fix(booking): sync cargo input accessibility with edit state

docs/business-index.md

@@ -37,7 +37,7 @@
 | 货柜双工作台、排柜、预装/装柜清单、真实柜号后补与整柜报关 | 国内 `modules/container-loading/pages/DomesticContainersView.vue`、海外 `OverseasContainersView.vue`，共享详情实现 `ContainerDetailView.vue`；预装详情 `modules/loading-lists/pages/PreloadPlanDetailView.vue`，资料/PDA 证据 `components/ContainerOverviewPanel.vue`，报关 `components/ContainerCustomsPanel.vue` | 规则见下文「货柜工作台规则」 |
 | 合柜报关 / 同柜不可拆组 | `modules/unified-orders/api/coLoadGroups.ts`、`pages/UnifiedOrdersView.vue`；装柜消费 `modules/container-loading/pages/SmartLoadingWorkbenchView.vue` | 前端只提交订单 ID；Backend `firstleg/loading/coload/` 展开并冻结每票全部可用入仓片段。成员数是入仓片段数，不等于订单票数；只要求同国内仓、同渠道，允许跨客户及不同目的仓港；分配、移除、取消均整组处理 |
 | 全局智能装柜工作台、入仓码候选与箱数分配 | `modules/container-loading/components/SmartLoadingDialog.vue` 内嵌 `pages/GlobalSmartLoadingView.vue`，柜次页 `SmartLoadingWorkbenchView.vue`，以及 `smartLoadingChannelGroups.ts`、`smartLoadingItems.ts`、`api/platformContainerLoading.ts`；全局页当前不注册独立路由 | Backend `firstleg/` 的 `/inbound-candidates`、`/containers`、`/inbound-assignments`、`/plans/{planId}/pending-review-assignments`、`/group-assignments`、`/unpicked-items`。`orderStatuses` 最多四项且未传表示全部未完成状态；候选状态多选覆盖待审核、待测量、待分柜、装柜中，状态只用于筛选展示，按钮资格以服务端 `canAssign` 为准；待审核/待测量可提前占位但不得提前确认预装或启动 PDA。计划箱数编辑上限、已用和未用展示只消费服务端 `totalPackageCount/remainingPackageCount`，不得从候选页或本地规格重新拼算。人工加入允许跨渠道，智能推荐仍按柜次渠道。柜次容量和限重取服务端字段；同柜组作为单卡整组分页、分配和移除，任一成员已拣时整组保留 |
-| 国内货柜履约订舱资料、打印、关联候选与出仓前船期 | `modules/ocean-bookings/` 的 `components/OceanBookingDocumentsPanel.vue`、`OceanBookingPrintDialog.vue`，以及 `modules/container-loading/`、`modules/port-schedules/` | 订舱草稿按当前版本维护资料，放舱后资料与表单只读；打印对草稿与已放舱订舱均开放，按当前已保存资料生成，未填写字段显示“—”。`platformOceanBookings.ts` 的 `/link-candidates` 只消费服务端分页，`containerCount` 是柜型需求 `quantity` 总和；Backend `firstleg/oceanbooking/`、`file/`、`print/`、`firstleg/portschedule/` |
+| 国内货柜履约订舱资料、打印、关联候选与出仓前船期 | `modules/ocean-bookings/` 的 `components/OceanBookingDocumentsPanel.vue`、`OceanBookingPrintDialog.vue`，以及 `modules/container-loading/`、`modules/port-schedules/` | 订舱草稿按当前版本维护资料，放舱后运输/预报/关系方/柜型/附件只读；客服实货量经 `/actual-cargo` 按编辑权限、版本、幂等键和原因补录；打印对草稿与已放舱订舱均开放，按当前已保存资料生成，托运单取委值，提单确认件取手工实值，未填显示“—”且不以委值回退。`platformOceanBookings.ts` 的 `/link-candidates` 只消费服务端分页，`containerCount` 是柜型需求 `quantity` 总和；Backend `firstleg/oceanbooking/`、`file/`、`print/`、`firstleg/portschedule/` |
 | 订舱级拖车预约 | `modules/trucking/api/platformTrucking.ts` 的 `/candidates`、`components/TruckAppointmentForm.vue`、`pages/TruckAppointmentCreateView.vue`、`TruckAppointmentsView.vue` | 表单只选择服务端返回的 `RELEASED` 订舱与 `TRUCKING + truckingScope=DOMESTIC` 国内拖车供应商，不选择或提交客户、柜次、装柜计划或真实集装箱号；清关提柜固定选择 `OVERSEAS` 海外车队，类型在供应商主档单选维护；提单号和仓库由订舱冻结事实带入。一个订舱最多一张非终态拖车单，重复创建转入现有单继续编辑；PDA 完成不自动推进拖车。附件为平台作用域且不重复提单文件；Backend `TruckAppointmentService`、`truck-appointments-v1.yaml` |
 | 目的港码头拖车与还空预警 | 海外清关提柜工作台/详情 `modules/container-loading/pages/OverseasContainersView.vue`、`OverseasContainerDetailView.vue`，API `modules/container-loading/api/terminalDrayages.ts`、`containerArrivalTimes.ts` | 与订舱级拖车预约是不同生命周期；按 `containerBookingId` 读取服务端状态、`allowedActions` 和历史，不能复用订舱级拖车表单或自行推进状态。列表“预计到仓”列直接提供人工日期时间选择器，保存时通过 Lastleg 柜级版本和幂等键原子更新该柜全部尾程订单，已有入库计划后禁止修改；“实际到仓”只读 `ll_receiving_container_session.receiving_at`，即海外 PDA 首次开始收货时间。还空截止、超时天/小时只展示服务端基于权威卸柜完成时间加 72 小时计算的结果；Backend `firstleg/terminaldrayage/`、`lastleg-service/`，邮件记录通过 `terminalDrayages.ts` 查询与重试。 |
 | 历史报关协同与国内出仓 | `modules/customs/`、`modules/outbound-dispatch/` | `modules/customs/` 是历史报关案件/清单/代理提交与回执入口；装柜完成后的整柜退税/买单资料从货柜详情进入，不在旧模块复制；Backend `firstleg/outbound/dispatch/`、`firstleg/customs/`、`file/` |

src/modules/appointment-calendar/WorkDispatchForm.vue

@@ -139,7 +139,7 @@ async function executeStep() {
     if (command.action === 'CONVERT') {
       const converted = value as ConvertedDraft
       if (converted.vehicles.length !== 1 || converted.vehicles[0]?.draftContainerId !== request.containerId) throw new DispatchInputError('整车结果与原装车容器不一致')
-      validateCommandResult(converted.vehicles[0]!.dispatch, { dispatchNo: '', action: 'CREATE', body: { idempotencyKey: request.dispatchKey }, attempted: true, rejected: false, result: null })
+      validateCommandResult(converted.vehicles[0]!.dispatch, { dispatchNo: '', action: 'CREATE', body: { idempotencyKey: request.dispatchKey } })
       request.converted = converted
     } else {
       const draft = value as DispatchDraft; requireVersion(draft.recordVersion)

src/modules/appointment-calendar/WorkSharedTripForm.test.ts

@@ -1,7 +1,7 @@
 import { flushPromises, mount } from '@vue/test-utils'
 import { beforeEach, expect, it, vi } from 'vitest'
 import WorkSharedTripForm from './WorkSharedTripForm.vue'
-import { getDispatch, useDispatchCommandRecovery, type CommandResult, type DispatchDetail } from '@/modules/overseas-warehouse'
+import { getDispatch, useDispatchCommandRecovery, type DispatchDetail } from '@/modules/overseas-warehouse'
 import type { LeaveGuard } from './useWorkDraft'
 const access = vi.hoisted(() => ({ allowed: true }))
 const identity = vi.hoisted(() => ({ id: '' }))
@@ -25,11 +25,14 @@ it('honors native stage/gate and permissions and rejects a different returned bu
   vi.mocked(getDispatch).mockResolvedValueOnce(detail('WRONG')); const wrong = render(); await flushPromises(); expect(wrong.get('[role="alert"]').text()).toContain('原排车单不一致'); wrong.unmount()
   access.allowed = false; const count = vi.mocked(getDispatch).mock.calls.length, denied = render(); await flushPromises(); expect(getDispatch).toHaveBeenCalledTimes(count); denied.unmount()
 })
-it('retains an unknown original add command after the overlay closes and offers recovery without a new key', async () => {
-  const recovery = useDispatchCommandRecovery(() => identity.id); recovery.begin('DS-60', 'ADD_CARGO', { recordVersion: 0, idempotencyKey: 'original-key', cargo: [], batchAllocations: [] })
-  const wrapper = render(); await flushPromises(); expect(button(wrapper, '选择同仓未安排货物').attributes('disabled')).toBeDefined(); expect(await guard()).toBe(false)
-  await button(wrapper, '核对原加货请求').trigger('click'); expect(wrapper.getComponent({ name: 'DispatchWorkflowDialog' }).props('modelValue')).toBe(true)
-  expect(recovery.pending.value?.body.idempotencyKey).toBe('original-key'); wrapper.getComponent({ name: 'DispatchWorkflowDialog' }).vm.$emit('update:modelValue', false); await flushPromises(); expect(await guard()).toBe(false); wrapper.unmount()
+it('ignores an old add command without blocking the calendar or another action',async()=>{
+  sessionStorage.setItem('dispatch-command:'+identity.id,JSON.stringify({dispatchNo:'DS-60',action:'ADD_CARGO',attempted:true,body:{idempotencyKey:'old'}}))
+  const wrapper=render();await flushPromises()
+  expect(button(wrapper,'选择同仓未安排货物').attributes('disabled')).toBeUndefined()
+  expect(await guard()).toBe(true)
+  expect(sessionStorage.getItem('dispatch-command:'+identity.id)).toBeNull()
+  expect(wrapper.text()).not.toContain('原排车请求尚未核对')
+  wrapper.unmount()
 })
 it('retries lookup as a read and keeps the original detail navigation', async () => {
   vi.mocked(getDispatch).mockRejectedValueOnce(new Error('lookup failed')); const wrapper = render(); await flushPromises(); await wrapper.get('[role="alert"] button').trigger('click'); await flushPromises(); expect(getDispatch).toHaveBeenCalledTimes(2)
@@ -50,22 +53,12 @@ it.each([false, true])('refreshes the original add-cargo gate after a rejection
   if (!readFails) expect(wrapper.text()).toContain('货物已开始真实拣货')
   wrapper.unmount()
 })
-it('offers read refresh for proven add-cargo success while retaining the exact original command', async () => {
-  const recovery = useDispatchCommandRecovery(() => identity.id)
-  recovery.begin('DS-60', 'ADD_CARGO', { recordVersion: 0, idempotencyKey: 'known-key', cargo: [], batchAllocations: [] })
-  recovery.pending.value!.attempted = true
-  const completed: CommandResult = {
-    dispatchNo: 'DS-60', action: 'ADD_CARGO', idempotencyKey: 'known-key', recordVersion: 1, status: 'ACTIVE', stage: 'BEFORE_LOADING',
-    occurredAt: '2026-10-20T00:00:00Z', effect: 'APPLIED', counts: { itemCount: 1, palletCount: 1, packageCount: 60, pickedPackageCount: 0, shippedPackageCount: 0 },
-    replayed: false, alreadyArranged: false, result: { dispatchNo: 'DS-60', changedItemIds: [] },
-  }
-  recovery.pending.value!.result = completed
-  const wrapper = render(); await flushPromises()
-  expect(wrapper.text()).toContain('操作已完成，页面资料待刷新')
-  expect(wrapper.text()).not.toContain('原排车请求尚未核对')
-  await button(wrapper, '刷新加货资料').trigger('click')
-  expect(wrapper.getComponent({ name: 'DispatchWorkflowDialog' }).props('modelValue')).toBe(true)
-  expect(recovery.pending.value!.body.idempotencyKey).toBe('known-key')
+it('does not offer a stored command replay when opening the form again',async()=>{
+  sessionStorage.setItem('dispatch-command:'+identity.id,JSON.stringify({dispatchNo:'DS-60',action:'ADD_CARGO',attempted:true,result:{recordVersion:1}}))
+  const wrapper=render();await flushPromises()
+  expect(wrapper.text()).not.toContain('刷新加货资料')
+  expect(button(wrapper,'选择同仓未安排货物').attributes('disabled')).toBeUndefined()
+  expect(useDispatchCommandRecovery(()=>identity.id).pending.value).toBeNull()
   wrapper.unmount()
 })
 it('clears a prior add-cargo rejection after the corrected original-dispatch workflow succeeds', async () => {

src/modules/appointment-calendar/WorkSharedTripForm.vue

@@ -31,9 +31,6 @@ async function load() {
   finally { if (current === generation) loading.value = false }
 }
 function prepare() { if (allowed.value && !loading.value && !recovery.pending.value) { rejectionError.value = null; open.value = true } }
-function recover() {
-  if (recovery.pending.value?.dispatchNo === props.dispatchNo && recovery.pending.value.action === 'ADD_CARGO') open.value = true
-}
 function saved() { open.value = false; rejectionError.value = null; emit('updated'); void load() }
 function rejected(details: ApiErrorDetails) { rejectionError.value = details; emit('updated'); void load() }
 watch(() => props.dispatchNo, load, { immediate: true })
@@ -47,7 +44,6 @@ onBeforeUnmount(() => { generation++; emit('busy', false) })
     <LoadErrorState v-if="rejectionError" title="本车加货未完成" :message="rejectionError.message" :show-retry="false"><template #details><ApiErrorMeta :details="rejectionError" /></template></LoadErrorState>
     <p v-if="detail">{{ detail.vehicleInfo.vehicle?.plate || '车辆待维护' }} · {{ detail.counts.packageCount }} 箱</p>
     <p v-if="detail && !allowed">{{ detail.actions.ADD_CARGO?.blockReason || '当前阶段或权限不允许加货，请从原排车单继续作业。' }}</p>
-    <p v-if="recovery.pending.value">{{ recovery.pending.value.result ? '原排车操作已完成，页面资料待刷新，不能另发加货命令。' : '原排车请求尚未核对，不能另发加货命令。' }}<el-button v-if="recovery.pending.value.dispatchNo === dispatchNo && recovery.pending.value.action === 'ADD_CARGO'" @click="recover">{{ recovery.pending.value.result ? '刷新加货资料' : '核对原加货请求' }}</el-button></p>
     <el-button :disabled="!allowed || busy" :loading="loading" @click="prepare">选择同仓未安排货物</el-button><el-button v-if="readable" :disabled="busy" @click="emit('external', `/overseas-warehouse/dispatches/${encodeURIComponent(dispatchNo)}`)">查看原排车单</el-button>
     <DispatchWorkflowDialog v-model="open" :dispatch-no="dispatchNo" action="ADD_CARGO" @saved="saved" @rejected="rejected" />
   </section>

src/modules/container-loading/components/ContainerCustomsPanel.test.ts

@@ -114,12 +114,12 @@ describe('ContainerCustomsPanel', () => {
     wrapper.unmount()
   })
 
-  it('开始报关确认显示柜次号，取消不会冻结资料或调用开始接口', async () => {
+  it('开始报关确认使用简短文案，取消不会冻结资料或调用开始接口', async () => {
     const confirm = vi.spyOn(ElMessageBox, 'confirm').mockRejectedValueOnce('cancel')
     const wrapper = await render('READY_TO_START')
     await wrapper.findAll('button').find(button => button.text() === '开始报关')!.trigger('click')
     await flushPromises()
-    expect(confirm).toHaveBeenCalledWith(expect.any(String), '开始整柜报关 · MCR08290001', expect.objectContaining({ customClass: 'admin-density-confirm' }))
+    expect(confirm).toHaveBeenCalledWith('确认开始整柜报送?', '整柜报关', expect.objectContaining({ customClass: 'admin-density-confirm', confirmButtonText: '确认' }))
     expect(api.start).not.toHaveBeenCalled()
     confirm.mockRestore()
     wrapper.unmount()

src/modules/container-loading/components/ContainerCustomsPanel.vue

@@ -183,7 +183,7 @@ async function resolveFormalResult(batch: DeclarationBatch, result: DeclarationB
 async function start() {
   if (!customs.value || customs.value.status !== 'READY_TO_START') return
   try {
-    await ElMessageBox.confirm('开始后将冻结客户当前退税资料版本、关联入仓码覆盖范围及平台买单准备事实，确认开始整柜报关？', customsDialogTitle('开始整柜报关'), { customClass: 'admin-density-confirm', type: 'warning', confirmButtonText: '确认开始' })
+    await ElMessageBox.confirm('确认开始整柜报送?', '整柜报关', { customClass: 'admin-density-confirm', type: 'warning', confirmButtonText: '确认' })
   } catch { return }
   actionLoading.value = true; actionError.value = null
   try { customs.value = await startContainerCustoms(props.loadingPlanId, customs.value.version); ElMessage.success('整柜报关已开始') }

src/modules/container-loading/index.ts

@@ -1,4 +1,5 @@
 export * from './api/platformContainerLoading'
+export { listContainerArrivalTimes, type ContainerArrivalTime } from './api/containerArrivalTimes'
 export * from './types'
 export { projectWarehouseArrival } from './warehouseArrival'
 export { getSmartLoadingChannelGroup, isSeaRailChannel, SMART_LOADING_CHANNEL_GROUPS } from './smartLoadingChannelGroups'

src/modules/customers/customerDensity.css

@@ -59,6 +59,8 @@
 
 
 /* Customer dialog business geometry; common appearance stays in adminDensity.css. */
+.customer-editor-dialog .density-form--outlined { --el-border-radius-base: var(--cc-radius-lg); }
+.customer-editor-dialog .density-form--outlined .el-input-number .el-input__inner { text-align: left; }
 .customer-editor-dialog .customer-editor-table { table-layout: fixed; }
 .customer-editor-dialog .customer-editor-table td:not([colspan]) { width: calc(100% / 3); }
 .customer-review-table th { width: 120px; }

src/modules/customers/pages/CustomersView.test.ts

@@ -182,7 +182,7 @@ describe('CustomersView', () => {
   it('searches the customer list by customer name only', () => {
     expect(customersSource).toContain("label: '客户名称', placeholder: '请输入客户名称'")
     expect(customersSource).toContain("label: '客户昵称'")
-    expect(customersSource).toContain('中文拼音大写首字母，如 SZWL')
+    expect(customersSource).toContain('placeholder="选填，默认自动生成"')
     expect(customersSource).not.toContain('公司名称、客户编号或联系人')
     expect(customersSource).not.toContain('row.tenantCode.toLowerCase().includes(keyword)')
     expect(customersSource).not.toContain('String(row.id).includes(keyword)')
@@ -210,12 +210,16 @@ describe('CustomersView', () => {
     expect(document.querySelector<HTMLElement>('.customer-editor-dialog .qualification-credit-code .el-form-item__label')?.style.width).toBe('144px')
     const company = document.querySelector<HTMLInputElement>('.customer-editor-dialog input[placeholder="请输入工商登记公司名称"]')!
     expect(company.closest('.el-form-item')?.querySelector<HTMLElement>('.el-form-item__label')?.style.width).toBe('120px')
+    const legalName = document.querySelector<HTMLInputElement>('.customer-editor-dialog input[placeholder="请输入营业执照上的企业名称"]')!
+    expect(legalName.closest('.el-form-item')?.querySelector<HTMLElement>('.el-form-item__label')?.style.width).toBe('144px')
+    expect(company.closest('form')?.classList.contains('density-form--outlined')).toBe(true)
     company.value = ''
     company.dispatchEvent(new Event('input', { bubbles: true }))
     await flushPromises()
     company.dispatchEvent(new FocusEvent('blur'))
     await vi.waitFor(() => expect(company.closest('.el-form-item')?.querySelector('.el-form-item__error')?.textContent).toContain('请输入公司名称'))
     expect(document.querySelector('.customer-editor-dialog .el-dialog__footer')?.textContent).toContain('保存资料和资质')
+    expect(document.querySelector('.customer-editor-dialog .el-dialog__footer')?.textContent).not.toContain('保存资料时会一并上传已选资质')
     expect(updatePlatformTenant).not.toHaveBeenCalled()
   })
 

src/modules/customers/pages/CustomersView.vue

@@ -1085,10 +1085,10 @@ onMounted(() => { void loadCustomers() })
     </ListPageLayout>
 
     <AppDialog v-model="editorOpen" :title="editorTitle" :width="editorDialogWidth" class="admin-density-dialog customer-density-dialog customer-editor-dialog admin-workbench is-dialog" :loading="editorLoading" :confirm-loading="saving" fullscreenable destroy-on-close>
-      <el-form ref="formRef" v-loading="editorLoading" :model="form" :rules="rules" label-position="left" label-width="120px" class="density-form density-dialog-sections" :disabled="editorLoading || saving || submitting || uploadingQualifications">
+      <el-form ref="formRef" v-loading="editorLoading" :model="form" :rules="rules" label-position="left" label-width="120px" class="density-form density-form--outlined density-dialog-sections" :disabled="editorLoading || saving || submitting || uploadingQualifications">
         <section class="density-dialog-section workbench-evidence"><h3 class="density-dialog-section__title">基础资料</h3>
           <table class="density-table density-table--editable customer-editor-table" aria-label="基础资料"><tbody>
-            <tr><td><el-form-item label="公司名称" prop="tenantName" required><el-input v-model="form.tenantName" placeholder="请输入工商登记公司名称" maxlength="128" /></el-form-item></td><td><el-form-item label="客户昵称" prop="customerNickname"><el-input v-model="form.customerNickname" placeholder="不填默认生成中文拼音大写首字母，如 SZWL" maxlength="32" /></el-form-item></td><td><el-form-item label="营业执照企业名称" prop="legalName" required><el-input v-model="form.legalName" placeholder="请输入营业执照上的企业名称" maxlength="128" /></el-form-item></td></tr>
+            <tr><td><el-form-item label="公司名称" prop="tenantName" required><el-input v-model="form.tenantName" placeholder="请输入工商登记公司名称" maxlength="128" /></el-form-item></td><td><el-form-item label="客户昵称" prop="customerNickname"><el-input v-model="form.customerNickname" placeholder="选填，默认自动生成" maxlength="32" /></el-form-item></td><td><el-form-item label="营业执照企业名称" prop="legalName" label-width="144px" required><el-input v-model="form.legalName" placeholder="请输入营业执照上的企业名称" maxlength="128" /></el-form-item></td></tr>
             <tr><td><el-form-item label="法定代表人" prop="legalRepresentative"><el-input v-model="form.legalRepresentative" placeholder="请输入法定代表人姓名（选填）" maxlength="64" /></el-form-item></td><td><el-form-item label="企业类型" prop="enterpriseType"><el-input v-model="form.enterpriseType" placeholder="如：有限责任公司" maxlength="64" /></el-form-item></td><td><el-form-item label="成立日期" prop="establishedDate"><el-date-picker style="width: 100%;" v-model="form.establishedDate" type="date" value-format="YYYY-MM-DD" placeholder="请选择成立日期" :disabled-date="(date: Date) => date.getTime() > Date.now()" /></el-form-item></td></tr>
             <tr><td colspan="3"><el-form-item label="注册资本" prop="registeredCapital"><div class="capital-input"><el-input-number v-model="form.registeredCapital" :min="0" :precision="2" controls-position="right" placeholder="请输入注册资本（选填）" /><el-select v-model="form.registeredCapitalCurrency" aria-label="注册资本币种"><el-option label="人民币 CNY" value="CNY" /><el-option label="美元 USD" value="USD" /><el-option label="港币 HKD" value="HKD" /></el-select></div></el-form-item></td></tr>
             <tr><td colspan="3"><el-form-item label="注册地址" prop="registeredAddress"><el-input v-model="form.registeredAddress" placeholder="请输入省市区、街道及门牌信息" maxlength="500" /></el-form-item></td></tr>
@@ -1103,8 +1103,8 @@ onMounted(() => { void loadCustomers() })
           </tbody></table>
         </section>
 
-        <section class="density-dialog-section qualification-section workbench-evidence"><h3 class="density-dialog-section__title">企业认证资料<InlineHelp title="资质提交规则"><p>营业执照和18位统一社会信用代码为必填业务项；法人身份证、货代资质证书和银行开户许可证均为选填。</p><p>支持 PDF、JPG、PNG，单个文件不超过 5MB；<span>*</span> 为提交审核必填项。</p></InlineHelp></h3><div v-if="editorStatus" class="qualification-heading"><el-tag :type="statusMeta(editorStatus).type" effect="light">{{ statusMeta(editorStatus).label }}</el-tag></div>
-          <table class="density-table density-table--editable" aria-label="企业信用代码"><tbody><tr><td><el-form-item label="统一社会信用代码" prop="unifiedSocialCreditCode" label-width="144px" required class="qualification-credit-code"><span v-if="creditCodeEstablished">{{ form.unifiedSocialCreditCode }}</span><el-input v-else v-model="form.unifiedSocialCreditCode" placeholder="请输入18位大写字母或数字" maxlength="18" @input="form.unifiedSocialCreditCode = String($event).toUpperCase()" /><small>{{ creditCodeEstablished ? '已登记的统一社会信用代码不可直接修改。' : '必须与营业执照一致，并随营业执照共同保存；法人身份证为选填。' }}</small></el-form-item></td></tr></tbody></table>
+        <section class="density-dialog-section qualification-section workbench-evidence"><h3 class="density-dialog-section__title">企业认证资料<InlineHelp title="资质提交规则"><p>营业执照和18位统一社会信用代码为必填业务项；法人身份证、货代资质证书和银行开户许可证均为选填。</p><p>支持 PDF、JPG、PNG，单个文件不超过 5MB；<span>*</span> 为提交审核必填项。</p></InlineHelp><el-tag v-if="editorStatus" :type="statusMeta(editorStatus).type" effect="light">{{ statusMeta(editorStatus).label }}</el-tag></h3>
+          <table class="density-table density-table--editable" aria-label="企业信用代码"><tbody><tr><td><el-form-item label="统一社会信用代码" prop="unifiedSocialCreditCode" label-width="144px" required class="qualification-credit-code"><span v-if="creditCodeEstablished">{{ form.unifiedSocialCreditCode }}</span><el-input v-else v-model="form.unifiedSocialCreditCode" placeholder="请输入18位大写字母或数字" maxlength="18" @input="form.unifiedSocialCreditCode = String($event).toUpperCase()" /><small v-if="!creditCodeEstablished">必须与营业执照一致，并随营业执照共同保存；法人身份证为选填。</small></el-form-item></td></tr></tbody></table>
           <div v-if="qualificationLoadError" class="qualification-load-error" role="alert">{{ qualificationLoadError }}<el-button v-if="editingId" link type="primary" @click="loadEditorQualifications(editingId)">重试</el-button></div>
           <div class="qualification-table" role="table" aria-label="客户资质文件">
             <div class="qualification-row qualification-header" role="row"><span role="columnheader">文件类型</span><span role="columnheader">上传文件</span><span role="columnheader">有效期</span></div>
@@ -1124,7 +1124,7 @@ onMounted(() => { void loadCustomers() })
 
         </section>
       </el-form>
-      <template #footer><div class="customer-editor-footer"><span>保存资料时会一并上传已选资质；进入审核仍需点击“提交审核”并再次确认</span><div class="density-actions density-actions--footer"><el-button :disabled="editorLoading || saving || submitting || uploadingQualifications" @click="editorOpen = false">关闭</el-button><el-button :loading="saving" :disabled="editorLoading || submitting || uploadingQualifications" @click="saveCustomer">保存资料和资质</el-button><el-button v-if="canSubmitReview" type="primary" :loading="submitting" :disabled="editorLoading || saving || uploadingQualifications" @click="submitReview">提交审核</el-button></div></div></template>
+      <template #footer><div class="customer-editor-footer"><div class="density-actions density-actions--footer"><el-button :disabled="editorLoading || saving || submitting || uploadingQualifications" @click="editorOpen = false">关闭</el-button><el-button :loading="saving" :disabled="editorLoading || submitting || uploadingQualifications" @click="saveCustomer">保存资料和资质</el-button><el-button v-if="canSubmitReview" type="primary" :loading="submitting" :disabled="editorLoading || saving || uploadingQualifications" @click="submitReview">提交审核</el-button></div></div></template>
     </AppDialog>
 
     <AppDialog v-model="qualificationPreviewOpen" :title="customerDialogTitle('查看资质文件', editorCustomer)" width="min(860px, calc(100vw - 28px))" class="admin-density-dialog customer-density-dialog qualification-preview-dialog customer-qualification-preview admin-workbench is-dialog" fullscreenable destroy-on-close :show-confirm="false" cancel-text="关闭预览">
@@ -1183,13 +1183,12 @@ onMounted(() => { void loadCustomers() })
       <div class="density-dialog-section qualification-preview" data-tone="source"><img v-if="reviewPreviewUrl && reviewPreviewKind === 'image'" :src="reviewPreviewUrl" :alt="`${reviewPreviewName}预览`" /><iframe v-else-if="reviewPreviewUrl" :src="reviewPreviewUrl" :title="`${reviewPreviewName} PDF 预览`" /></div>
     </AppDialog>
 
-    <AppDialog v-model="passwordDialogOpen" :title="customerDialogTitle('重置客户密码', passwordTenant)" :confirm-loading="passwordSubmitting" width="min(520px, calc(100vw - 28px))" class="admin-density-dialog customer-density-dialog customer-password-dialog admin-workbench is-dialog" :close-on-click-modal="false" :close-on-press-escape="!passwordSubmitting" :show-close="!passwordSubmitting">
-      <div v-if="passwordTenant" class="decision-summary"><div><strong>正在重置企业管理员登录密码</strong><span>{{ passwordTenant.tenantName }}</span></div><span>客户编号：{{ passwordTenant.tenantCode }}</span></div>
+    <AppDialog v-model="passwordDialogOpen" title="重置客户密码" :confirm-loading="passwordSubmitting" width="min(520px, calc(100vw - 28px))" class="admin-density-dialog customer-density-dialog customer-password-dialog admin-workbench is-dialog" :close-on-click-modal="false" :close-on-press-escape="!passwordSubmitting" :show-close="!passwordSubmitting">
+      <div v-if="passwordTenant" class="decision-summary"><div><strong>正在重置企业管理员登录密码</strong></div><span>客户编号：{{ passwordTenant.tenantCode }}</span></div>
       <el-form ref="passwordFormRef" :model="passwordForm" :rules="passwordRules" label-position="top" class="density-form">
         <el-form-item label="新密码" prop="newPassword" required><div class="password-input-row"><el-input v-model="passwordForm.newPassword" type="password" show-password autocomplete="new-password" placeholder="请输入 8-20 位新密码" /><el-button @click="randomPassword">随机生成</el-button></div></el-form-item>
         <el-form-item label="确认新密码" prop="confirmPassword" required><el-input v-model="passwordForm.confirmPassword" type="password" show-password autocomplete="new-password" placeholder="请再次输入新密码" /></el-form-item>
         <el-checkbox v-model="passwordForm.forceChangePassword">客户下次登录时必须修改密码</el-checkbox>
-        <p class="density-dialog-note">重置对象为企业 OWNER 管理员，原密码将立即失效。</p>
       </el-form>
       <template #footer><div class="density-actions density-actions--footer"><el-button :disabled="passwordSubmitting" @click="passwordDialogOpen = false">取消</el-button><el-button type="primary" :loading="passwordSubmitting" @click="submitResetPassword">确认重置</el-button></div></template>
     </AppDialog>
@@ -1219,7 +1218,7 @@ onMounted(() => { void loadCustomers() })
 .customer-company-name { display:block; overflow:hidden; color:var(--workbench-text); font-weight:500; text-overflow:ellipsis; white-space:nowrap; }
 :deep(.customer-list-table .customer-code-column .cell) { white-space:nowrap; }
 .capital-input { display:grid; grid-template-columns:minmax(0,1fr) 130px; width:100%; gap:var(--admin-space-3, 8px); } .capital-input :deep(.el-input-number) { width:100%; } .capital-input :deep(.el-select) { width:100%; }
-.qualification-heading { display:flex; justify-content:flex-end; margin-bottom:var(--admin-space-5, 12px); } .qualification-hint { margin:var(--admin-space-5, 12px) 0 0; color:var(--workbench-muted); font-size:var(--admin-font-caption, 12px); line-height:1.6; } .qualification-hint span { color:var(--el-color-danger); } .qualification-label > span { color:var(--el-color-danger); }
+.qualification-hint { margin:var(--admin-space-5, 12px) 0 0; color:var(--workbench-muted); font-size:var(--admin-font-caption, 12px); line-height:1.6; } .qualification-hint span { color:var(--el-color-danger); } .qualification-label > span { color:var(--el-color-danger); }
 .qualification-credit-code small { display:block; margin-top:var(--admin-space-2, 6px); color:var(--workbench-muted); font-size:var(--admin-font-caption, 11px); line-height:1.5; } .field-hint { display:block; margin-top:var(--admin-space-2, 6px); color:var(--workbench-muted); line-height:1.5; }
 .qualification-table { container-type:inline-size; overflow:hidden; margin-top:14px; border:1px solid var(--workbench-border); border-radius:8px; } .qualification-row { display:grid; grid-template-columns:170px minmax(0,1fr) 220px; min-width:0; border-top:1px solid var(--workbench-border); } .qualification-row:first-child { border-top:0; } .qualification-row > * { display:flex; min-width:0; align-items:center; } .qualification-header { min-height:44px; background:var(--cc-list-table-header-bg); color:var(--cc-list-table-header-text); font-size:var(--admin-font-caption, 12px); font-weight:600; }
 .qualification-label { gap:5px; font-weight:600; } .qualification-label svg { margin-left:auto; color:var(--el-color-success); }
@@ -1240,7 +1239,7 @@ onMounted(() => { void loadCustomers() })
 .qualification-preview-placeholder small { font-size:var(--admin-font-caption, 10px); font-weight:700; }
 .qualification-preview-action { position:absolute; inset:auto 0 0; display:flex; min-height:22px; align-items:center; justify-content:center; gap:3px; background:rgba(23,32,51,.78); color:var(--workbench-surface); }
 .qualification-load-error { display:flex; align-items:center; justify-content:space-between; gap:var(--admin-space-4, 10px); margin-top:var(--admin-space-5, 12px); padding:var(--admin-space-4, 10px) var(--admin-space-5, 12px); border:1px solid #fecdca; border-radius:6px; background:#fffafa; color:#b42318; font-size:var(--admin-font-caption, 12px); }
-.customer-editor-footer { display:flex; align-items:center; justify-content:space-between; gap:var(--admin-space-6, 16px); } .customer-editor-footer > span { color:var(--workbench-muted); font-size:var(--admin-font-caption, 12px); text-align:left; }
+.customer-editor-footer { display:flex; align-items:center; justify-content:flex-end; gap:var(--admin-space-6, 16px); }
 .decision-summary { display:flex; min-width:0; align-items:center; justify-content:space-between; gap:var(--admin-space-5, 12px); background:var(--workbench-surface-soft); } .decision-summary > * { min-width:0; overflow-wrap:anywhere; } .decision-summary strong { color:var(--workbench-text); font-size:var(--admin-font-body, 13px); } .decision-summary span { color:var(--workbench-muted); font-size:var(--admin-font-caption, 11px); }
 .review-document-state { padding:14px; color:var(--workbench-muted); font-size:var(--admin-font-caption, 12px); }
 .review-document-error { padding:14px; color:var(--workbench-muted); font-size:var(--admin-font-caption, 12px); }

src/modules/ocean-bookings/AGENTS.md

@@ -20,12 +20,14 @@
 
 ## 关键边界
 
-- 订舱草稿按当前版本维护资料；放舱后资料与表单只读，不允许绕过版本直接改字段。
-- 打印对草稿与已放舱订舱均开放，按当前**已保存**资料生成，未填写字段显示“—”，不用未保存的表单值。
+- 订舱草稿按当前版本维护资料；放舱后运输、关系方、柜型需求、预报货量和附件只读；仅实货量可由订舱编辑权限通过 `/actual-cargo` 按版本、幂等键和原因补录并审计，禁止绕过运输冻结边界。
+- 打印对草稿与已放舱订舱均开放，按当前**已保存**资料生成，未填写字段显示“—”，不用未保存的表单值。托运单取委值，提单确认件取实值；实值由客服手工录入，不回退为委值，不生成正式提单。
 - 关联候选只消费服务端 `/link-candidates` 分页结果，不在浏览器重排或本地拼接候选。
 - 订舱是拖车预约的唯一归属：拖车由 `../trucking/` 创建，本模块不直接建拖车单。
 - 出仓前船期只展示订舱级计划，实际节点归 `../port-schedules/` 与海外回写，本模块不写实际时间。
 
+- 本轮布局与操作证据维护在 `PROTOTYPE_MATRIX.md`，缺截图时保留待人工确认。
+
 ## 验证
 
 - 定向：`pnpm test src/modules/ocean-bookings/<目标测试>`；资料字段或打印变更同时核对 `print/` 模板与 `file/` 附件契约。

src/modules/ocean-bookings/PROTOTYPE_MATRIX.md

@@ -0,0 +1,13 @@
+# 订舱页面受影响操作核对
+
+业务依据为用户提供的《订舱信息页面说明.docx》及页面截图；本轮确认：放舱后仅补实货量、客服手工录入、保留现有提单确认件，正式提单从外部附件接收。样式使用 `docs/Admin高密度界面规范.md` 的详情与基本信息、蓝白主题及既有公共密度。用户后续提供现页与产品稿对比，确认现页缺少层次、重点且间距过大；订舱页以该产品稿为局部视觉依据：紧凑页头、蓝色圆点连线流程、编号区块、细线小标题、浅底三方卡片及右下主打印按钮。可编辑输入、下拉和文本域使用白底、清晰边框与文字，悬停/聚焦使用蓝色反馈；灰底和禁止光标仅用于真实禁用状态，校验错误仍保留组件错误色。
+
+流程条根据已保存订舱、当前未保存修改、放舱状态及实货量推进：当前步骤蓝底，已完成节点勾选，待处理灰色。第一步的“已保存”不代替放舱完整性校验；打印节点仅在本次页面成功生成对应数据的 PDF 预览后显示“已预览”，失败或只点击按钮不推进，也不声称实际打印完成。预览标记随本次页面保留，刷新后按服务端保存/放舱/实值恢复进度，打印仍可重新预览；单据消费的数据改变后，该单据重新进入待预览。
+
+| 页面/路由 | 操作 | 参考承载与布局 | 当前实现 | 人工结论 |
+|---|---|---|---|---|
+| `/ocean-bookings/new`、`/ocean-bookings/:bookingId` | 草稿新增、维护 | 独立页面；左主资料、右三方并排，下方放舱资料 | 独立页面；按产品稿重排视觉层级，保留仓库、渠道、预计到港、多柜型和附件；港代码与港名成组、委实成对输入，新增保存留在详情 | 待人工截图确认 |
+| `/ocean-bookings/:bookingId` | 已放舱补实 | 客服补录实际货量 | 运输及预报只读，实值可按编辑权限补录，原因必填并版本审计 | 待人工截图确认 |
+| `/ocean-bookings/:bookingId` | 托运单、提单确认件 | 两个作业入口，A4单据预览 | 两张业务卡片底部右侧的蓝色主按钮，分别直达现有PDF预览；读已保存委/实数据，缺失显示“—” | 待人工截图确认 |
+
+人工按 1920×1080、100% 缩放核对三方长名称/地址、两类货量、保存失败与版本冲突、冻结/无编辑权限，以及两类 PDF 预览的打开、关闭和重开。自动检查结果在交付中单独报告，不能代替人工截图。

src/modules/ocean-bookings/api/platformOceanBookings.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi } from 'vitest'
-import { createOceanBooking, deleteOceanBookingDraft, downloadOceanBookingDocument, downloadOceanBookingPrint, invalidateOceanBookingDocument, listOceanBookingAgents, listOceanBookingDocuments, listOceanBookingLinkCandidates, listOceanBookings, listWarehouseLogisticsChannels, referenceOceanBookingDocument, releaseOceanBooking, updateOceanBookingDraft, uploadOceanBookingDocument } from './platformOceanBookings'
+import { createOceanBooking, deleteOceanBookingDraft, downloadOceanBookingDocument, downloadOceanBookingPrint, invalidateOceanBookingDocument, listOceanBookingAgents, listOceanBookingDocuments, listOceanBookingLinkCandidates, listOceanBookings, listWarehouseLogisticsChannels, referenceOceanBookingDocument, releaseOceanBooking, updateOceanBookingActualCargo, updateOceanBookingDraft, uploadOceanBookingDocument } from './platformOceanBookings'
 import { http } from '@/shared/api/http'
 
 const detailResponse = (version = 0, status = 'DRAFT') => ({
@@ -14,6 +14,17 @@ const detailResponse = (version = 0, status = 'DRAFT') => ({
 })
 
 describe('ocean bookings api', () => {
+  it('sends actual cargo only to the versioned supplement endpoint and normalizes decimal responses', async () => {
+    const payload = { expectedVersion: 3, actualPackageCount: 480, actualGrossWeightKg: 14000.125, actualVolumeCbm: 65.321, reason: '客服补录' }
+    const response = detailResponse(4, 'RELEASED')
+    const put = vi.spyOn(http, 'put').mockResolvedValue({ code: '200', data: {
+      ...response, oceanBooking: { ...response.oceanBooking, actualPackageCount: 480, actualGrossWeightKg: '14000.125', actualVolumeCbm: '65.321', declaredPackageCount: 500 },
+    } })
+    const saved = await updateOceanBookingActualCargo('123', payload)
+    expect(put).toHaveBeenCalledWith('/platform/v1/ocean-bookings/123/actual-cargo', payload, { headers: { 'Idempotency-Key': expect.any(String) } })
+    expect(saved).toMatchObject({ status: 'RELEASED', version: 4, actualPackageCount: 480, actualGrossWeightKg: 14000.125, actualVolumeCbm: 65.321, declaredPackageCount: 500 })
+  })
+
   it('preserves the backend history creation timestamp when normalizing a detail response', async () => {
     const createdAt = '2026-10-20T09:12:34'
     const post = vi.spyOn(http, 'post').mockResolvedValue({ code: '200', data: {

src/modules/ocean-bookings/api/platformOceanBookings.ts

@@ -1,6 +1,6 @@
 import axios from 'axios'
 import { ApiResponseError, http, unwrapApiResponse, type ApiEnvelope } from '@/shared/api/http'
-import type { OceanBookingAgentOption, OceanBookingCarrierCode, OceanBookingDetail, OceanBookingDocument, OceanBookingDocumentInvalidation, OceanBookingDocumentMutation, OceanBookingDocumentType, OceanBookingLinkCandidatePage, OceanBookingLinkCandidateQuery, OceanBookingPage, OceanBookingPrintType, OceanBookingQuery, OceanBookingResource, OceanBookingSaveRequest, OceanBookingStatus, OceanBookingReleaseRequest } from '../types'
+import type { OceanBookingActualCargoRequest, OceanBookingAgentOption, OceanBookingCarrierCode, OceanBookingDetail, OceanBookingDocument, OceanBookingDocumentInvalidation, OceanBookingDocumentMutation, OceanBookingDocumentType, OceanBookingLinkCandidatePage, OceanBookingLinkCandidateQuery, OceanBookingPage, OceanBookingPrintType, OceanBookingQuery, OceanBookingResource, OceanBookingSaveRequest, OceanBookingStatus, OceanBookingReleaseRequest } from '../types'
 
 const basePath = '/platform/v1/ocean-bookings'
 const maxErrorEnvelopeBytes = 1024 * 1024
@@ -21,6 +21,12 @@ function booking(raw: OceanBookingResource): OceanBookingResource {
     carrierCode: raw.carrierCode ?? null,
     bookingAgentId: raw.bookingAgentId == null ? null : String(raw.bookingAgentId),
     containerCount: Number(raw.containerCount ?? 0),
+    declaredPackageCount: raw.declaredPackageCount == null ? null : Number(raw.declaredPackageCount),
+    declaredGrossWeightKg: raw.declaredGrossWeightKg == null ? null : Number(raw.declaredGrossWeightKg),
+    declaredVolumeCbm: raw.declaredVolumeCbm == null ? null : Number(raw.declaredVolumeCbm),
+    actualPackageCount: raw.actualPackageCount == null ? null : Number(raw.actualPackageCount),
+    actualGrossWeightKg: raw.actualGrossWeightKg == null ? null : Number(raw.actualGrossWeightKg),
+    actualVolumeCbm: raw.actualVolumeCbm == null ? null : Number(raw.actualVolumeCbm),
     pol: raw.pol ?? raw.departurePortName ?? null,
     pod: raw.pod ?? raw.destinationPortName ?? null,
     carrierName: raw.carrierName ?? raw.shippingCompanyName ?? null,
@@ -88,6 +94,10 @@ export async function getOceanBooking(id: string) { const response = await http.
 function idempotencyKey() { return `ocean-booking-${Date.now()}-${Math.random().toString(36).slice(2)}` }
 export async function createOceanBooking(payload: OceanBookingSaveRequest) { const response = await http.post<ApiEnvelope<OceanBookingDetail>, ApiEnvelope<OceanBookingDetail>>(basePath, payload, { headers: { 'Idempotency-Key': idempotencyKey() } }); return detail(unwrapApiResponse(response)) }
 export async function updateOceanBookingDraft(id: string, payload: OceanBookingSaveRequest) { const response = await http.put<ApiEnvelope<OceanBookingDetail>, ApiEnvelope<OceanBookingDetail>>(`${basePath}/${encodeURIComponent(id)}`, payload, { headers: { 'Idempotency-Key': idempotencyKey() } }); return detail(unwrapApiResponse(response)) }
+export async function updateOceanBookingActualCargo(id: string, payload: OceanBookingActualCargoRequest) {
+  const response = await http.put<ApiEnvelope<OceanBookingDetail>, ApiEnvelope<OceanBookingDetail>>(`${basePath}/${encodeURIComponent(id)}/actual-cargo`, payload, { headers: { 'Idempotency-Key': idempotencyKey() } })
+  return detail(unwrapApiResponse(response))
+}
 export async function deleteOceanBookingDraft(id: string, expectedVersion: number) { await http.delete(`${basePath}/${encodeURIComponent(id)}`, { data: { expectedVersion }, headers: { 'Idempotency-Key': idempotencyKey() } }) }
 export async function releaseOceanBooking(id: string, request: OceanBookingReleaseRequest) { const response = await http.post<ApiEnvelope<OceanBookingDetail>, ApiEnvelope<OceanBookingDetail>>(`${basePath}/${encodeURIComponent(id)}/release`, request, { headers: { 'Idempotency-Key': idempotencyKey() } }); return detail(unwrapApiResponse(response)) }
 const printPaths: Record<OceanBookingPrintType, string> = {

src/modules/ocean-bookings/components/OceanBookingPrintDialog.test.ts

@@ -33,6 +33,7 @@ describe('OceanBookingPrintDialog', () => {
     await flushPromises()
 
     expect(downloadOceanBookingPrint).toHaveBeenCalledWith('123', 'SHIPPING_INSTRUCTION')
+    expect(wrapper.emitted('previewed')).toEqual([[{ bookingId: '123', type: 'SHIPPING_INSTRUCTION' }]])
     expect(document.body.querySelector('iframe')?.getAttribute('src')).toBe('blob:booking-print')
     expect(document.body.querySelector('.el-dialog__title')?.textContent).toBe('出口货物托运单 · OB-123')
     document.querySelector<HTMLButtonElement>('[aria-label="展开全屏"]')!.click()
@@ -144,4 +145,24 @@ describe('OceanBookingPrintDialog identity and resource lifecycle', () => {
     wrapper.unmount()
     expect(URL.revokeObjectURL).toHaveBeenCalledExactlyOnceWith('blob:current-print')
   })
+  it('opens the selected document directly and reloads the other type after closing', async () => {
+    vi.stubGlobal('URL', { createObjectURL: vi.fn(() => 'blob:booking-print'), revokeObjectURL: vi.fn() })
+    vi.mocked(downloadOceanBookingPrint).mockResolvedValue(new Blob(['pdf'], { type: 'application/pdf' }))
+    const wrapper = mount(OceanBookingPrintDialog, {
+      props: { modelValue: true, bookingId: '123', bookingNo: 'OB-123', allowed: true, initialType: 'SHIPPING_INSTRUCTION' },
+      global: { plugins: [ElementPlus] }, attachTo: document.body,
+    })
+    await flushPromises()
+    expect(downloadOceanBookingPrint).toHaveBeenLastCalledWith('123', 'SHIPPING_INSTRUCTION')
+    expect(document.body.querySelector('iframe')).not.toBeNull()
+    await wrapper.setProps({ modelValue: false })
+    await flushPromises()
+    expect(URL.revokeObjectURL).toHaveBeenCalledWith('blob:booking-print')
+    await wrapper.setProps({ initialType: 'BILL_OF_LADING_CONFIRMATION', modelValue: true })
+    await flushPromises()
+    expect(downloadOceanBookingPrint).toHaveBeenLastCalledWith('123', 'BILL_OF_LADING_CONFIRMATION')
+    expect(document.body.querySelector('.el-dialog__title')?.textContent).toBe('提单确认件 · OB-123')
+    wrapper.unmount()
+  })
+
 })

src/modules/ocean-bookings/components/OceanBookingPrintDialog.vue

@@ -10,7 +10,8 @@ import { getApiErrorDetails, type ApiErrorDetails } from '@/shared/api/http'
 import { downloadOceanBookingPrint } from '../api/platformOceanBookings'
 import type { OceanBookingPrintType } from '../types'
 
-const props = defineProps<{ bookingId: string; bookingNo?: string | null; allowed: boolean }>()
+const props = defineProps<{ bookingId: string; bookingNo?: string | null; allowed: boolean; initialType?: OceanBookingPrintType }>()
+const emit = defineEmits<{ previewed: [event: { bookingId: string; type: OceanBookingPrintType }] }>()
 const open = defineModel<boolean>({ default: false })
 const selectedType = ref<OceanBookingPrintType | ''>('')
 const loading = ref(false)
@@ -42,15 +43,18 @@ function reset() {
 }
 async function preview() {
   if (!props.allowed || !selectedType.value || loading.value) return
+  const bookingId = props.bookingId
+  const type = selectedType.value
   const request = ++previewRequest
   loading.value = true
   error.value = null
   releasePreview()
   try {
-    const blob = await downloadOceanBookingPrint(props.bookingId, selectedType.value)
+    const blob = await downloadOceanBookingPrint(bookingId, type)
     if (request !== previewRequest || !open.value) return
     printBlob.value = blob
     previewUrl.value = URL.createObjectURL(blob)
+    emit('previewed', { bookingId, type })
   } catch (cause) {
     if (request === previewRequest) error.value = getApiErrorDetails(cause, '打印单据加载失败，请稍后重试')
   } finally {
@@ -71,7 +75,13 @@ function download() {
   URL.revokeObjectURL(url)
 }
 
-watch(open, (value) => { if (!value) reset() })
+watch(open, (value) => {
+  if (!value) reset()
+  else if (props.initialType) {
+    selectedType.value = props.initialType
+    void preview()
+  }
+}, { immediate: true })
 onBeforeUnmount(() => { previewRequest += 1; releasePreview() })
 </script>
 

src/modules/ocean-bookings/pages/OceanBookingDetailView.release.test.ts

@@ -12,10 +12,12 @@ import {
   listWarehouseLogisticsChannels,
   releaseOceanBooking,
   updateOceanBookingDraft,
+  updateOceanBookingActualCargo,
 } from '../api/platformOceanBookings'
 import type { OceanBookingDetail, OceanBookingStatus } from '../types'
 import OceanBookingDetailView from './OceanBookingDetailView.vue'
 import AppDialog from '@/shared/components/AppDialog.vue'
+import OceanBookingPrintDialog from '../components/OceanBookingPrintDialog.vue'
 
 const routerReplace = vi.hoisted(() => vi.fn())
 const routeState = vi.hoisted(() => ({ name: 'ocean-booking-detail', params: { bookingId: '123' } }))
@@ -23,7 +25,8 @@ vi.mock('vue-router', () => ({
   useRoute: () => routeState,
   useRouter: () => ({ push: vi.fn(), replace: routerReplace }),
 }))
-vi.mock('@/core/access/accessPreview', () => ({ useAccessPreviewStore: () => ({ can: () => true }) }))
+const deniedPermissions = vi.hoisted(() => new Set<string>())
+vi.mock('@/core/access/accessPreview', () => ({ useAccessPreviewStore: () => ({ can: (permission: string) => !deniedPermissions.has(permission) }) }))
 vi.mock('@/core/workspace-tabs/workspaceTabs', () => ({ useWorkspaceTabsStore: () => ({ removeByIds: vi.fn(), bumpCacheEpoch: vi.fn() }) }))
 vi.mock('@/modules/iam', async importOriginal => ({
   ...await importOriginal<typeof import('@/modules/iam')>(), listPlatformTenants: vi.fn() }))
@@ -32,7 +35,7 @@ vi.mock('@/modules/warehouses', () => ({ listPlatformWarehouses: vi.fn() }))
 vi.mock('../api/platformOceanBookings', () => ({
   createOceanBooking: vi.fn(), deleteOceanBookingDraft: vi.fn(), getOceanBooking: vi.fn(),
   listOceanBookingAgents: vi.fn(), listWarehouseLogisticsChannels: vi.fn(),
-  releaseOceanBooking: vi.fn(), updateOceanBookingDraft: vi.fn(),
+  releaseOceanBooking: vi.fn(), updateOceanBookingDraft: vi.fn(), updateOceanBookingActualCargo: vi.fn(),
 }))
 
 function booking(status: OceanBookingStatus = 'DRAFT', version = 3, billOfLadingNo = 'BL-001'): OceanBookingDetail {
@@ -66,6 +69,11 @@ function booking(status: OceanBookingStatus = 'DRAFT', version = 3, billOfLading
 
 type ViewModel = {
   form: { data: import('../types').OceanBookingDraftData }
+  saveActualCargo: () => Promise<void>
+  actualReason: string
+  cargoWritable: boolean
+  hasUnsavedActualChanges: boolean
+  printDisabledReason: string
   save: () => Promise<void>
   selectCustomer: (value: unknown) => void
   canManageDocuments: boolean
@@ -95,6 +103,7 @@ describe('OceanBookingDetailView one-click release', () => {
   beforeEach(() => {
     routeState.name = 'ocean-booking-detail'; routeState.params.bookingId = '123'
     vi.clearAllMocks()
+    deniedPermissions.clear()
     vi.mocked(getOceanBooking).mockResolvedValue(booking())
     vi.mocked(listPlatformTenants).mockResolvedValue({ records: [], page: 1, size: 200, total: 0, pages: 0 })
     vi.mocked(listPlatformPartners).mockResolvedValue({ records: [], page: 1, size: 200, total: 0, pages: 0 })
@@ -103,6 +112,23 @@ describe('OceanBookingDetailView one-click release', () => {
     vi.mocked(listOceanBookingAgents).mockResolvedValue([{ supplierId: '20', name: '订舱代理', carrierCodes: ['MATSON'] }])
   })
 
+  it('renders actual workflow progress and advances only on a successful matching preview', async () => {
+    const { wrapper } = await mountView()
+    const states = () => wrapper.findAll('.booking-workflow li').map(item => item.attributes('data-state'))
+    expect(states()).toEqual(['complete', 'current', 'pending', 'pending'])
+    expect(wrapper.get('[aria-current="step"]').text()).toContain('托运单')
+    const print = wrapper.findComponent(OceanBookingPrintDialog)
+    print.vm.$emit('previewed', { bookingId: 'another', type: 'SHIPPING_INSTRUCTION' })
+    await flushPromises()
+    expect(states()).toEqual(['complete', 'current', 'pending', 'pending'])
+    print.vm.$emit('previewed', { bookingId: '123', type: 'SHIPPING_INSTRUCTION' })
+    await flushPromises()
+    expect(states()).toEqual(['complete', 'complete', 'current', 'pending'])
+    expect(wrapper.findAll('.booking-workflow li')[1]?.text()).toContain('已预览')
+    expect(wrapper.get('[aria-current="step"]').text()).toContain('确认放舱')
+    wrapper.unmount()
+  })
+
   it('finds a customer outside the initial page and saves its actual ID and name in a new booking', async () => {
     routeState.name = 'ocean-booking-create'; routeState.params.bookingId = 'new'
     const customer = { id: '9007199254740999', tenantName: '柏悦物流', status: 'ACTIVE' } as PlatformTenantResource
@@ -137,7 +163,7 @@ describe('OceanBookingDetailView one-click release', () => {
     expect(wrapper.get('.release-summary').text()).toContain('EDITED-BL')
     expect(wrapper.get('.release-summary').element.closest('section')?.hasAttribute('data-tone')).toBe(false)
     expect(wrapper.find('.el-alert--warning').exists()).toBe(false)
-    expect(wrapper.text()).toContain('不能修改、不能删除')
+    expect(dialog.find('.density-dialog-note').exists()).toBe(false)
     expect(wrapper.text()).not.toContain('处理数据库')
     expect(updateOceanBookingDraft).not.toHaveBeenCalled()
     expect(releaseOceanBooking).not.toHaveBeenCalled()
@@ -281,4 +307,88 @@ describe('OceanBookingDetailView one-click release', () => {
     await Promise.all([first, duplicate])
     expect(vm.actionSaving).toBe(false)
   })
+  it('keeps newly saved booking open and preserves partial parties and manual cargo', async () => {
+    routeState.name = 'ocean-booking-create'; routeState.params.bookingId = 'new'
+    vi.mocked(createOceanBooking).mockResolvedValue(booking('DRAFT', 0))
+    const { vm, wrapper } = await mountView()
+    vm.form.data.parties[0]!.contactEmail = 'ops@example.test'
+    vm.form.data.declaredPackageCount = 500
+    vm.form.data.declaredGrossWeightKg = 15000
+    vm.form.data.declaredVolumeCbm = 68
+    await vm.save()
+    expect(createOceanBooking).toHaveBeenCalledWith(expect.objectContaining({ data: expect.objectContaining({
+      freightTerm: 'FREIGHT PREPAID', serviceTerm: 'CY-CY', packageUnit: 'CARTONS',
+      declaredPackageCount: 500, actualPackageCount: null,
+      parties: expect.arrayContaining([expect.objectContaining({ partyType: 'SHIPPER', partyName: '', contactEmail: 'ops@example.test' })]),
+    }) }))
+    expect(routerReplace).toHaveBeenCalledWith('/ocean-bookings/123')
+    expect(vm.detail?.bookingNo).toBe('OB-123')
+    wrapper.unmount()
+  })
+
+  it('saves released actual cargo alone with version and reason while transport remains frozen', async () => {
+    vi.mocked(getOceanBooking).mockResolvedValue({ ...booking('RELEASED'), declaredPackageCount: 500 })
+    vi.mocked(updateOceanBookingActualCargo).mockResolvedValue({ ...booking('RELEASED', 4), declaredPackageCount: 500, actualPackageCount: 480, actualGrossWeightKg: 14320.125, actualVolumeCbm: 65.321 })
+    const { vm, wrapper } = await mountView()
+    expect(wrapper.find('input[placeholder="请输入船名"]').attributes('disabled')).toBeDefined()
+    for (const label of ['实际件数', '实际毛重', '实际体积']) {
+      const actualInput = wrapper.get(`input[aria-label="${label}"]`)
+      expect(actualInput.attributes('disabled')).toBeUndefined()
+      expect(actualInput.attributes('aria-disabled')).toBe('false')
+    }
+    for (const label of ['预报件数', '预报毛重', '预报体积']) {
+      const declaredInput = wrapper.get(`input[aria-label="${label}"]`)
+      expect(declaredInput.attributes('disabled')).toBeDefined()
+      expect(declaredInput.attributes('aria-disabled')).toBe('true')
+    }
+    vm.form.data.actualPackageCount = 480
+    vm.form.data.actualGrossWeightKg = 14320.125
+    vm.form.data.actualVolumeCbm = 65.321
+    vm.actualReason = ' 实装后补录 '
+    await flushPromises()
+    expect(vm.printDisabledReason).toContain('请先保存')
+    await vm.saveActualCargo()
+    expect(updateOceanBookingActualCargo).toHaveBeenCalledWith('123', { expectedVersion: 3, actualPackageCount: 480, actualGrossWeightKg: 14320.125, actualVolumeCbm: 65.321, reason: '实装后补录' })
+    expect(updateOceanBookingDraft).not.toHaveBeenCalled()
+    expect(vm.detail?.version).toBe(4)
+    expect(vm.actualReason).toBe('')
+    expect(vm.hasUnsavedActualChanges).toBe(false)
+    expect(vm.form.data.declaredPackageCount).toBe(500)
+    wrapper.unmount()
+  })
+
+  it('preserves actual inputs and reason on a stale-version failure and blocks duplicate writes', async () => {
+    vi.mocked(getOceanBooking).mockResolvedValue(booking('RELEASED'))
+    let rejectSave!: (cause: unknown) => void
+    vi.mocked(updateOceanBookingActualCargo).mockReturnValue(new Promise((_, reject) => { rejectSave = reject }))
+    const { vm, wrapper } = await mountView()
+    vm.form.data.actualPackageCount = 480
+    await vm.saveActualCargo()
+    expect(updateOceanBookingActualCargo).not.toHaveBeenCalled()
+    expect(vm.actionError?.message).toContain('原因')
+    vm.actualReason = '修正'
+    const first = vm.saveActualCargo()
+    await vm.saveActualCargo()
+    expect(updateOceanBookingActualCargo).toHaveBeenCalledTimes(1)
+    rejectSave(new ApiResponseError('版本已变化', 'A0409', 409))
+    await first
+    expect(vm.form.data.actualPackageCount).toBe(480)
+    expect(vm.actualReason).toBe('修正')
+    expect(vm.detail?.version).toBe(3)
+    expect(vm.actionError?.code).toBe('A0409')
+    wrapper.unmount()
+  })
+
+  it('keeps actual cargo read-only without edit permission', async () => {
+    deniedPermissions.add('platform:firstleg:ocean-booking:edit')
+    vi.mocked(getOceanBooking).mockResolvedValue(booking('RELEASED'))
+    const { vm, wrapper } = await mountView()
+    expect(vm.cargoWritable).toBe(false)
+    expect(wrapper.text()).not.toContain('保存实际货量')
+    vm.actualReason = '补录'
+    await vm.saveActualCargo()
+    expect(updateOceanBookingActualCargo).not.toHaveBeenCalled()
+    wrapper.unmount()
+  })
+
 })

src/modules/ocean-bookings/pages/OceanBookingDetailView.test.ts

@@ -34,7 +34,7 @@ describe('OceanBookingDetailView draft and release contract', () => {
     expect(source).toContain('function draftPayload(): OceanBookingDraftData')
     expect(source).toContain('channelCode: form.data.channelCode?.trim() || null')
     expect(source).toContain('warehouseId: form.data.warehouseId?.trim() || null')
-    expect(source).toContain('parties: form.data.parties.filter((party) => party.partyName.trim())')
+    expect(source).toContain('parties: form.data.parties.map')
     expect(source).toContain('containerRequirements: form.data.containerRequirements.map')
     expect(source).not.toContain('登记后直接确认')
   })
@@ -51,7 +51,7 @@ describe('OceanBookingDetailView draft and release contract', () => {
     expect(source).not.toContain('新增真实柜')
   })
 
-  it('performs the complete release gate and presents the irreversible warning', () => {
+  it('performs the complete release gate without the extra explanatory line', () => {
     expect(source).toContain('function releaseValidationError()')
     expect(source).toContain('预计到港时间不能早于预计开船时间')
     expect(source).toContain('放舱前请填写起运港代码或名称')
@@ -61,7 +61,7 @@ describe('OceanBookingDetailView draft and release contract', () => {
     expect(source).toContain("if (!form.data.carrierCode) return '放舱前请重新选择船公司，所选船公司必须配置标准编码'")
     expect(source).not.toContain('请先保存草稿后再放舱')
     expect(source).toContain('放舱前请填写${missing[1]}')
-    expect(source).toContain('放舱后资料将同步到关联货柜，不能修改、不能删除，请确认资料无误。')
+    expect(source).not.toContain('放舱后运输资料和预报货量不能修改、不能删除；实际货量可另行补录并记录原因。请确认运输资料无误。')
     expect(source).toContain('if (hasUnsavedDraftChanges.value)')
     expect(source).toContain('const saved = await persistDraft(false)')
     expect(source).toContain('releaseVersion = saved.version')
@@ -70,7 +70,7 @@ describe('OceanBookingDetailView draft and release contract', () => {
     expect(source).toContain('if (!saved) return')
     expect(source).toContain("{{ form.data.billOfLadingNo || '—' }}")
     expect(source).not.toContain("{{ detail?.billOfLadingNo || '—' }}")
-    expect(source).toContain('const workflowBusy = computed(() => saving.value || actionSaving.value)')
+    expect(source).toContain('const workflowBusy = computed(() => saving.value || actionSaving.value || actualSaving.value)')
     expect(source).toContain(':disabled="workflowBusy" @click="openReleaseDialog"')
     expect(source).not.toContain('releaseReason')
     expect(source).toContain('放舱前请上传有效的订舱确认文件或提单文件')
@@ -112,15 +112,16 @@ describe('OceanBookingDetailView draft and release contract', () => {
     expect(source).toContain('@media(max-width:720px)')
     expect(source).toContain('@media(max-width:420px)')
     expect(source).toContain('OceanBookingPrintDialog')
-    expect(source).toContain('打印单据')
+    expect(source).toContain('打印托运单')
+    expect(source).toContain('打印提单确认件')
   })
 
   it('keeps a DRAFT detail read-only when the user lacks write permission', () => {
     expect(source).toContain('const formWritable = computed(() => canSave.value)')
     expect(source).toContain(':disabled="!formWritable" class="booking-groups density-form"')
-    expect(source).toContain('.booking-groups{display:grid;grid-template-columns:minmax(0,1.35fr) minmax(0,1fr);gap:var(--admin-space-5)}')
-    expect(source).toContain('.booking-group:last-child{grid-column:1/-1}')
-    expect(source).toContain('.container-table-wrap{max-width:100%;overflow-x:auto')
+    expect(source).toMatch(/\.booking-core\s*\{[^}]*grid-template-columns:\s*minmax\(0,\s*1\.2fr\) minmax\(0,\s*1fr\)/)
+    expect(source).toMatch(/\.booking-group:last-child\s*\{\s*grid-column:\s*1\s*\/\s*-1/)
+    expect(source).toMatch(/\.container-table-wrap\s*\{[^}]*max-width:\s*100%;\s*overflow-x:\s*auto/)
     expect(source).toContain('v-if="formWritable" class="container-actions"')
     expect(source).toContain(':disabled="!formWritable"')
   })

src/modules/ocean-bookings/pages/OceanBookingDetailView.vue

@@ -4,7 +4,7 @@ import '@/styles/adminWorkbench.css'
 import { computed, onMounted, reactive, ref } from 'vue'
 import { ElMessage, ElMessageBox, type FormInstance, type FormRules } from 'element-plus'
 import { useRoute, useRouter } from 'vue-router'
-import { ArrowLeft, Printer, Save, Trash2 } from '@lucide/vue'
+import { ArrowLeft, Check, Printer, Save, Ship, Trash2 } from '@lucide/vue'
 import { useAccessPreviewStore } from '@/core/access/accessPreview'
 import { useWorkspaceTabsStore } from '@/core/workspace-tabs/workspaceTabs'
 import { getApiErrorDetails, type ApiErrorDetails } from '@/shared/api/http'
@@ -30,6 +30,7 @@ import {
   releaseOceanBooking,
   listWarehouseLogisticsChannels,
   updateOceanBookingDraft,
+  updateOceanBookingActualCargo,
   type OceanLogisticsChannel,
 } from '../api/platformOceanBookings'
 import type {
@@ -41,10 +42,12 @@ import type {
   OceanBookingParty,
   OceanBookingSaveRequest,
   OceanBookingStatus,
+  OceanBookingPrintType,
 } from '../types'
 import { oceanBookingStatusLabel } from '../status'
 import { containerRequirementError, createBlankContainerRequirement, selectContainerRequirementType } from '../containerRequirements'
 import { shouldClearBookingAgent } from '../bookingAgents'
+import { oceanBookingPrintSignature, oceanBookingWorkflow, type OceanBookingPreviewSignatures } from '../workflow'
 import OceanBookingPrintDialog from '../components/OceanBookingPrintDialog.vue'
 import OceanBookingDocumentsPanel from '../components/OceanBookingDocumentsPanel.vue'
 
@@ -95,10 +98,13 @@ const channelGroups = computed(() => {
 const channelUnavailable = computed(() => Boolean(form.data.warehouseId) && !channelsLoading.value && !channelsError.value && channelGroups.value.length === 0)
 
 function blankParties(): OceanBookingParty[] {
-  return partyTypes.map(({ value }) => ({ partyType: value, partyName: '', contactName: '', contactPhone: '', address: '' }))
+  return partyTypes.map(({ value }) => ({ partyType: value, partyName: '', contactName: '', contactPhone: '', contactEmail: '', taxNo: '', address: '' }))
 }
 function blankData(): OceanBookingDraftData {
   return {
+    freightTerm: 'FREIGHT PREPAID', serviceTerm: 'CY-CY', packageUnit: 'CARTONS',
+    cargoDescription: '', marksAndNos: '', declaredPackageCount: null, declaredGrossWeightKg: null, declaredVolumeCbm: null,
+    actualPackageCount: null, actualGrossWeightKg: null, actualVolumeCbm: null,
     customerId: null, customerName: null, channelCode: '', warehouseId: '', parties: blankParties(),
     billOfLadingNo: '', vesselName: '', voyageNo: '', estimatedSailingAt: null, estimatedArrivalAt: null,
     shippingCompanyId: null, shippingCompanyName: null, carrierCode: null,
@@ -117,13 +123,22 @@ const canRelease = computed(() => detail.value?.status === 'DRAFT' && access.can
 const canPrint = computed(() => !!detail.value && access.can('platform:firstleg:ocean-booking:list'))
 const canManageDocuments = computed(() => detail.value?.status === 'DRAFT' && access.can('platform:firstleg:ocean-booking:edit'))
 const documentManageReason = computed(() => !access.can('platform:firstleg:ocean-booking:edit') ? '暂无订舱资料维护权限' : '')
-const workflowBusy = computed(() => saving.value || actionSaving.value)
+const actualSaving = ref(false)
+const actualReason = ref('')
+const cargoWritable = computed(() => formWritable.value || (detail.value?.status === 'RELEASED' && access.can('platform:firstleg:ocean-booking:edit')))
+const workflowBusy = computed(() => saving.value || actionSaving.value || actualSaving.value)
 const releaseDialogOpen = ref(false)
 const printOpen = ref(false)
+const printType = ref<OceanBookingPrintType>('SHIPPING_INSTRUCTION')
+const previewSignatures = ref<OceanBookingPreviewSignatures>({})
 
 function statusLabel(status: OceanBookingStatus | string | null | undefined) {
   return oceanBookingStatusLabel(status)
 }
+function historyActionLabel(action: string) {
+  const labels: Record<string, string> = { CREATE: '创建草稿', UPDATE_DRAFT: '编辑草稿', RELEASE: '确认放舱', UPDATE_ACTUAL_CARGO: '实货量补录/修正', UPLOAD_DOCUMENT: '上传文件', ATTACH_DOCUMENT: '关联文件', INVALIDATE_DOCUMENT: '作废文件' }
+  return labels[action] || '资料维护'
+}
 async function loadOptions() {
   optionsLoading.value = true
   optionsError.value = ''
@@ -163,12 +178,49 @@ function draftPayload(): OceanBookingDraftData {
     billOfLadingNo: form.data.billOfLadingNo.trim(),
     vesselName: form.data.vesselName.trim(),
     voyageNo: form.data.voyageNo.trim(),
-    parties: form.data.parties.filter((party) => party.partyName.trim()).map((party) => ({ ...party, partyName: party.partyName.trim() })),
+    parties: form.data.parties.map((party) => ({ ...party, partyName: party.partyName.trim() })),
     containerRequirements: form.data.containerRequirements.map(({ containerType, containerKind, quantity, capacityCbm, maxWeightKg }) => ({ containerType, containerKind, quantity: Number(quantity), capacityCbm, maxWeightKg })),
   }
 }
 function draftSignature() { return JSON.stringify(draftPayload()) }
 const hasUnsavedDraftChanges = computed(() => Boolean(detail.value?.status === 'DRAFT' && savedDraftSignature.value && draftSignature() !== savedDraftSignature.value))
+const hasUnsavedActualChanges = computed(() => detail.value?.status === 'RELEASED' && (
+  (form.data.actualPackageCount ?? null) !== (detail.value.actualPackageCount ?? null)
+  || (form.data.actualGrossWeightKg ?? null) !== (detail.value.actualGrossWeightKg ?? null)
+  || (form.data.actualVolumeCbm ?? null) !== (detail.value.actualVolumeCbm ?? null)
+))
+const printDisabledReason = computed(() => !detail.value ? '请先保存草稿' : hasUnsavedDraftChanges.value || hasUnsavedActualChanges.value ? '请先保存修改，再打印已保存资料' : !canPrint.value ? '暂无订舱单据打印权限' : '')
+const workflowSteps = computed(() => oceanBookingWorkflow(detail.value, hasUnsavedDraftChanges.value, hasUnsavedActualChanges.value, previewSignatures.value))
+function onPrintPreviewed(event: { bookingId: string; type: OceanBookingPrintType }) {
+  if (!detail.value || event.bookingId !== detail.value.id || printDisabledReason.value) return
+  previewSignatures.value[event.type] = oceanBookingPrintSignature(detail.value, event.type)
+}
+function openPrint(type: OceanBookingPrintType) {
+  if (printDisabledReason.value || workflowBusy.value) return
+  printType.value = type
+  printOpen.value = true
+}
+async function saveActualCargo() {
+  if (detail.value?.status !== 'RELEASED' || !cargoWritable.value || workflowBusy.value) return
+  const validationError = cargoValidationError()
+  if (validationError || !actualReason.value.trim()) {
+    actionError.value = { message: validationError || '请填写实货量补录或修正原因' }
+    return
+  }
+  actualSaving.value = true
+  actionError.value = null
+  try {
+    applyDetail(await updateOceanBookingActualCargo(detail.value.id, {
+      expectedVersion: detail.value.version,
+      actualPackageCount: form.data.actualPackageCount ?? null,
+      actualGrossWeightKg: form.data.actualGrossWeightKg ?? null,
+      actualVolumeCbm: form.data.actualVolumeCbm ?? null,
+      reason: actualReason.value.trim(),
+    }))
+    ElMessage.success('实际货量已保存')
+  } catch (cause) { actionError.value = getApiErrorDetails(cause) }
+  finally { actualSaving.value = false }
+}
 function selectWarehouse(value: unknown) {
   const warehouseId = value == null || value === '' ? null : String(value)
   form.data.warehouseId = warehouseId
@@ -248,9 +300,18 @@ function applyDetail(value: OceanBookingDetail) {
     destinationPortCode: value.destinationPortCode, destinationPortName: value.destinationPortName,
     placeOfDelivery: value.placeOfDelivery,
     remark: value.remark,
-    parties: value.parties.length ? value.parties.map(({ partyType, partyName, contactName, contactPhone, address }) => ({ partyType, partyName, contactName, contactPhone, address })) : blankParties(),
+    freightTerm: value.freightTerm, serviceTerm: value.serviceTerm, packageUnit: value.packageUnit,
+    cargoDescription: value.cargoDescription, marksAndNos: value.marksAndNos,
+    declaredPackageCount: value.declaredPackageCount ?? null,
+    declaredGrossWeightKg: value.declaredGrossWeightKg == null ? null : Number(value.declaredGrossWeightKg),
+    declaredVolumeCbm: value.declaredVolumeCbm == null ? null : Number(value.declaredVolumeCbm),
+    actualPackageCount: value.actualPackageCount ?? null,
+    actualGrossWeightKg: value.actualGrossWeightKg == null ? null : Number(value.actualGrossWeightKg),
+    actualVolumeCbm: value.actualVolumeCbm == null ? null : Number(value.actualVolumeCbm),
+    parties: blankParties().map((blank) => ({ ...blank, ...value.parties.find((party) => party.partyType === blank.partyType) })),
     containerRequirements: value.containerRequirements.length ? value.containerRequirements.map(({ requirementId, containerType, containerKind, quantity, remainingQuantity, capacityCbm, maxWeightKg }) => ({ requirementId, containerType, containerKind, quantity, remainingQuantity, capacityCbm, maxWeightKg })) : [createBlankContainerRequirement()],
   }
+  actualReason.value = ''
   selectedChannelName.value = value.channelName || ''
   savedDraftSignature.value = draftSignature()
   channels.value = []
@@ -265,9 +326,24 @@ async function load() {
   catch (cause) { error.value = getApiErrorDetails(cause) }
   finally { loading.value = false }
 }
+function cargoValidationError() {
+  for (const kind of ['declared', 'actual'] as const) {
+    const count = form.data[`${kind}PackageCount`]
+    if (count != null && (!Number.isInteger(count) || count < 1 || count > 999999999)) return '货物件数必须为1到999999999的整数'
+    for (const number of [form.data[`${kind}GrossWeightKg`], form.data[`${kind}VolumeCbm`]]) {
+      if (number != null && (!Number.isFinite(number) || number <= 0 || number > 999999999999.999)) return '货物重量和体积必须为有效正数'
+    }
+  }
+  return ''
+}
 async function validateDraftForm() {
   const valid = await formRef.value?.validate().catch(() => false)
   if (valid === false) { actionError.value = { message: '请检查表单中的必填项和格式' }; return false }
+  const cargoMessage = cargoValidationError()
+  if (cargoMessage) { actionError.value = { message: cargoMessage }; return false }
+  if (form.data.parties.some((party) => party.contactEmail && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(party.contactEmail))) {
+    actionError.value = { message: '请填写有效的关系方邮箱' }; return false
+  }
   const requirementMessage = containerRequirementError(form.data.containerRequirements)
   if (requirementMessage) { actionError.value = { message: requirementMessage }; return false }
   return true
@@ -283,10 +359,13 @@ async function persistDraft(showSuccess: boolean) {
     if (showSuccess) ElMessage.success(isNew.value ? `订舱创建成功：${saved.bookingNo || '未生成订舱号'}` : '订舱草稿已保存')
     if (isNew.value) {
       workspace.removeByIds(['ocean-booking-create'])
-      await router.replace('/ocean-bookings')
+      applyDetail(saved)
+      workspace.bumpCacheEpoch('ocean-bookings')
+      await router.replace(`/ocean-bookings/${encodeURIComponent(saved.id)}`)
       return saved
     }
     applyDetail(saved)
+    workspace.bumpCacheEpoch('ocean-bookings')
     return saved
   } catch (cause) { actionError.value = getApiErrorDetails(cause); return null }
 }
@@ -377,53 +456,123 @@ onMounted(() => { void load(); void loadOptions() })
       <template #header>
         <div class="detail-heading">
           <el-button link class="density-back" @click="router.push('/ocean-bookings')"><ArrowLeft :size="16" />返回列表</el-button>
-          <PageToolbar class="booking-page-toolbar" as="section" :title="detail?.bookingNo || '订舱草稿'" :description="detail ? `${detail.customerName ? `${detail.customerName} · ` : ''}${detail.pol || '—'} → ${detail.pod || '—'}` : ''">
-            <template v-if="detail" #actions><div class="heading-status"><StatusBadge :status="statusLabel(detail.status)" /></div></template>
+          <span class="booking-brand" aria-hidden="true"><Ship :size="22" /></span>
+          <PageToolbar class="booking-page-toolbar" as="section" :title="detail?.bookingNo || '订舱信息管理'" :description="detail ? `${detail.customerName ? `${detail.customerName} · ` : ''}${detail.pol || '—'} → ${detail.pod || '—'}` : '出口订舱作业'">
+            <template #actions>
+              <div class="actions booking-page-actions">
+                <StatusBadge v-if="detail" :status="statusLabel(detail.status)" />
+                <el-button v-if="canDelete" type="danger" plain :loading="actionSaving" :disabled="workflowBusy" @click="removeDraft"><Trash2 :size="16" />删除草稿</el-button>
+                <el-button v-if="canSave" plain :loading="saving" :disabled="workflowBusy" @click="save"><Save :size="16" />保存草稿</el-button>
+              </div>
+            </template>
           </PageToolbar>
         </div>
       </template>
 
       <LoadErrorState v-if="error" title="订舱详情加载失败" :message="error.message" :loading="loading" @retry="load"><template #details><ApiErrorMeta :details="error" /></template></LoadErrorState>
       <template v-else>
-      <section class="workbench-panel is-compact">
-        <div class="section-title">
-          <h2>订舱信息</h2>
-          <div class="actions">
-            <el-tooltip :content="canPrint ? '按当前已保存资料打印出口货物托运单或提单确认件' : '暂无订舱单据打印权限'" placement="top"><span><el-button v-if="detail" plain :disabled="!canPrint || workflowBusy" @click="printOpen = true"><Printer :size="16" />打印单据</el-button></span></el-tooltip>
-            <el-button v-if="canDelete" type="danger" plain :loading="actionSaving" :disabled="workflowBusy" @click="removeDraft"><Trash2 :size="16" />删除草稿</el-button>
-            <el-button v-if="canRelease" type="primary" plain :loading="actionSaving" :disabled="workflowBusy" @click="openReleaseDialog">放舱</el-button>
-            <el-button v-if="canSave" type="primary" :loading="saving" :disabled="workflowBusy" @click="save"><Save :size="16" />保存草稿</el-button>
-          </div>
+      <ol class="booking-workflow" aria-label="订舱作业流程">
+        <li v-for="(step, index) in workflowSteps" :key="step.label" :data-state="step.state" :aria-current="step.state === 'current' ? 'step' : undefined">
+          <span class="booking-workflow__index" aria-hidden="true"><Check v-if="step.state === 'complete'" :size="16" /><template v-else>{{ index + 1 }}</template></span>
+          <span class="booking-workflow__label">{{ step.label }}</span>
+          <span class="booking-workflow__status">{{ step.status }}</span>
+        </li>
+      </ol>
+      <section class="workbench-panel is-compact booking-section booking-section--core">
+        <div class="section-title booking-section__heading">
+          <h2><span class="booking-section__number" aria-hidden="true">1</span>一、核心订舱信息</h2>
         </div>
         <el-alert v-if="optionsError" type="warning" :closable="false" show-icon :title="optionsError"><el-button link type="warning" :loading="optionsLoading" @click="loadOptions">重新加载选项</el-button></el-alert>
-        <el-form ref="formRef" :model="form.data" :rules="rules" label-position="top" :disabled="!formWritable" class="booking-groups density-form">
+        <div class="booking-core">
+          <div class="booking-core__main">
+            <el-form ref="formRef" :model="form.data" :rules="rules" label-position="top" :disabled="!formWritable" class="booking-groups density-form">
           <section class="booking-group" aria-label="基本信息">
-            <h3>基本信息</h3><div class="booking-group__body booking-group__body--fields">
+            <h3 class="booking-group__title"><span>基础信息</span></h3>
+            <div class="booking-group__body booking-group__body--fields">
             <el-form-item label="订舱号"><el-input :model-value="detail?.bookingNo || '保存后生成'" disabled /></el-form-item>
-            <el-form-item label="客户（选填）"><el-select :model-value="form.data.customerId" filterable clearable placeholder="单客户可选择，多客户可留空" no-data-text="暂无可选客户" :loading="customersLoading" remote :remote-method="loadCustomers" @end-reached="customerEndReached" style="width:100%" @update:model-value="selectCustomer"><el-option v-if="form.data.customerId && !selectableCustomers.some((customer) => String(customer.id) === String(form.data.customerId))" :label="form.data.customerName || '客户名称缺失'" :value="String(form.data.customerId)" /><el-option v-for="customer in selectableCustomers" :key="String(customer.id)" :label="customer.tenantName" :value="String(customer.id)" /></el-select><LoadErrorState v-if="customersError" title="客户选项加载失败" :message="customersError.message" :loading="customersLoading" compact @retry="retryCustomers"><template #details><ApiErrorMeta :details="customersError" /></template></LoadErrorState></el-form-item>
-            <el-form-item label="状态"><el-input :model-value="detail ? statusLabel(detail.status) : '保存后为草稿'" disabled /></el-form-item>
-            <el-form-item label="装柜仓库" prop="warehouseId"><el-select :model-value="form.data.warehouseId" filterable placeholder="请选择装柜仓库" :loading="optionsLoading" style="width:100%" @update:model-value="selectWarehouse"><el-option v-for="warehouse in warehouses" :key="String(warehouse.id)" :label="warehouse.warehouseName" :value="String(warehouse.id)" /></el-select></el-form-item>
-            <el-form-item label="物流渠道" prop="channelCode"><el-select :model-value="form.data.channelCode" filterable :disabled="!formWritable || !form.data.warehouseId || channelsLoading || !!channelsError || channelUnavailable" :loading="channelsLoading" :placeholder="form.data.warehouseId ? '请选择物流渠道' : '请先选择装柜仓库'" no-data-text="该仓库暂无有效物流渠道" style="width:100%" @update:model-value="selectChannel(String($event || ''))"><el-option v-if="form.data.channelCode && !channelGroups.some((channel) => channel.code === form.data.channelCode)" :label="selectedChannelName || form.data.channelCode" :value="form.data.channelCode" /><el-option v-for="channel in channelGroups" :key="channel.code" :label="channel.name" :value="channel.code" /></el-select><div v-if="channelsError" class="field-error"><span>{{ channelsError }}</span><el-button link type="primary" :loading="channelsLoading" @click="form.data.warehouseId && loadChannels(form.data.warehouseId)">重新加载</el-button></div><div v-else-if="channelUnavailable" class="field-hint">该仓库暂无有效物流渠道，请更换仓库或联系管理员。</div></el-form-item>
-            <el-form-item label="提单号" prop="billOfLadingNo"><el-input v-model="form.data.billOfLadingNo" maxlength="128" placeholder="请输入提单号" /></el-form-item>
             <el-form-item label="船公司"><el-select :model-value="form.data.shippingCompanyId" filterable clearable placeholder="请选择船公司" :loading="optionsLoading" style="width:100%" @update:model-value="selectShippingCompany(String($event || ''))"><el-option v-if="form.data.shippingCompanyId && !shippingCompanies.some((partner) => String(partner.id) === String(form.data.shippingCompanyId))" :label="form.data.shippingCompanyName || '船公司名称缺失'" :value="String(form.data.shippingCompanyId)" /><el-option v-for="partner in shippingCompanies" :key="String(partner.id)" :label="partner.partnerName" :value="String(partner.id)" /></el-select></el-form-item>
             <el-form-item label="订舱代理"><el-select :model-value="form.data.bookingAgentId" filterable clearable :disabled="!editable || !form.data.carrierCode || bookingAgentsLoading || !!bookingAgentsError" :placeholder="form.data.carrierCode ? '请选择订舱代理' : '请先选择船公司'" :loading="bookingAgentsLoading" no-data-text="当前船公司暂无可用订舱代理" style="width:100%" @update:model-value="selectBookingAgent(String($event || ''))"><el-option v-if="!editable && form.data.bookingAgentId && !bookingAgents.some((supplier) => supplier.supplierId === String(form.data.bookingAgentId))" :label="form.data.bookingAgentName || '订舱代理名称缺失'" :value="String(form.data.bookingAgentId)" /><el-option v-for="supplier in bookingAgents" :key="supplier.supplierId" :label="supplier.name" :value="supplier.supplierId" /></el-select><div v-if="bookingAgentsError" class="field-error"><ApiErrorMeta :details="bookingAgentsError" /><el-button link type="primary" :loading="bookingAgentsLoading" @click="form.data.carrierCode && loadBookingAgents(form.data.carrierCode)">重新加载</el-button></div></el-form-item>
+            <el-form-item label="客户（选填）"><el-select :model-value="form.data.customerId" filterable clearable placeholder="单客户可选择，多客户可留空" no-data-text="暂无可选客户" :loading="customersLoading" remote :remote-method="loadCustomers" @end-reached="customerEndReached" style="width:100%" @update:model-value="selectCustomer"><el-option v-if="form.data.customerId && !selectableCustomers.some((customer) => String(customer.id) === String(form.data.customerId))" :label="form.data.customerName || '客户名称缺失'" :value="String(form.data.customerId)" /><el-option v-for="customer in selectableCustomers" :key="String(customer.id)" :label="customer.tenantName" :value="String(customer.id)" /></el-select><LoadErrorState v-if="customersError" title="客户选项加载失败" :message="customersError.message" :loading="customersLoading" compact @retry="retryCustomers"><template #details><ApiErrorMeta :details="customersError" /></template></LoadErrorState></el-form-item>
+            <el-form-item label="装柜仓库" prop="warehouseId"><el-select :model-value="form.data.warehouseId" filterable placeholder="请选择装柜仓库" :loading="optionsLoading" style="width:100%" @update:model-value="selectWarehouse"><el-option v-for="warehouse in warehouses" :key="String(warehouse.id)" :label="warehouse.warehouseName" :value="String(warehouse.id)" /></el-select></el-form-item>
+            <el-form-item label="物流渠道" prop="channelCode"><el-select :model-value="form.data.channelCode" filterable :disabled="!formWritable || !form.data.warehouseId || channelsLoading || !!channelsError || channelUnavailable" :loading="channelsLoading" :placeholder="form.data.warehouseId ? '请选择物流渠道' : '请先选择装柜仓库'" no-data-text="该仓库暂无有效物流渠道" style="width:100%" @update:model-value="selectChannel(String($event || ''))"><el-option v-if="form.data.channelCode && !channelGroups.some((channel) => channel.code === form.data.channelCode)" :label="selectedChannelName || form.data.channelCode" :value="form.data.channelCode" /><el-option v-for="channel in channelGroups" :key="channel.code" :label="channel.name" :value="channel.code" /></el-select><div v-if="channelsError" class="field-error"><span>{{ channelsError }}</span><el-button link type="primary" :loading="channelsLoading" @click="form.data.warehouseId && loadChannels(form.data.warehouseId)">重新加载</el-button></div><div v-else-if="channelUnavailable" class="field-hint">该仓库暂无有效物流渠道，请更换仓库或联系管理员。</div></el-form-item>
             </div>
           </section>
           <section class="booking-group" aria-label="航线船期">
-            <h3>航线船期</h3><div class="booking-group__body booking-group__body--fields">
-            <el-form-item label="船名" prop="vesselName"><el-input v-model="form.data.vesselName" maxlength="128" placeholder="请输入船名" /></el-form-item>
-            <el-form-item label="航次" prop="voyageNo"><el-input v-model="form.data.voyageNo" maxlength="64" placeholder="请输入航次" /></el-form-item>
-            <el-form-item label="起运港代码"><el-input v-model="form.data.departurePortCode" placeholder="例如：CNNGB" /></el-form-item>
-            <el-form-item label="起运港"><el-input v-model="form.data.departurePortName" placeholder="例如：宁波港" /></el-form-item>
-            <el-form-item label="目的港代码"><el-input v-model="form.data.destinationPortCode" placeholder="例如：USLAX" /></el-form-item>
-            <el-form-item label="目的港"><el-input v-model="form.data.destinationPortName" placeholder="例如：洛杉矶港" /></el-form-item>
-            <el-form-item class="booking-field--wide" label="交货地点"><el-input v-model="form.data.placeOfDelivery" placeholder="请输入最终交货地点" /></el-form-item>
+            <h3 class="booking-group__title"><span>港口航线</span></h3>
+            <div class="booking-group__body booking-group__body--fields">
+              <el-form-item label="起运港"><div class="booking-port-fields"><el-input v-model="form.data.departurePortCode" placeholder="港代码" aria-label="起运港代码" /><el-input v-model="form.data.departurePortName" placeholder="港口名称" aria-label="起运港名称" /></div></el-form-item>
+              <el-form-item label="目的港"><div class="booking-port-fields"><el-input v-model="form.data.destinationPortCode" placeholder="港代码" aria-label="目的港代码" /><el-input v-model="form.data.destinationPortName" placeholder="港口名称" aria-label="目的港名称" /></div></el-form-item>
             <el-form-item label="预计开船" prop="estimatedSailingAt"><el-date-picker v-model="form.data.estimatedSailingAt" type="datetime" value-format="YYYY-MM-DDTHH:mm:ss" placeholder="请选择预计开船时间" style="width:100%" /></el-form-item>
             <el-form-item label="预计到港" prop="estimatedArrivalAt"><el-date-picker v-model="form.data.estimatedArrivalAt" type="datetime" value-format="YYYY-MM-DDTHH:mm:ss" placeholder="请选择预计到港时间" style="width:100%" /></el-form-item>
+            <el-form-item class="booking-field--wide" label="交货地点"><el-input v-model="form.data.placeOfDelivery" placeholder="请输入最终交货地点" /></el-form-item>
+            <el-form-item label="运费条款"><el-input v-model="form.data.freightTerm" maxlength="64" /></el-form-item>
+            <el-form-item label="运输条款"><el-input v-model="form.data.serviceTerm" maxlength="64" /></el-form-item>
             </div>
           </section>
+            </el-form>
+          <section class="booking-group" aria-label="货物信息">
+            <h3 class="booking-group__title"><span>货物信息</span></h3>
+            <el-form label-position="top" class="density-form booking-group__body">
+              <div class="cargo-metrics" role="group" aria-label="货物预报与实际数量">
+                <!-- 数字组件只在挂载时写入 aria-disabled；可编辑资格切换时重建，保持辅助标记与原生禁用状态一致。 -->
+                <div class="cargo-metric">
+                  <span class="cargo-metric__label">件数（委 / 实）</span>
+                  <div class="cargo-metric__inputs">
+                    <el-input-number :key="'declared-count-' + formWritable" v-model="form.data.declaredPackageCount" :disabled="!formWritable" :min="1" :max="999999999" :precision="0" :controls="false" placeholder="预报量" aria-label="预报件数" />
+                    <span class="cargo-metric__separator" aria-hidden="true">/</span>
+                    <el-input-number :key="'actual-count-' + cargoWritable" v-model="form.data.actualPackageCount" :disabled="!cargoWritable" :min="1" :max="999999999" :precision="0" :controls="false" placeholder="待录实值" aria-label="实际件数" />
+                    <span class="cargo-metric__unit">{{ form.data.packageUnit || '—' }}</span>
+                  </div>
+                </div>
+                <div class="cargo-metric">
+                  <span class="cargo-metric__label">毛重（委 / 实）</span>
+                  <div class="cargo-metric__inputs">
+                    <el-input-number :key="'declared-weight-' + formWritable" v-model="form.data.declaredGrossWeightKg" :disabled="!formWritable" :min="0.001" :max="999999999999.999" :precision="3" :controls="false" placeholder="预报量" aria-label="预报毛重" />
+                    <span class="cargo-metric__separator" aria-hidden="true">/</span>
+                    <el-input-number :key="'actual-weight-' + cargoWritable" v-model="form.data.actualGrossWeightKg" :disabled="!cargoWritable" :min="0.001" :max="999999999999.999" :precision="3" :controls="false" placeholder="待录实值" aria-label="实际毛重" />
+                    <span class="cargo-metric__unit">KGS</span>
+                  </div>
+                </div>
+                <div class="cargo-metric">
+                  <span class="cargo-metric__label">体积（委 / 实）</span>
+                  <div class="cargo-metric__inputs">
+                    <el-input-number :key="'declared-volume-' + formWritable" v-model="form.data.declaredVolumeCbm" :disabled="!formWritable" :min="0.001" :max="999999999999.999" :precision="3" :controls="false" placeholder="预报量" aria-label="预报体积" />
+                    <span class="cargo-metric__separator" aria-hidden="true">/</span>
+                    <el-input-number :key="'actual-volume-' + cargoWritable" v-model="form.data.actualVolumeCbm" :disabled="!cargoWritable" :min="0.001" :max="999999999999.999" :precision="3" :controls="false" placeholder="待录实值" aria-label="实际体积" />
+                    <span class="cargo-metric__unit">CBM</span>
+                  </div>
+                </div>
+              </div>
+              <div class="booking-group__body--fields">
+                <el-form-item label="包装单位"><el-select v-model="form.data.packageUnit" :disabled="!formWritable" placeholder="请选择包装单位"><el-option label="箱 CARTONS" value="CARTONS" /><el-option label="件 PCS" value="PCS" /><el-option label="托 PALLETS" value="PALLETS" /></el-select></el-form-item>
+                <el-form-item label="唛头和号码"><el-input v-model="form.data.marksAndNos" :disabled="!formWritable" maxlength="1000" /></el-form-item>
+                <el-form-item class="booking-field--wide" label="品名及托运要求"><el-input v-model="form.data.cargoDescription" :disabled="!formWritable" type="textarea" :rows="2" maxlength="1000" placeholder="填写实际品名及免用箱等托运要求" /></el-form-item>
+              </div>
+              <template v-if="detail?.status === 'RELEASED' && cargoWritable">
+                <el-form-item label="补录或修正原因" required><el-input v-model="actualReason" type="textarea" :rows="2" maxlength="1000" placeholder="请填写本次补录或修正原因" /></el-form-item>
+                <div class="actions"><el-button type="primary" :loading="actualSaving" :disabled="workflowBusy || !hasUnsavedActualChanges" @click="saveActualCargo">保存实际货量</el-button></div>
+              </template>
+            </el-form>
+          </section>
+          </div>
+          <aside class="booking-parties" aria-label="订舱关系方"><h3 class="booking-group__title"><span>订舱关系方</span></h3>
+            <el-form class="party-grid density-form" label-position="top" :disabled="!formWritable">
+              <section v-for="(party, index) in form.data.parties" :key="party.partyType" class="subsection booking-party-card">
+                <h3>{{ partyTypes[index]?.label || party.partyType }}</h3>
+                <el-form-item label="单位名称" :required="true"><el-input v-model="party.partyName" :disabled="!formWritable" maxlength="255" :aria-label="`${partyTypes[index]?.label || party.partyType}单位名称（必填）`" placeholder="单位名称" /></el-form-item>
+                <el-form-item label="联系人" ><el-input v-model="party.contactName" :disabled="!formWritable" maxlength="128" :aria-label="`${partyTypes[index]?.label || party.partyType}联系人`" placeholder="联系人" /></el-form-item>
+                <el-form-item label="邮箱" ><el-input v-model="party.contactEmail" :disabled="!formWritable" maxlength="255" :aria-label="`${partyTypes[index]?.label || party.partyType}邮箱`" placeholder="邮箱" /></el-form-item>
+                <el-form-item label="联系电话" ><el-input v-model="party.contactPhone" :disabled="!formWritable" maxlength="64" :aria-label="`${partyTypes[index]?.label || party.partyType}联系电话`" placeholder="联系电话" /></el-form-item>
+                <el-form-item label="税号" ><el-input v-model="party.taxNo" :disabled="!formWritable" maxlength="128" :aria-label="`${partyTypes[index]?.label || party.partyType}税号`" placeholder="税号" /></el-form-item>
+                <el-form-item label="地址" ><el-input v-model="party.address" :disabled="!formWritable" maxlength="1000" :aria-label="`${partyTypes[index]?.label || party.partyType}地址`" placeholder="地址" type="textarea" :rows="2" /></el-form-item>
+              </section>
+            </el-form>
+          </aside>
+        </div>
+
+        <el-form :model="form.data" label-position="top" :disabled="!formWritable" class="density-form booking-requirements">
           <section class="booking-group" aria-label="柜型需求">
-            <h3>柜型需求</h3><div class="booking-group__body">
+            <h3 class="booking-group__title"><span>柜型需求与备注</span></h3><div class="booking-group__body">
             <div class="container-table-wrap" aria-label="柜型需求">
               <div class="workbench-evidence"><table class="container-table density-table">
                 <thead><tr><th scope="col">操作</th><th scope="col">柜型</th><th scope="col">箱种</th><th scope="col">数量</th><th scope="col">容量</th><th scope="col">限重</th><th v-if="detail?.status === 'RELEASED'" scope="col">剩余可关联</th></tr></thead>
@@ -450,19 +599,21 @@ onMounted(() => { void load(); void loadOptions() })
             </div>
           </section>
         </el-form>
+        <footer class="booking-section__footer">
+        <el-tooltip :content="printDisabledReason || '按已保存预报货量打印托运单'" placement="top"><span><el-button type="primary" :disabled="!!printDisabledReason || workflowBusy" @click="openPrint('SHIPPING_INSTRUCTION')"><Printer :size="16" />打印托运单</el-button></span></el-tooltip>
+        </footer>
       </section>
-
-      <section class="workbench-panel is-compact">
-        <h2>订舱关系方</h2>
-        <div class="party-grid">
-          <div v-for="(party, index) in form.data.parties" :key="party.partyType" class="subsection">
-            <h3><span class="required-mark" aria-hidden="true">*</span>{{ partyTypes[index]?.label || party.partyType }}</h3>
-            <el-input v-model="party.partyName" :disabled="!formWritable" :aria-label="`${partyTypes[index]?.label || party.partyType}单位名称（必填）`" placeholder="单位名称（必填）" />
-            <el-input v-model="party.contactName" :disabled="!formWritable" placeholder="联系人" />
-            <el-input v-model="party.contactPhone" :disabled="!formWritable" placeholder="联系电话" />
-            <el-input v-model="party.address" :disabled="!formWritable" placeholder="地址" />
-          </div>
-        </div>
+      <section class="workbench-panel is-compact booking-section booking-section--release" aria-label="放舱信息">
+        <div class="section-title booking-section__heading"><h2><span class="booking-section__number" aria-hidden="true">3</span>二、放舱信息</h2></div>
+        <el-form :model="form.data" label-position="top" :disabled="!formWritable" class="density-form booking-group__body--fields">
+            <el-form-item label="船名" prop="vesselName"><el-input v-model="form.data.vesselName" maxlength="128" placeholder="请输入船名" /></el-form-item>
+            <el-form-item label="航次" prop="voyageNo"><el-input v-model="form.data.voyageNo" maxlength="64" placeholder="请输入航次" /></el-form-item>
+            <el-form-item class="booking-field--wide" label="提单号" prop="billOfLadingNo"><el-input v-model="form.data.billOfLadingNo" maxlength="128" placeholder="请输入提单号" /></el-form-item>
+        </el-form>
+        <footer class="booking-section__footer">
+          <el-button v-if="canRelease" type="primary" plain :loading="actionSaving" :disabled="workflowBusy" @click="openReleaseDialog">放舱</el-button>
+        <el-tooltip :content="printDisabledReason || '按已保存实际货量打印提单确认件'" placement="top"><span><el-button type="primary" :disabled="!!printDisabledReason || workflowBusy" @click="openPrint('BILL_OF_LADING_CONFIRMATION')"><Printer :size="16" />打印提单确认件</el-button></span></el-tooltip>
+        </footer>
       </section>
 
       <OceanBookingDocumentsPanel v-if="detail" :booking-id="detail.id" :booking-no="detail.bookingNo" :booking-version="detail.version" :booking-status="detail.status" :documents="detail.documents" :can-manage="canManageDocuments" :manage-reason="documentManageReason" @updated="updateDocuments" />
@@ -471,15 +622,14 @@ onMounted(() => { void load(); void loadOptions() })
 
       <section v-if="detail" class="workbench-panel is-compact history-panel">
         <div class="section-title"><div><h2>状态历史</h2><p>当前进度：{{ statusLabel(detail.status) }}</p></div></div>
-        <div class="workbench-evidence"><table class="density-table booking-history-table"><thead><tr><th>时间</th><th>状态变化</th><th>操作人</th><th>备注</th></tr></thead><tbody><tr v-for="event in detail.histories" :key="event.id"><td>{{ event.createdAt || '—' }}</td><td>{{ statusLabel(event.fromStatus) }} → {{ statusLabel(event.toStatus) }}</td><td>{{ event.operatorName || '系统' }}</td><td>{{ event.reason || '—' }}</td></tr><tr v-if="!detail.histories.length"><td colspan="4">暂无状态历史</td></tr></tbody></table></div>
+        <div class="workbench-evidence"><table class="density-table booking-history-table"><thead><tr><th>时间</th><th>操作</th><th>状态变化</th><th>操作人</th><th>备注</th></tr></thead><tbody><tr v-for="event in detail.histories" :key="event.id"><td>{{ event.createdAt || '—' }}</td><td>{{ historyActionLabel(event.action) }}</td><td>{{ statusLabel(event.fromStatus) }} → {{ statusLabel(event.toStatus) }}</td><td>{{ event.operatorName || '系统' }}</td><td>{{ event.reason || '—' }}</td></tr><tr v-if="!detail.histories.length"><td colspan="5">暂无状态历史</td></tr></tbody></table></div>
       </section>
       </template>
     </DetailPageLayout>
-    <OceanBookingPrintDialog v-if="detail" v-model="printOpen" :booking-id="detail.id" :booking-no="detail.bookingNo" :allowed="canPrint" />
+    <OceanBookingPrintDialog v-if="detail" v-model="printOpen" :booking-id="detail.id" :booking-no="detail.bookingNo" :allowed="canPrint" :initial-type="printType" @previewed="onPrintPreviewed" />
 
     <AppDialog class="admin-density-dialog admin-workbench is-dialog" v-model="releaseDialogOpen" :title="bookingDialogTitle('确认放舱')" width="min(560px, 94vw)" :confirm-loading="actionSaving" :confirm-disabled="workflowBusy" confirm-text="确认放舱" cancel-text="取消" @confirm="submitRelease">
       <div class="density-dialog-sections">
-        <p class="density-dialog-note">放舱后资料将同步到关联货柜，不能修改、不能删除，请确认资料无误。</p>
         <section class="density-dialog-section"><el-descriptions class="release-summary density-descriptions" :column="2" border>
           <el-descriptions-item label="提单号">{{ form.data.billOfLadingNo || '—' }}</el-descriptions-item>
           <el-descriptions-item label="船名">{{ form.data.vesselName || '—' }}</el-descriptions-item>
@@ -493,6 +643,196 @@ onMounted(() => { void load(); void loadOptions() })
 </template>
 
 <style scoped>
-.channel-code{display:block;margin-left:var(--admin-space-3);color:var(--workbench-muted);font-size:var(--admin-font-caption)}.field-error,.field-hint{display:flex;align-items:center;justify-content:space-between;gap:var(--admin-space-3);margin-top:5px;color:var(--workbench-muted);font-size:var(--admin-font-caption);line-height:20px}.field-error{color:var(--el-color-danger)}
-.booking-detail{min-width:0}.detail-heading{display:flex;min-width:0;gap:var(--admin-space-5);padding:var(--admin-space-3) var(--admin-space-5);background:var(--admin-surface);border:1px solid var(--workbench-border);align-items:center}.booking-page-toolbar{min-width:0;flex:1}.section-title p,.history-panel p{margin:5px 0 0;color:var(--workbench-muted);font-size:var(--admin-font-body)}.heading-status{display:flex;align-items:center;gap:var(--admin-space-3)}.surface-panel h2{margin:0;font-size:var(--admin-font-section)}.section-title{display:flex;justify-content:space-between;gap:var(--admin-space-5);align-items:flex-start;margin-bottom:var(--admin-space-5)}.actions{display:flex;flex-wrap:wrap;gap:var(--admin-space-3)}.booking-groups{display:grid;grid-template-columns:minmax(0,1.35fr) minmax(0,1fr);gap:var(--admin-space-5)}.booking-group{min-width:0;overflow:hidden;background:var(--admin-surface);border:0}.booking-group:last-child{grid-column:1/-1}.booking-group>h3{margin:0;color:#1f2937;font-size:var(--admin-font-section);padding:var(--admin-space-3) 0;border-bottom:1px solid var(--workbench-border)}.booking-group__body{padding:var(--admin-space-3) 0 0}.booking-group__body--fields,.booking-terms{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));column-gap:var(--admin-space-4);row-gap:var(--admin-space-3)}.booking-field--wide{grid-column:1/-1}.booking-terms :deep(.el-select){width:100%}.party-grid{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:var(--admin-space-4);margin-top:var(--admin-space-5)}.subsection{display:grid;gap:var(--admin-space-4);border:0;padding:0}.subsection h3{margin:0;font-size:var(--admin-font-section)}.required-mark{margin-right:var(--admin-space-1);color:var(--el-color-danger)}.container-table-wrap{max-width:100%;overflow-x:auto;margin-bottom:var(--admin-space-4)}.container-table{width:100%;min-width:780px;table-layout:fixed}.container-table th:first-child,.container-table td:first-child{width:80px}.container-table th:nth-child(2),.container-table td:nth-child(2){width:180px}.container-table th:nth-child(3),.container-table td:nth-child(3){width:90px}.container-table th:nth-child(4),.container-table td:nth-child(4){width:110px}.container-table th:nth-child(5),.container-table td:nth-child(5),.container-table th:nth-child(6),.container-table td:nth-child(6){width:100px}.container-table td :deep(.el-select),.container-table td :deep(.el-input){width:100%;min-width:0}.container-table__action{text-align:center!important}.container-table__specification{color:var(--workbench-muted);white-space:nowrap}.container-actions{display:flex;align-items:center;gap:var(--admin-space-4);margin-bottom:var(--admin-space-5);color:var(--workbench-muted);font-size:var(--admin-font-caption)}.add-container{margin:0}@media(max-width:720px){.booking-groups,.party-grid{grid-template-columns:1fr}.booking-group:last-child{grid-column:auto}.detail-heading{flex-direction:column;padding:var(--admin-space-3) var(--admin-space-5);background:var(--admin-surface);border:1px solid var(--workbench-border);align-items:center}.booking-page-toolbar{width:100%}.section-title{flex-direction:column}.actions{width:100%}}@media(max-width:520px){.booking-group__body--fields,.booking-terms{grid-template-columns:1fr}.booking-field--wide{grid-column:auto}}@media(max-width:420px){.booking-group__body{padding:var(--admin-space-3) 0 0}.actions :deep(.el-button){min-height:44px}}.booking-history-table th:nth-child(1){width:180px}.booking-history-table th:nth-child(2){width:220px}.booking-history-table th:nth-child(3){width:140px}.booking-page-toolbar :deep(h1){font-size:var(--admin-font-title)}
+.booking-detail {
+  min-width: 0;
+}
+.detail-heading {
+  display: flex;
+  align-items: center;
+  gap: var(--admin-space-5);
+  min-width: 0;
+  padding: var(--admin-space-3) 0 var(--admin-space-5);
+  border-bottom: 1px solid var(--workbench-border);
+}
+.booking-brand {
+  display: grid;
+  flex: 0 0 36px;
+  place-items: center;
+  width: 36px;
+  height: 36px;
+  border-radius: var(--admin-dialog-section-radius);
+  color: #fff;
+  background: var(--workbench-primary);
+  box-shadow: 0 3px 8px rgb(55 132 250 / 24%);
+}
+.booking-page-toolbar { min-width: 0; flex: 1; }
+.booking-page-toolbar :deep(h1) { font-size: var(--admin-font-title); }
+.booking-page-toolbar :deep(.page-toolbar__description) { margin-top: var(--admin-space-1); font-size: var(--admin-font-caption); color: var(--workbench-muted); }
+.booking-page-actions { align-items: center; }
+.actions { display: flex; flex-wrap: wrap; gap: var(--admin-space-3); }
+.booking-workflow {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  list-style: none;
+  margin: 0 0 var(--admin-space-6);
+  padding: var(--admin-space-6) var(--admin-space-5);
+  border: 1px solid var(--workbench-border);
+  border-radius: var(--admin-dialog-section-radius);
+  background: var(--workbench-surface-tint);
+}
+.booking-workflow li { position: relative; display: grid; justify-items: center; align-content: start; gap: var(--admin-space-3); min-width: 0; }
+.booking-workflow li:not(:last-child)::after {
+  position: absolute;
+  top: 14px;
+  left: calc(50% + 16px);
+  width: calc(100% - 32px);
+  height: 2px;
+  background: var(--workbench-border);
+  content: '';
+}
+.booking-workflow__index {
+  z-index: 1;
+  display: grid;
+  place-items: center;
+  width: 30px;
+  height: 30px;
+  border-radius: 50%;
+  color: var(--workbench-muted);
+  background: var(--workbench-surface-soft);
+  border: 1px solid var(--workbench-border);
+  box-sizing: border-box;
+  font-size: var(--admin-font-section);
+  font-weight: 600;
+}
+.booking-workflow__label { padding: 0 var(--admin-space-2); color: var(--workbench-text); font-size: var(--admin-font-caption); font-weight: 600; text-align: center; line-height: 1.5; }
+.booking-workflow__status { color: var(--workbench-muted); font-size: var(--admin-font-caption); line-height: 18px; text-align: center; }
+.booking-workflow li[data-state='current'] .booking-workflow__index { border-color: var(--workbench-primary); color: #fff; background: var(--workbench-primary); box-shadow: 0 0 0 4px var(--workbench-accent-soft); }
+.booking-workflow li[data-state='current'] .booking-workflow__label,
+.booking-workflow li[data-state='current'] .booking-workflow__status { color: var(--workbench-primary-active); }
+.booking-workflow li[data-state='complete'] .booking-workflow__index { color: var(--workbench-primary-active); background: var(--workbench-accent-soft); border-color: var(--workbench-accent-border); }
+.booking-workflow li[data-state='complete']::after { background: var(--workbench-primary); }
+.booking-workflow li[data-state='pending'] .booking-workflow__label { color: var(--workbench-muted); font-weight: 500; }
+.booking-detail.admin-workbench .booking-section {
+  padding: var(--admin-space-6);
+  margin-bottom: var(--admin-space-6);
+  border-radius: var(--admin-dialog-section-radius);
+}
+.section-title { display: flex; align-items: center; justify-content: space-between; gap: var(--admin-space-5); }
+.booking-section__heading { margin-bottom: var(--admin-space-6); }
+.booking-section__heading h2 {
+  display: flex;
+  align-items: center;
+  gap: var(--admin-space-3);
+  margin: 0;
+  color: var(--workbench-text);
+  font-size: var(--admin-font-section);
+  font-weight: 700;
+  line-height: 24px;
+}
+.booking-section__number {
+  display: inline-grid;
+  flex: 0 0 24px;
+  place-items: center;
+  width: 24px;
+  height: 24px;
+  border-radius: var(--admin-action-radius);
+  background: var(--workbench-primary);
+  color: #fff;
+  box-shadow: 0 2px 5px rgb(55 132 250 / 20%);
+  font-size: var(--admin-font-caption);
+}
+.booking-core { display: grid; grid-template-columns: minmax(0, 1.2fr) minmax(0, 1fr); gap: var(--admin-space-7); }
+.booking-core__main, .booking-parties, .booking-group { min-width: 0; }
+.booking-groups { display: grid; grid-template-columns: 1fr; gap: var(--admin-space-6); }
+.booking-group:last-child { grid-column: 1 / -1; }
+.booking-group__title {
+  display: flex;
+  align-items: center;
+  gap: var(--admin-space-3);
+  margin: 0 0 var(--admin-space-5);
+  color: var(--workbench-muted);
+  font-size: var(--admin-font-caption);
+  font-weight: 600;
+  line-height: 20px;
+}
+.booking-group__title::before { flex: 0 0 5px; width: 5px; height: 5px; border-radius: 50%; background: var(--workbench-accent-border); content: ''; }
+.booking-group__title::after { flex: 1; height: 1px; background: var(--workbench-border); content: ''; }
+.booking-group__body--fields { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); column-gap: var(--admin-space-5); row-gap: var(--admin-space-3); }
+.booking-field--wide { grid-column: 1 / -1; }
+.booking-port-fields { display: grid; grid-template-columns: minmax(76px, .65fr) minmax(0, 1fr); gap: var(--admin-space-2); width: 100%; }
+.booking-core__main > .booking-group { margin-top: var(--admin-space-6); }
+.booking-parties { padding-left: var(--admin-space-7); border-left: 1px solid var(--workbench-border); }
+.party-grid { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: var(--admin-space-4); align-items: start; }
+.booking-party-card { display: grid; min-width: 0; gap: var(--admin-space-3); padding: var(--admin-space-4); border: 1px solid var(--workbench-border); border-radius: var(--admin-dialog-section-radius); background: var(--workbench-surface-tint); }
+.booking-party-card h3 { margin: 0 0 var(--admin-space-1); padding-bottom: var(--admin-space-3); border-bottom: 1px dashed var(--workbench-border); color: var(--workbench-text); font-size: var(--admin-font-body); font-weight: 600; line-height: 20px; }
+/* 网格间距负责排版，避免再叠加 Element 表单项的默认下边距。 */
+.booking-detail :deep(.density-form .el-form-item) { margin-bottom: 0; }
+.booking-detail :deep(.density-form .el-form-item__label) { height: auto; margin-bottom: var(--admin-space-1); padding: 0; color: var(--workbench-muted); font-size: var(--admin-font-caption); font-weight: 500; line-height: 18px; }
+.booking-detail :deep(.density-form .el-input),
+.booking-detail :deep(.density-form .el-select),
+.booking-detail :deep(.density-form .el-textarea) {
+  --el-input-bg-color: var(--workbench-surface);
+  --el-fill-color-blank: var(--workbench-surface);
+  --el-input-text-color: var(--workbench-text);
+  --el-input-border-color: var(--el-border-color-darker);
+  --el-input-hover-border-color: var(--workbench-primary-hover);
+  --el-input-focus-border-color: var(--workbench-primary);
+  --el-border-color: var(--el-border-color-darker);
+  --el-border-color-hover: var(--workbench-primary-hover);
+}
+/* 白底和清晰文字表示可编辑；禁用控件继续使用组件原生灰底、弱文字及禁止光标。 */
+.booking-detail :deep(.density-form .el-input:not(.is-disabled)),
+.booking-detail :deep(.density-form .el-textarea:not(.is-disabled)),
+.booking-detail :deep(.density-form .el-select__wrapper:not(.is-disabled)) {
+  --el-input-placeholder-color: var(--workbench-muted);
+  --el-text-color-placeholder: var(--workbench-muted);
+}
+.booking-detail :deep(.density-form .el-input__inner),
+.booking-detail :deep(.density-form .el-textarea__inner),
+.booking-detail :deep(.density-form .el-select__wrapper) { font-size: var(--admin-font-body); }
+.booking-detail :deep(.density-form .el-input__wrapper),
+.booking-detail :deep(.density-form .el-select__wrapper) { min-height: var(--admin-control-height); box-sizing: border-box; }
+.cargo-metrics { display: grid; gap: var(--admin-space-3); margin-bottom: var(--admin-space-5); }
+.cargo-metric { display: grid; gap: var(--admin-space-1); }
+.cargo-metric__label { color: var(--workbench-muted); font-size: var(--admin-font-caption); font-weight: 500; line-height: 18px; }
+.cargo-metric__inputs { display: grid; grid-template-columns: minmax(0, 1fr) 12px minmax(0, 1fr) 64px; align-items: center; gap: var(--admin-space-2); }
+.cargo-metric__separator { color: var(--workbench-muted); text-align: center; }
+.cargo-metric__unit { color: var(--workbench-muted); font-size: var(--admin-font-caption); }
+.cargo-metric__inputs :deep(.el-input__inner) { text-align: left; }
+.booking-requirements { margin-top: var(--admin-space-6); }
+.container-table-wrap { max-width: 100%; overflow-x: auto; margin-bottom: var(--admin-space-4); }
+.container-table { width: 100%; min-width: 780px; table-layout: fixed; }
+.container-table th:first-child, .container-table td:first-child { width: 80px; }
+.container-table th:nth-child(2), .container-table td:nth-child(2) { width: 180px; }
+.container-table th:nth-child(3), .container-table td:nth-child(3) { width: 90px; }
+.container-table th:nth-child(4), .container-table td:nth-child(4) { width: 110px; }
+.container-table th:nth-child(5), .container-table td:nth-child(5), .container-table th:nth-child(6), .container-table td:nth-child(6) { width: 100px; }
+.container-table td :deep(.el-select), .container-table td :deep(.el-input) { width: 100%; min-width: 0; }
+.container-table__action { text-align: center !important; }
+.container-table__specification { color: var(--workbench-muted); white-space: nowrap; }
+.container-actions { display: flex; align-items: center; gap: var(--admin-space-4); margin-bottom: var(--admin-space-5); color: var(--workbench-muted); font-size: var(--admin-font-caption); }
+.add-container { margin: 0; }
+.booking-section__footer { display: flex; align-items: center; justify-content: flex-end; flex-wrap: wrap; gap: var(--admin-space-3); margin-top: var(--admin-space-6); padding-top: var(--admin-space-5); border-top: 1px dashed var(--workbench-border); }
+.field-error, .field-hint { display: flex; align-items: center; justify-content: space-between; gap: var(--admin-space-3); margin-top: var(--admin-space-1); color: var(--workbench-muted); font-size: var(--admin-font-caption); line-height: 20px; }
+.field-error { color: var(--el-color-danger); }
+.history-panel h2 { margin: 0; font-size: var(--admin-font-section); }
+.history-panel p { margin: var(--admin-space-1) 0 var(--admin-space-5); color: var(--workbench-muted); font-size: var(--admin-font-caption); }
+.booking-history-table th:nth-child(1) { width: 180px; }
+.booking-history-table th:nth-child(2) { width: 160px; }
+.booking-history-table th:nth-child(3) { width: 200px; }
+.booking-history-table th:nth-child(4) { width: 140px; }
+@media(max-width:720px) {
+  .booking-core, .booking-workflow, .party-grid { grid-template-columns: 1fr; }
+  .booking-parties { padding-left: 0; border-left: 0; }
+  .detail-heading { flex-wrap: wrap; }
+  .booking-page-toolbar { width: 100%; }
+  .booking-workflow li:not(:last-child)::after { display: none; }
+}
+@media(max-width:520px) {
+  .booking-group__body--fields { grid-template-columns: 1fr; }
+  .booking-field--wide { grid-column: auto; }
+}
+@media(max-width:420px) {
+  .actions :deep(.el-button) { min-height: 44px; }
+}
 </style>

src/modules/ocean-bookings/types.ts

@@ -32,7 +32,7 @@ export interface OceanBookingAgentOption {
   carrierCodes: OceanBookingCarrierCode[]
 }
 
-export interface OceanBookingParty { id?: string; partyType: string; partyName: string; contactName?: string | null; contactPhone?: string | null; address?: string | null }
+export interface OceanBookingParty { id?: string; partyType: string; partyName: string; contactName?: string | null; contactPhone?: string | null; address?: string | null; contactEmail?: string | null; taxNo?: string | null }
 export interface OceanBookingContainerRequirement {
   id?: string
   requirementId?: string
@@ -53,7 +53,27 @@ export interface OceanBookingAllocatedContainer {
   capacityCbm: number
   maxWeightKg: number
 }
-export interface OceanBookingDraftData {
+export interface OceanBookingCargoData {
+  freightTerm?: string | null
+  serviceTerm?: string | null
+  packageUnit?: 'CARTONS' | 'PCS' | 'PALLETS' | null
+  cargoDescription?: string | null
+  marksAndNos?: string | null
+  declaredPackageCount?: number | null
+  declaredGrossWeightKg?: number | null
+  declaredVolumeCbm?: number | null
+  actualPackageCount?: number | null
+  actualGrossWeightKg?: number | null
+  actualVolumeCbm?: number | null
+}
+export interface OceanBookingActualCargoRequest {
+  expectedVersion: number
+  actualPackageCount: number | null
+  actualGrossWeightKg: number | null
+  actualVolumeCbm: number | null
+  reason: string
+}
+export interface OceanBookingDraftData extends OceanBookingCargoData {
   customerId: string | null; customerName: string | null; parties: OceanBookingParty[]; containerRequirements: OceanBookingContainerRequirement[]
   channelCode: string | null; warehouseId: string | null
   billOfLadingNo: string; vesselName: string; voyageNo: string
@@ -63,7 +83,7 @@ export interface OceanBookingDraftData {
   placeOfDelivery?: string | null
   remark?: string | null
 }
-export interface OceanBookingResource {
+export interface OceanBookingResource extends OceanBookingCargoData {
   id: string; bookingNo: string | null; status: OceanBookingStatus; version: number
   customerId: string | null; customerName: string | null; billOfLadingNo: string | null
   /** 订舱柜型需求 quantity 的总和，不是已关联真实柜数。 */

src/modules/ocean-bookings/workflow.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from 'vitest'
+import { oceanBookingPrintSignature, oceanBookingWorkflow } from './workflow'
+import type { OceanBookingDetail, OceanBookingResource } from './types'
+
+function detail(): OceanBookingDetail {
+  // 流程只消费订舱已保存事实，不依赖权限、选项请求或页面临时输入。
+  const resource: OceanBookingResource = {
+    id: '123', bookingNo: 'OB-123', status: 'DRAFT', version: 1,
+    customerId: null, customerName: null, billOfLadingNo: null,
+    shipperName: null, consigneeName: null, containerCount: 1,
+    channelCode: null, channelName: null, warehouseId: null, warehouseName: null,
+    shippingCompanyId: null, shippingCompanyName: null, carrierCode: null, bookingAgentId: null, bookingAgentName: null,
+    vesselName: null, voyageNo: null, departurePortCode: null, departurePortName: null,
+    destinationPortCode: null, destinationPortName: null, placeOfDelivery: null,
+    estimatedSailingAt: null, estimatedArrivalAt: null, remark: null, createdAt: null, updatedAt: null,
+    orderNo: null, carrierName: null, bookingAgent: null, pol: null, pod: null,
+    mblShipper: null, mblConsignee: null, soNo: null, cutoffAt: null,
+    etd: null, atd: null, eta: null, ata: null, containerSummary: null, amount: null, currency: null,
+    declaredPackageCount: 500, declaredGrossWeightKg: 15000, declaredVolumeCbm: 68,
+    actualPackageCount: null, actualGrossWeightKg: null, actualVolumeCbm: null,
+  }
+  return { ...resource, oceanBooking: resource, parties: [], containerRequirements: [], containers: [], documents: [], histories: [], statusHistory: [] }
+}
+
+describe('ocean booking workflow milestones', () => {
+  it('starts on the first step and does not mark an unsaved form as complete', () => {
+    expect(oceanBookingWorkflow(null, false, false, {}).map(step => step.state))
+      .toEqual(['current', 'pending', 'pending', 'pending'])
+    expect(oceanBookingWorkflow(detail(), true, false, {})[0]).toMatchObject({ state: 'current', status: '修改待保存' })
+  })
+
+  it('advances from saved draft to preview, then to release without inventing a print record', () => {
+    const saved = detail()
+    const initial = oceanBookingWorkflow(saved, false, false, {})
+    expect(initial.map(step => step.state)).toEqual(['complete', 'current', 'pending', 'pending'])
+    expect(initial[0]?.status).toBe('已保存')
+    const previews = { SHIPPING_INSTRUCTION: oceanBookingPrintSignature(saved, 'SHIPPING_INSTRUCTION') }
+    const previewed = oceanBookingWorkflow(saved, false, false, previews)
+    expect(previewed.map(step => step.state)).toEqual(['complete', 'complete', 'current', 'pending'])
+    expect(previewed[1]?.status).toBe('已预览')
+    expect(previewed.some(step => step.status === '已打印')).toBe(false)
+  })
+
+  it('restores released progress from server data and requires all saved actual values before final completion', () => {
+    const saved = detail()
+    saved.status = 'RELEASED'
+    let steps = oceanBookingWorkflow(saved, false, false, {})
+    expect(steps[2]).toMatchObject({ state: 'complete', status: '已放舱' })
+    expect(steps[3]).toMatchObject({ state: 'current', status: '待补齐实值' })
+    saved.actualPackageCount = 480
+    saved.actualGrossWeightKg = 14320
+    saved.actualVolumeCbm = 65
+    const previews = { BILL_OF_LADING_CONFIRMATION: oceanBookingPrintSignature(saved, 'BILL_OF_LADING_CONFIRMATION') }
+    expect(oceanBookingWorkflow(saved, false, true, previews)[3]).toMatchObject({ state: 'current', status: '实值待保存' })
+    steps = oceanBookingWorkflow(saved, false, false, {})
+    expect(steps[3]).toMatchObject({ state: 'current', status: '可预览 / 打印' })
+    expect(oceanBookingWorkflow(saved, false, false, previews)[3]).toMatchObject({ state: 'complete', status: '已预览' })
+  })
+
+  it('invalidates only previews whose actual data changed', () => {
+    const saved = detail()
+    saved.status = 'RELEASED'
+    saved.actualPackageCount = 480; saved.actualGrossWeightKg = 14320; saved.actualVolumeCbm = 65
+    const previews = {
+      SHIPPING_INSTRUCTION: oceanBookingPrintSignature(saved, 'SHIPPING_INSTRUCTION'),
+      BILL_OF_LADING_CONFIRMATION: oceanBookingPrintSignature(saved, 'BILL_OF_LADING_CONFIRMATION'),
+    }
+    saved.version = 100 // 附件等引起的订舱版本变化不会伪造或抹去相同单据的预览事实。
+    saved.actualPackageCount = 490
+    let steps = oceanBookingWorkflow(saved, false, false, previews)
+    expect(steps[1]?.state).toBe('complete')
+    expect(steps[3]).toMatchObject({ state: 'current', status: '可预览 / 打印' })
+    saved.declaredPackageCount = 510
+    steps = oceanBookingWorkflow(saved, false, false, previews)
+    expect(steps[1]?.state).toBe('pending')
+  })
+})

src/modules/ocean-bookings/workflow.ts

@@ -0,0 +1,50 @@
+import type { OceanBookingDetail, OceanBookingPrintType } from './types'
+
+export interface OceanBookingWorkflowStep {
+  label: string
+  status: string
+  state: 'complete' | 'current' | 'pending'
+}
+
+export type OceanBookingPreviewSignatures = Partial<Record<OceanBookingPrintType, string>>
+
+// 预览只对应其实际消费的数据；补录实值不会作废已经预览的托运单。
+export function oceanBookingPrintSignature(detail: OceanBookingDetail, type: OceanBookingPrintType): string {
+  return JSON.stringify([
+    detail.id, detail.billOfLadingNo, detail.vesselName, detail.voyageNo, detail.estimatedSailingAt,
+    detail.shippingCompanyName, detail.bookingAgentName,
+    detail.departurePortCode, detail.departurePortName, detail.destinationPortCode, detail.destinationPortName,
+    detail.placeOfDelivery, detail.serviceTerm, detail.freightTerm, detail.packageUnit,
+    detail.cargoDescription, detail.marksAndNos, detail.remark,
+    detail.parties.map(party => [party.partyType, party.partyName, party.address, party.contactName, party.contactPhone, party.contactEmail, party.taxNo]).sort((a, b) => String(a[0]).localeCompare(String(b[0]))),
+    detail.containerRequirements.map(item => [item.containerType, item.containerKind, item.quantity]),
+    type === 'SHIPPING_INSTRUCTION'
+      ? [detail.declaredPackageCount, detail.declaredGrossWeightKg, detail.declaredVolumeCbm]
+      : [detail.actualPackageCount, detail.actualGrossWeightKg, detail.actualVolumeCbm],
+  ])
+}
+
+export function oceanBookingWorkflow(
+  detail: OceanBookingDetail | null,
+  draftDirty: boolean,
+  actualDirty: boolean,
+  previews: OceanBookingPreviewSignatures,
+): OceanBookingWorkflowStep[] {
+  const saved = Boolean(detail && !draftDirty)
+  const released = detail?.status === 'RELEASED'
+  const actualComplete = Boolean(detail && [detail.actualPackageCount, detail.actualGrossWeightKg, detail.actualVolumeCbm]
+    .every(value => value != null && Number(value) > 0))
+  const previewed = (type: OceanBookingPrintType) => Boolean(detail && previews[type] === oceanBookingPrintSignature(detail, type))
+  const instructionPreviewed = saved && previewed('SHIPPING_INSTRUCTION')
+  const confirmationPreviewed = saved && released && actualComplete && !actualDirty && previewed('BILL_OF_LADING_CONFIRMATION')
+  const current = !saved ? 0 : !released ? instructionPreviewed ? 2 : 1 : confirmationPreviewed ? -1 : 3
+  const step = (index: number, label: string, complete: boolean, status: string): OceanBookingWorkflowStep => ({
+    label, status, state: complete ? 'complete' : current === index ? 'current' : 'pending',
+  })
+  return [
+    step(0, '填写并保存订舱信息', saved, saved ? '已保存' : detail ? '修改待保存' : '待填写并保存'),
+    step(1, '托运单预览 / 打印', instructionPreviewed, instructionPreviewed ? '已预览' : saved ? '可预览 / 打印' : '待保存资料'),
+    step(2, '补齐资料并确认放舱', released, released ? '已放舱' : saved ? '待确认放舱' : '待补齐资料'),
+    step(3, '补实并预览提单确认件', confirmationPreviewed, !released ? '待放舱' : actualDirty ? '实值待保存' : !actualComplete ? '待补齐实值' : confirmationPreviewed ? '已预览' : '可预览 / 打印'),
+  ]
+}

src/modules/overseas-master-data/components/DriverEditorDialog.vue

@@ -5,7 +5,6 @@ import { ElMessage } 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 InlineHelp from '@/shared/components/InlineHelp.vue'
 import { getApiErrorDetails, type ApiErrorDetails } from '@/shared/api/http'
 import { useAccessPreviewStore } from '@/core/access/accessPreview'
 import { overseasMasterDataPermissions as permission } from '../permissions'
@@ -97,7 +96,7 @@ onBeforeUnmount(() => { warehouseRequest++; editSession++ })
       <el-form-item label="可驾驶车型"><el-input v-model="profile.vehicleModels" maxlength="128" placeholder="如 53 尺拖车" /></el-form-item>
       <LoadErrorState v-if="warehouseError" class="full-width" title="仓库候选加载失败" :message="warehouseError.message" @retry="loadWarehouses" ><template #details><ApiErrorMeta :details="warehouseError" /></template></LoadErrorState>
       <el-form-item label="语言 / 服务区域" class="full-width"><el-input v-model="profile.languagesAndArea" maxlength="256" placeholder="如 中文、英语 / 洛杉矶区域" /></el-form-item>
-      <h3 class="full-width driver-section-heading">驾驶资质<InlineHelp title="驾驶资质规则"><p>驾驶证在 30 天内到期但仍有效时允许派车并提醒；预计任务结束前到期则禁止。其他证照日期用于档案记录。</p></InlineHelp></h3>
+      <h3 class="full-width">驾驶资质</h3>
       <el-form-item label="驾照类型"><el-select v-model="form.licenseType" filterable allow-create default-first-option clearable><el-option v-for="kind in ['Class A', 'Class B', 'Class C', '普通驾照']" :key="kind" :label="kind" :value="kind" /></el-select></el-form-item>
       <el-form-item label="驾照编号"><el-input v-model="form.licenseNumber" maxlength="128" placeholder="请输入驾驶证编号" /></el-form-item>
       <el-form-item label="证照有效时区" required><el-select v-model="form.licenseZone" filterable allow-create default-first-option placeholder="请选择或输入 IANA 时区"><el-option v-for="zone in zones" :key="zone" :label="zone" :value="zone" /></el-select></el-form-item>
@@ -106,12 +105,11 @@ onBeforeUnmount(() => { warehouseRequest++; editSession++ })
       <el-form-item label="体检到期日"><el-date-picker v-model="profile.medicalExpiresOn" type="date" value-format="YYYY-MM-DD" /></el-form-item>
       <el-form-item label="培训 / 安全到期日"><el-date-picker v-model="profile.trainingExpiresOn" type="date" value-format="YYYY-MM-DD" /></el-form-item>
       <el-form-item label="保险到期日"><el-date-picker v-model="profile.insuranceExpiresOn" type="date" value-format="YYYY-MM-DD" /></el-form-item>
-      <h3 class="full-width driver-section-heading">证照附件<el-tag v-if="current?.licenseFileId" size="small" type="info">已有附件</el-tag><InlineHelp title="驾驶证上传说明"><p>支持 PDF、JPG、PNG，最大 10MiB。上传新驾驶证后需要重新审核；未上传时可先保存档案，补齐驾驶证后才能通过审核。</p></InlineHelp></h3>
+      <h3 class="full-width driver-section-heading">证照附件<el-tag v-if="current?.licenseFileId" size="small" type="info">已有附件</el-tag></h3>
       <div class="full-width">
         <label v-if="access.can(permission.driverUpload)">驾驶证<input ref="fileInput" type="file" accept="application/pdf,image/jpeg,image/png" :disabled="saving" @change="selectFile" /></label>
-        <p v-if="selectedFile && current?.licenseFileId" class="density-dialog-note" role="status">更换驾驶证后需重新审核。</p>
       </div>
-      <el-form-item label="备注" class="full-width"><el-input v-model="form.remark" type="textarea" :rows="2" maxlength="1000" placeholder="补充司机档案说明（选填）" /></el-form-item>
+      <el-form-item label="备注" class="full-width"><el-input v-model="form.remark" type="textarea" :rows="2" maxlength="1000" /></el-form-item>
     </el-form>
   </AppDialog>
 </template>

src/modules/overseas-warehouse/AGENTS.md

@@ -35,7 +35,7 @@
 
 ## 履约硬边界
 
-- 排车详情固定四个彩色图标页签：车辆信息、排车信息、单据信息、关联订单明细。五个作业阶段及审核分区、逐动作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，复用列表权限；不在前端生成标签或维护模板、尺寸、编码。模板/接口变化才查 [Print 指引](../../../../../baiyue-firstleg/print/AGENTS.md)的托盘入口及[标签维护](../../../../../docs/打印标签维护/README.md)，纯按钮文案不追加打印资料。

src/modules/overseas-warehouse/PROTOTYPE_MATRIX.md

@@ -2,12 +2,12 @@
 
 ## 排车发布内部散板需求（2026-10-21）
 
-依据本轮用户确认默认勾选发布，详见拼车主契约当前页面范围。
+依据用户确认及 2026-10-22 简化要求，详见拼车主契约当前页面范围。
 
 | 页面／操作 | 当前承载与最小调整 | 验收 |
 |---|---|---|
-| 智能排车／新建空单或选货转换 | 保持原弹框，在每车计划信息内增加默认勾选的“发布公共散板需求”；每车独立提交，不新增发布页面 | 本轮8文件115项定向测试及受影响文件类型检查通过；待人工1920×1080、100%截图确认 |
-| 维护车辆信息／保存及提交审核 | 保持原弹框，回显并保存本车发布选项；与原资源命令同事务，后续提交审核使用新版本 | 同上 |
+| 智能排车／新建空单或选货转换 | 保持原弹框，搜索区增加默认不勾选的“发布公共需求”，统一用于本次生成的所有排车单；移除下方计划时间与备注区，沿用关联排车维护 | 3文件59项定向测试通过；组件及两份测试类型检查通过，规划测试原有VueWrapper辅助函数类型不匹配仍阻断其类型检查；待人工1920×1080、100%截图确认 |
+| 维护车辆信息／保存及提交审核 | 保持原弹框，回显并保存本车发布选项；与原资源命令同事务，后续提交审核使用新版本 | 沿用此前8文件115项定向测试及受影响文件类型检查结果；本轮未修改，待人工1920×1080、100%截图确认 |
 
 
 ## 2026-10-21 智能排车区域入口替代仓库搜索
@@ -60,7 +60,7 @@
 | 页面／操作 | 截图承载与当前实现 | 验证 |
 |---|---|---|
 | 排车列表／装车后页签 | 在装车中与派送中之间显示；计数与分页按服务端AFTER_LOADING查询，行内管理资料进入原居中弹框 | 定向自动检查；待1920×1080、100%人工截图确认 |
-| 管理资料／装车资料 | 原居中弹框内两列共五个装车照片框；装车后默认打开，Admin与PDA共享整车照片；第五张保存后自动进入派送中 | 上传恢复、权限和服务端事务定向检查；待人工截图及PDA真机确认 |
+| 管理资料／装车资料 | 原居中弹框内五行装车照片表格（2026-10-22 简化确认），保留图片预览；装车后默认打开，Admin与PDA共享整车照片；第五张保存后自动进入派送中 | 上传恢复、权限和服务端事务定向检查；待人工截图及PDA真机确认 |
 | 装车完成／原请求恢复 | 装车结果为AFTER_LOADING；已确认结果重读失败不重复POST，当前派送状态另读 | 定向恢复检查 |
 
 ## 2026-10-21 智能排车恢复10月18日布局
@@ -445,6 +445,6 @@
 
 | 页面 | 操作 | 原型／确认依据 | 承载与实现 | 验收 |
 |---|---|---|---|---|
-| 排车列表：装车中、装车后、派送中、配送完成 | 管理资料 | 用户管理资料截图及同车／派送单资料共用确认；签收完成即可，其他可补 | 1100px居中可全屏弹框，签收文件／油耗图片／装车资料三个页签；装车中及装车后默认打开装车资料，可同步上传，确认装车且资料齐全后自动派送；按关联派送单切换，共用原派送资料编辑器；油耗沿本车附加照片保存 | 自动回归单独报告；1920×1080、100%待人工截图确认 |
+| 排车列表：装车中、装车后、派送中、配送完成 | 管理资料 | 用户管理资料截图及同车／派送单资料共用确认；2026-10-22 用户截图确认移除资料核对、油耗和装车照片改表格；签收完成即可，其他可补 | 1100px居中可全屏弹框，签收文件／油耗图片／装车资料三个页签；嵌入编辑器隐藏资料核对；三个页签仅显示各自资料，装车资料只保留整车装车照片，不再附带BOL及车辆／司机附件，保存资料按钮仅在签收页签显示，切换保留签收草稿；油耗两行、装车照片五行表格，操作列在首列，保留预览、上传／替换和原保存行为；装车中及装车后默认打开装车资料，可同步上传，确认装车且资料齐全后自动派送；按关联派送单切换，共用原派送资料编辑器；油耗沿本车附加照片保存 | 4文件27项定向测试及受影响组件与测试源码类型检查通过；页签隔离追加修改后5项定向测试及组件／测试类型检查通过；1920×1080、100%待人工截图确认 |
 
 | 仓库派送排车列表 → 维护车辆 | 提交审核入口合并 | 2026-10-21 用户确认：隐藏调整卸货顺序，提交审核移入车辆维护弹框，不需要备注 | 沿用原居中弹框；底部保存／提交审核，提交先保存本次资料及三类照片再按新版本送审；去掉维护和提交备注输入，保留审核驳回原因；详情保持只读 | 定向自动检查单独报告；1920×1080、100%待人工截图确认 |

src/modules/overseas-warehouse/components/DeliveryDocumentsDialog.vue

@@ -118,7 +118,7 @@ async function 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 + '/' + visibleGroups.length + ' 已上传' : loading ? '正在读取…' : '资料未返回' }}</td></tr></tbody></table><p v-if="snapshot" class="density-dialog-note">{{ canEdit ? '上传、替换和删除将在保存资料后生效；关闭将放弃未保存修改。' : '当前账号仅可查看已保存资料。' }}</p></section>
+      <section v-if="!embedded" 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 + '/' + visibleGroups.length + ' 已上传' : loading ? '正在读取…' : '资料未返回' }}</td></tr></tbody></table><p v-if="snapshot" class="density-dialog-note">{{ canEdit ? '上传、替换和删除将在保存资料后生效；关闭将放弃未保存修改。' : '当前账号仅可查看已保存资料。' }}</p></section>
       <template v-if="snapshot">
         <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">

src/modules/overseas-warehouse/components/DispatchDocumentsDialog.test.ts

@@ -15,7 +15,7 @@ const dialogStub = defineComponent({ props: ['modelValue', 'showConfirm'], emits
 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 } } }) }
+function setup() { return mount(DispatchDocumentsDialog, { attachTo: document.body, 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'
@@ -32,6 +32,8 @@ it.each(['LOADING', 'AFTER_LOADING'] as const)('opens loading documents in %s be
   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.find('dispatch-evidence-files-stub').exists()).toBe(false)
+  expect(wrapper.find('.save').exists()).toBe(false)
   expect(wrapper.findAll('[role="tab"]').find(tab => tab.text() === '装车资料')!.attributes('aria-selected')).toBe('true')
   expect(getDeliveryDocuments).not.toHaveBeenCalled(); wrapper.unmount()
 })
@@ -39,6 +41,8 @@ it('reads existing delivery files in one dialog and saves receipt without requir
   const wrapper = setup(); await flushPromises()
   expect(getDeliveryDocuments).toHaveBeenCalledWith('DL-1', '101')
   expect(wrapper.text()).toContain('existing-pod.pdf')
+  expect(wrapper.text()).not.toContain('资料核对')
+  expect(wrapper.find('[aria-label="派送资料摘要"]').exists()).toBe(false)
   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'] }] }))
@@ -48,13 +52,31 @@ it('reads existing delivery files in one dialog and saves receipt without requir
 })
 it('switches customer scope exactly and keeps unsaved delivery edits when switching tabs', async () => {
   const wrapper = setup(); await flushPromises()
+  const receipt = wrapper.getComponent(DeliveryDocumentsDialog)
+  await receipt.findAll('button').find(button => button.text() === '删除')!.trigger('click')
+  expect(receipt.text()).not.toContain('existing-pod.pdf')
   await wrapper.findAll('[role="tab"]').find(tab => tab.text() === '装车资料')!.trigger('click')
-  expect(wrapper.getComponent(DeliveryDocumentsDialog).props('categories')).toEqual(['BOL'])
+  expect(wrapper.getComponent(DeliveryDocumentsDialog).props('categories')).toEqual(['RECEIPT'])
+  expect(receipt.isVisible()).toBe(false)
+  expect(wrapper.find('dispatch-loading-documents-stub').isVisible()).toBe(true)
+  expect(wrapper.find('dispatch-evidence-files-stub').exists()).toBe(false)
+  expect(wrapper.find('.save').exists()).toBe(false)
+  expect(wrapper.text()).not.toContain('关联派送单资料')
+  expect(wrapper.text()).not.toContain('车辆及司机附件')
+  expect(wrapper.find('[data-category="BOL"]').exists()).toBe(false)
   expect(wrapper.find('[data-category="LOADING_PHOTO"]').exists()).toBe(false)
-  expect(wrapper.getComponent(DeliveryDocumentsDialog).text()).toContain('0/1 已上传')
-  await wrapper.getComponent(DeliveryDocumentsDialog).find('input').setValue('BOL-CHANGED')
+  expect(wrapper.getComponent(DeliveryDocumentsDialog).find('[aria-label="派送资料摘要"]').exists()).toBe(false)
   await wrapper.findAll('[role="tab"]').find(tab => tab.text() === '油耗图片')!.trigger('click')
+  expect(wrapper.find('dispatch-loading-documents-stub').exists()).toBe(false)
+  expect(wrapper.find('dispatch-vehicle-documents-stub').isVisible()).toBe(true)
+  expect(receipt.isVisible()).toBe(false)
+  expect(wrapper.find('.save').exists()).toBe(false)
   expect(getDeliveryDocuments).toHaveBeenCalledTimes(1)
+  await wrapper.findAll('[role="tab"]').find(tab => tab.text() === '签收文件')!.trigger('click')
+  expect(receipt.isVisible()).toBe(true)
+  expect(receipt.text()).not.toContain('existing-pod.pdf')
+  expect(wrapper.find('dispatch-vehicle-documents-stub').isVisible()).toBe(false)
+  expect(wrapper.find('.save').exists()).toBe(true)
   const confirmation = vi.spyOn(ElMessageBox, 'confirm').mockRejectedValue('cancel')
   wrapper.getComponent({ name: 'ElSelect' }).vm.$emit('update:modelValue', 'DL-2'); await flushPromises()
   expect(getDeliveryDocuments).toHaveBeenCalledTimes(1)

src/modules/overseas-warehouse/components/DispatchDocumentsDialog.vue

@@ -11,11 +11,9 @@ 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 }>()
@@ -28,7 +26,6 @@ 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++ })
@@ -61,20 +58,18 @@ watch(() => [open.value, props.dispatchNo] as const, ([visible]) => {
 }, { immediate: true })
 </script>
 <template>
-  <AppDialog v-model="open" class="admin-density 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()">
+  <AppDialog v-model="open" class="admin-density 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 === 'RECEIPT' && 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">
-        <h3 v-if="tab === 'LOADING'" class="density-dialog-section__title">关联派送单资料</h3>
+      <div v-show="tab === 'RECEIPT'" 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" />
+        <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="['RECEIPT']" @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>

src/modules/overseas-warehouse/components/DispatchLoadingDocuments.test.ts

@@ -27,11 +27,15 @@ beforeEach(() => {
 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)
+  const table = wrapper.get('table[aria-label="装车照片"]')
+  expect(table.findAll('thead th').map(cell => cell.text())).toEqual(['操作', '照片类别', '文件名称', '图片预览', '保存时间'])
+  expect(table.findAll('tbody tr').map(row => row.findAll('td')[1]!.text())).toEqual(['装车照片 1', '装车照片 2', '装车照片 3', '装车照片 4', '装车照片 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('图片读取失败')
+  expect(table.get('tbody tr').text()).toContain('loading.png')
   wrapper.unmount()
 })
 it('keeps the original binding and file after an unknown result and never uploads again', async () => {

src/modules/overseas-warehouse/components/DispatchLoadingDocuments.vue

@@ -94,22 +94,31 @@ defineExpose({ busy })
     <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">
+    <table class="density-table loading-documents-table" aria-label="装车照片"><thead><tr><th class="photo-actions">操作</th><th class="photo-category">照片类别</th><th>文件名称</th><th class="photo-preview">图片预览</th><th class="photo-time">保存时间</th></tr></thead><tbody>
+      <tr v-for="(slot, index) in loadingPhotoSlots" :key="slot">
+        <td><label v-if="editable" class="photo-upload" :class="{ 'is-disabled': busy || Boolean(pending) }">上传／替换<input type="file" accept="image/jpeg,image/png" :aria-label="`装车照片 ${index + 1}`" :disabled="busy || Boolean(pending)" @change="upload(slot, $event)" /></label><span v-else>—</span></td>
+        <td>装车照片 {{ index + 1 }}</td>
+        <td><div v-for="photo in snapshot?.photos.filter(item => item.slot === slot) || []" :key="photo.fileId">{{ photo.fileName }}</div><span v-if="!snapshot?.photos.some(item => item.slot === slot)">未上传</span></td>
+        <td><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>
+        </template><span v-if="!snapshot?.photos.some(item => item.slot === slot)">—</span></td>
+        <td><div v-for="photo in snapshot?.photos.filter(item => item.slot === slot) || []" :key="photo.fileId">{{ photo.savedAt?.replace('T', ' ') || '—' }}</div><span v-if="!snapshot?.photos.some(item => item.slot === slot)">—</span></td>
+      </tr>
+    </tbody></table>
   </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%; }
+.loading-documents-table { table-layout: fixed; }
+.loading-documents-table td { overflow-wrap: anywhere; }
+.photo-actions { width: 110px; }
+.photo-category { width: 120px; }
+.photo-preview { width: 140px; }
+.photo-time { width: 190px; }
+.loading-photo-image { display: block; width: 100px; height: 64px; }
+.photo-upload { position: relative; display: inline-flex; color: var(--el-color-primary); cursor: pointer; }
+.photo-upload input { position: absolute; inset: 0; width: 100%; height: 100%; opacity: 0; cursor: pointer; }
+.photo-upload:focus-within { outline: 2px solid var(--el-color-primary); outline-offset: 2px; }
+.photo-upload.is-disabled { color: var(--el-text-color-disabled); cursor: not-allowed; }
+.photo-upload.is-disabled input { cursor: not-allowed; }
 </style>

src/modules/overseas-warehouse/components/DispatchVehicleDocuments.test.ts

@@ -22,6 +22,9 @@ beforeEach(() => {
 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 table = first.get('table[aria-label="油耗图片"]')
+  expect(table.findAll('thead th').map(cell => cell.text())).toEqual(['操作', '图片类别', '文件名称', '保存时间'])
+  expect(table.findAll('tbody tr').map(row => row.findAll('td')[1]!.text())).toEqual(['起始油耗表盘', '结束油耗表盘'])
   const original = vi.mocked(bindVehiclePhoto).mock.calls[0]![2]
   expect(original).toMatchObject({ recordVersion: '3', fileId: photo.fileId })
   first.unmount()
@@ -30,6 +33,7 @@ it('binds the uploaded file to the car and restores the original binding after r
   expect(bindVehiclePhoto).toHaveBeenLastCalledWith('PC/1', 'FUEL_START', original)
   expect(uploadVehiclePhoto).toHaveBeenCalledTimes(1)
   expect(reopened.text()).toContain('fuel.png')
+  expect(reopened.get('table tbody tr').text()).toContain('2026-10-21 00:00:00Z')
   expect(sessionStorage.length).toBe(0)
   reopened.unmount()
 })

src/modules/overseas-warehouse/components/DispatchVehicleDocuments.vue

@@ -93,17 +93,28 @@ defineExpose({ busy })
   <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>
+    <table class="density-table fuel-documents-table" aria-label="油耗图片"><thead><tr><th class="photo-actions">操作</th><th class="photo-category">图片类别</th><th>文件名称</th><th class="photo-time">保存时间</th></tr></thead><tbody>
+      <tr v-for="role in roles" :key="role.slot">
+        <td><label v-if="editable" class="photo-upload" :class="{ 'is-disabled': busy || Boolean(pending) }">上传／替换<input type="file" accept="image/jpeg,image/png" :aria-label="role.label" :disabled="busy || Boolean(pending)" @change="upload(role.slot, $event)" /></label><span v-else>—</span></td>
+        <td>{{ role.label }}</td>
+        <td><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?.photos.some(item => item.slot === role.slot)">未上传</span></td>
+        <td><div v-for="photo in snapshot?.photos.filter(item => item.slot === role.slot) || []" :key="photo.fileId">{{ photo.savedAt?.replace('T', ' ') || '—' }}</div><span v-if="!snapshot?.photos.some(item => item.slot === role.slot)">—</span></td>
+      </tr>
+    </tbody></table>
     <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); }
+.fuel-documents-table { table-layout: fixed; }
+.fuel-documents-table td { overflow-wrap: anywhere; }
+.fuel-documents-table :deep(.el-button > span) { white-space: normal; text-align: left; overflow-wrap: anywhere; }
+.photo-actions { width: 110px; }
+.photo-category { width: 160px; }
+.photo-time { width: 190px; }
+.photo-upload { position: relative; display: inline-flex; color: var(--el-color-primary); cursor: pointer; }
+.photo-upload input { position: absolute; inset: 0; width: 100%; height: 100%; opacity: 0; cursor: pointer; }
+.photo-upload:focus-within { outline: 2px solid var(--el-color-primary); outline-offset: 2px; }
+.photo-upload.is-disabled { color: var(--el-text-color-disabled); cursor: not-allowed; }
+.photo-upload.is-disabled input { cursor: not-allowed; }
 .photo-preview { display: block; max-width: 100%; max-height: 400px; object-fit: contain; }
 </style>

src/modules/overseas-warehouse/components/DispatchWorkflowDialog.layout.test.ts

@@ -109,22 +109,22 @@ describe('dispatch workflow native layout', () => {
     expect(api.submitDispatchReview).toHaveBeenCalledExactlyOnceWith('PC/1', expect.objectContaining({ recordVersion: 1, remark: null }))
     expect(vi.mocked(api.updateDispatch).mock.invocationCallOrder[0]).toBeLessThan(vi.mocked(api.submitDispatchReview).mock.invocationCallOrder[0]!)
   })
-  it('retains the locally submitted draft after close and reopen and retries exactly the same failed request', async () => {
-    vi.mocked(api.updateDispatch).mockRejectedValueOnce(new ApiResponseError('结果未确认', 'A0503', 503, null, 'workflow-request')).mockImplementationOnce(async (_, body) => command('EDIT', body.idempotencyKey))
-    const { wrapper, dialog } = await render('EDIT')
-    await field(dialog, '车牌号').get('input').setValue('CA-PRESERVED')
-    dialog.vm.$emit('confirm'); await flushPromises()
-    const original = JSON.parse(JSON.stringify(vi.mocked(api.updateDispatch).mock.calls[0]![1])) as UpdateDispatch
+  it('keeps failed input editable and permits a new request and another target',async()=>{
+    vi.mocked(api.updateDispatch).mockRejectedValueOnce(new ApiResponseError('结果未确认','S0503',200,null,'workflow-request')).mockImplementationOnce(async(_,body)=>command('EDIT',body.idempotencyKey))
+    const {wrapper,dialog}=await render('EDIT')
+    await field(dialog,'车牌号').get('input').setValue('CA-PRESERVED')
+    dialog.vm.$emit('confirm');await flushPromises()
+    const original=structuredClone(vi.mocked(api.updateDispatch).mock.calls[0]![1])
     expect(dialog.text()).toContain('workflow-request')
-    expect(field(dialog, '车牌号').get('input').attributes('disabled')).toBeDefined()
-    await wrapper.setProps({ dispatchNo: 'PC/2', action: 'CANCEL' }); await flushPromises()
-    expect(dialog.props('title')).toBe('维护车辆 · PC/1')
-    await wrapper.setProps({ modelValue: false }); await wrapper.setProps({ modelValue: true }); await flushPromises()
-    expect((field(dialog, '车牌号').get('input').element as HTMLInputElement).value).toBe('CA-PRESERVED')
-    expect(original.remark).toBe('真实备注')
-    expect(dialog.find('textarea[aria-label="本次操作备注"]').exists()).toBe(false)
-    dialog.findComponent(LoadErrorState).vm.$emit('retry'); await flushPromises()
-    expect(vi.mocked(api.updateDispatch).mock.calls[1]![1]).toEqual(original)
+    expect(field(dialog,'车牌号').get('input').attributes('disabled')).toBeUndefined()
+    expect((field(dialog,'车牌号').get('input').element as HTMLInputElement).value).toBe('CA-PRESERVED')
+    await field(dialog,'车牌号').get('input').setValue('CA-CHANGED')
+    dialog.vm.$emit('confirm');await flushPromises()
+    const next=vi.mocked(api.updateDispatch).mock.calls[1]![1]
+    expect(next.vehicle?.plate).toBe('CA-CHANGED');expect(next.idempotencyKey).not.toBe(original.idempotencyKey)
+    expect(api.getDispatchCommand).not.toHaveBeenCalled()
+    await wrapper.setProps({dispatchNo:'PC/2',action:'CANCEL'});await flushPromises()
+    expect(dialog.props('title')).toContain('PC/2')
   })
   it.each(['DISPATCH_REVIEW', 'LOADING_REVIEW'] as const)('keeps %s facts read-only and requires a rejection reason', async action => {
     const { dialog } = await render(action)
@@ -143,7 +143,7 @@ describe('dispatch workflow native layout', () => {
     expect(review).toHaveBeenCalledExactlyOnceWith('PC/1', { recordVersion: 0, idempotencyKey: expect.any(String), decision: 'REJECTED', reason: '证据不完整' })
     expect(dialog.findAll('input[type="file"]')).toHaveLength(0)
   })
-  it.each(['DISPATCH_REVIEW', 'LOADING_REVIEW'] as const)('approves %s directly and keeps an unknown result on the original request', async action => {
+  it.each(['DISPATCH_REVIEW', 'LOADING_REVIEW'] as const)('approves %s directly and permits a new decision after failure', async action => {
     const review = action === 'DISPATCH_REVIEW' ? api.reviewDispatch : api.reviewDispatchLoading
     vi.mocked(review).mockRejectedValueOnce(new Error('结果未知'))
     const { dialog } = await render(action)
@@ -153,10 +153,10 @@ describe('dispatch workflow native layout', () => {
     const original = structuredClone(vi.mocked(review).mock.calls[0]![1])
     expect(dialog.props('showCancel')).toBe(false)
     expect(dialog.findAll('button').some(button => button.text() === '取消')).toBe(false)
-    expect(dialog.findAll('button').some(button => button.text() === '驳回')).toBe(false)
-    await dialog.findAll('button').find(button => button.text() === '核对并重试原请求')!.trigger('click')
+    expect(dialog.findAll('button').some(button => button.text() === '驳回')).toBe(true)
+    await dialog.findAll('button').find(button => button.text() === '审核通过')!.trigger('click')
     await flushPromises()
-    expect(vi.mocked(review).mock.calls[1]![1]).toEqual(original)
+    expect(vi.mocked(review).mock.calls[1]![1].decision).toBe('APPROVED');expect(vi.mocked(review).mock.calls[1]![1].idempotencyKey).not.toBe(original.idempotencyKey)
   })
   it.each(['DISPATCH_REVIEW', 'LOADING_REVIEW'] as const)('disables both %s decisions when write permission is missing', async action => {
     can.mockReturnValue(false)
@@ -169,7 +169,7 @@ describe('dispatch workflow native layout', () => {
     expect(api.reviewDispatch).not.toHaveBeenCalled()
     expect(api.reviewDispatchLoading).not.toHaveBeenCalled()
   })
-  it('uploads all three photos during resource maintenance and retries the exact original edit', async () => {
+  it('retains all three uploaded photos and permits a fresh vehicle save after failure', async () => {
     can.mockImplementation(code => code === 'platform:overseas-warehouse:dispatch:edit')
     vi.mocked(api.updateDispatch).mockRejectedValueOnce(new Error('unknown edit')).mockImplementationOnce(async (_, body) => command('EDIT', body.idempotencyKey))
     const { wrapper, dialog } = await render('EDIT', undefined, true)
@@ -191,16 +191,16 @@ describe('dispatch workflow native layout', () => {
     dialog.vm.$emit('confirm'); await flushPromises()
     const original = structuredClone(vi.mocked(api.updateDispatch).mock.calls[0]![1])
     expect(original).toMatchObject({ vehicle: { evidenceFileIds: ['301', '401'] }, driver: { evidence: { photoFileIds: ['402'], fileIds: expect.arrayContaining(['403']) } } })
-    await wrapper.setProps({ modelValue: false }); await wrapper.setProps({ modelValue: true }); await flushPromises()
     dialog.vm.$emit('confirm'); await flushPromises()
-    expect(vi.mocked(api.updateDispatch).mock.calls[1]![1]).toEqual(original)
+    const next=vi.mocked(api.updateDispatch).mock.calls[1]![1]
+    expect(next).toMatchObject({...original,recordVersion:1,idempotencyKey:expect.any(String)})
+    expect(next.idempotencyKey).not.toBe(original.idempotencyKey)
     expect(api.reviewDispatch).not.toHaveBeenCalled()
     expect(api.reviewDispatchLoading).not.toHaveBeenCalled()
   })
   it.each(['DISPATCH_REVIEW', 'LOADING_REVIEW'] as const)('shows saved photos and old audit evidence read-only in %s', async action => {
     const { wrapper, dialog } = await render(action)
     const value = detail({ actions })
-    value.vehicleInfo.vehicle!.evidenceFileIds = ['401']
     value.vehicleInfo.driver!.evidence!.photoFileIds = ['402']
     value.reviews.dispatchReview.attachments = { vehicleFileIds: [], driverPhotoFileIds: ['403'], licenseFileIds: [] }
     vi.mocked(api.getDispatch).mockResolvedValueOnce(value)
@@ -208,9 +208,6 @@ describe('dispatch workflow native layout', () => {
     const fields = dialog.findAllComponents(DispatchEvidenceFiles)
     expect(fields.map(item => item.props('label'))).toEqual(['车辆图片', '司机照片', '驾驶证照片'])
     expect(fields.every(item => item.props('readonly') && item.props('photoCard'))).toBe(true)
-    expect(fields[0]!.props('modelValue')).toEqual(['401'])
-    expect(api.getDispatchEvidence).toHaveBeenCalledWith('PC/1', 'VEHICLE', '401')
-    expect(api.getDispatchEvidenceContent).toHaveBeenCalledWith('PC/1', 'VEHICLE', '401')
     expect(fields[1]!.props('modelValue')).toEqual(['402', '403'])
     expect(dialog.findAll('input[type="file"]')).toHaveLength(0)
     expect(api.uploadDispatchEvidence).not.toHaveBeenCalled()

src/modules/overseas-warehouse/components/DispatchWorkflowDialog.test.ts

@@ -40,19 +40,22 @@ it('accepts actual evidence and a matching confirmed manifest while refusing an
   const { wrapper, state } = await open('LOADING_COMPLETE'); expect(state.measurements[0]).toMatchObject({ weightKg: 92, volumeCbm: 1.5, deliveryIndex: null })
   await state.submit(); expect(api.completeDispatchLoading).not.toHaveBeenCalled(); wrapper.unmount()
 })
-it.each(['DISPATCH_REVIEW', 'LOADING_REVIEW'] as const)('requires a rejection reason and retains the original %s decision after an unknown result', async action => {
-  const success = vi.spyOn(ElMessage, 'success')
-  const reviewApi = action === 'DISPATCH_REVIEW' ? api.reviewDispatch : api.reviewDispatchLoading
-  const { wrapper, state } = await open(action); state.form.decision = 'REJECTED'
-  await state.submit(); expect(reviewApi).not.toHaveBeenCalled()
-  state.form.reason = '预约未核实'; vi.mocked(reviewApi).mockRejectedValue(new Error('unknown result'))
-  await state.submit(); state.form.reason = 'later changed'; state.form.decision = 'APPROVED'
-  vi.mocked(api.getDispatchCommand).mockImplementation(async (_, key) => command(action, key))
-  vi.mocked(api.getDispatch).mockResolvedValue(detail({ recordVersion: 1 }))
-  await state.submit(); expect(reviewApi).toHaveBeenCalledTimes(1)
-  expect(vi.mocked(reviewApi).mock.calls[0]![1]).toMatchObject({ recordVersion: 0, decision: 'REJECTED', reason: '预约未核实' })
-  expect(success).toHaveBeenCalledWith('已退回客服处理（车辆信息），修改后需重新提交调度审核')
-  expect(wrapper.emitted('saved')).toHaveLength(1); wrapper.unmount()
+it.each(['DISPATCH_REVIEW','LOADING_REVIEW'] as const)('allows editing the %s decision after a failed request',async action=>{
+  const reviewApi=action==='DISPATCH_REVIEW'?api.reviewDispatch:api.reviewDispatchLoading
+  const {wrapper,state}=await open(action);state.form.decision='REJECTED'
+  await state.submit();expect(reviewApi).not.toHaveBeenCalled()
+  state.form.reason='预约未核实';vi.mocked(reviewApi).mockRejectedValueOnce(new Error('unknown result'))
+  await state.submit()
+  expect(useDispatchCommandRecovery(()=>identity.id).pending.value).toBeNull()
+  state.form.reason='重新确认';state.form.decision='APPROVED'
+  vi.mocked(reviewApi).mockImplementationOnce(async(_,body)=>command(action,body.idempotencyKey))
+  vi.mocked(api.getDispatch).mockResolvedValue(detail({recordVersion:1}))
+  await state.submit()
+  const calls=vi.mocked(reviewApi).mock.calls
+  expect(calls).toHaveLength(2)
+  expect(calls[1]![1].decision).toBe('APPROVED')
+  expect(calls[1]![1].idempotencyKey).not.toBe(calls[0]![1].idempotencyKey)
+  expect(api.getDispatchCommand).not.toHaveBeenCalled();wrapper.unmount()
 })
 it('shows the preserved rejection while customer service edits vehicle information', async () => {
   const { wrapper, state } = await open('EDIT')
@@ -81,7 +84,7 @@ it('preserves external destinations and retries route EDIT through its original
   await state.submit(); vi.mocked(api.getDispatchCommand).mockRejectedValueOnce(new ApiResponseError('not found', 'HTTP_404'))
   vi.mocked(api.getDispatch).mockResolvedValue(detail({ recordVersion: 1 })); await state.submit()
   const first = vi.mocked(api.reorderDispatchRoute).mock.calls[0]![1]
-  expect(first).toMatchObject({ recordVersion: 0, destinationKeys: ['PRIVATE:actual', 'CODE:ONT8'], reason: '按本车现场顺序卸货' }); expect(api.reorderDispatchRoute).toHaveBeenNthCalledWith(2, 'PC/1', first); expect(api.updateDispatch).not.toHaveBeenCalled(); expect(toast).toHaveBeenLastCalledWith('卸货顺序调整已确认，请重新核对两级审核'); toast.mockRestore(); wrapper.unmount()
+  expect(first).toMatchObject({ recordVersion: 0, destinationKeys: ['PRIVATE:actual', 'CODE:ONT8'], reason: '按本车现场顺序卸货' }); expect(vi.mocked(api.reorderDispatchRoute).mock.calls[1]![1]).toMatchObject({destinationKeys:first.destinationKeys,reason:first.reason}); expect(vi.mocked(api.reorderDispatchRoute).mock.calls[1]![1].idempotencyKey).not.toBe(first.idempotencyKey); expect(api.updateDispatch).not.toHaveBeenCalled(); expect(toast).toHaveBeenLastCalledWith('卸货顺序调整已确认，请重新核对两级审核'); toast.mockRestore(); wrapper.unmount()
 })
 it('refuses a route that drops an authoritative destination', async () => {
   vi.mocked(api.getDispatchRoute).mockResolvedValue({ dispatchNo: 'PC/1', recordVersion: 0, edit: { allowed: true, blockCode: null, blockReason: null }, stops: [{ index: 0, name: '起运仓', address: null, destinationKey: null }, { index: 1, name: 'ONT8', address: null, destinationKey: 'CODE:ONT8' }, { index: 2, name: '外接点', address: null, destinationKey: 'EXTERNAL:destination' }] })
@@ -133,37 +136,29 @@ it('reports a definite rejection to its parent even if the follow-up GET fails a
   expect(api.submitDispatchReview).toHaveBeenCalledTimes(1)
   wrapper.unmount()
 })
-it('keeps an unknown original command when its later replay is rejected instead of treating it as a fresh rejection', async () => {
-  const { wrapper, state } = await open('SUBMIT_REVIEW')
-  vi.mocked(api.submitDispatchReview).mockRejectedValueOnce(new Error('unknown transport outcome')).mockRejectedValueOnce(new ApiResponseError('当前已提交', 'A0409', 409))
+it('ends every failed request and displays a later business rejection without replaying',async()=>{
+  const {wrapper,state}=await open('SUBMIT_REVIEW')
+  vi.mocked(api.submitDispatchReview).mockRejectedValueOnce(new Error('unknown')).mockRejectedValueOnce(new ApiResponseError('当前已提交','A0409',409))
   await state.submit()
-  const original = structuredClone(vi.mocked(api.submitDispatchReview).mock.calls[0]![1])
-  expect(wrapper.text()).toContain('原操作结果尚待核对')
-  vi.mocked(api.getDispatchCommand).mockRejectedValueOnce(new ApiResponseError('未找到命令', 'A0404', 404))
-  await state.submit(); await flushPromises()
-  expect(api.submitDispatchReview).toHaveBeenNthCalledWith(2, 'PC/1', original)
-  expect(useDispatchCommandRecovery(() => identity.id).pending.value?.body).toEqual(original)
-  expect(wrapper.emitted('rejected')).toBeUndefined()
-  expect(wrapper.emitted('update:modelValue')).toBeUndefined()
-  expect(api.getDispatch).toHaveBeenCalledTimes(1)
-  expect(wrapper.text()).toContain('原操作结果尚待核对')
-  wrapper.unmount()
-})
-it('describes a proven success with a failed GET as completed and retries only its read', async () => {
-  const { wrapper, state } = await open('SUBMIT_REVIEW')
-  vi.mocked(api.submitDispatchReview).mockImplementationOnce(async (_, body) => command('SUBMIT_REVIEW', body.idempotencyKey))
-  vi.mocked(api.getDispatch).mockRejectedValueOnce(new Error('current detail unavailable'))
-  await state.submit(); await flushPromises()
-  expect(useDispatchCommandRecovery(() => identity.id).pending.value?.result).toMatchObject({ action: 'SUBMIT_REVIEW', recordVersion: 1 })
-  expect(wrapper.text()).toContain('操作已完成，页面资料待刷新')
+  expect(useDispatchCommandRecovery(()=>identity.id).pending.value).toBeNull()
   expect(wrapper.text()).not.toContain('原操作结果尚待核对')
-  expect(wrapper.text()).not.toContain('核对并重试原请求')
-  vi.mocked(api.getDispatch).mockResolvedValueOnce(detail({ recordVersion: 1 }))
+  await state.submit();await flushPromises()
+  const calls=vi.mocked(api.submitDispatchReview).mock.calls
+  expect(calls).toHaveLength(2);expect(calls[1]![1].idempotencyKey).not.toBe(calls[0]![1].idempotencyKey)
+  expect(useDispatchCommandRecovery(()=>identity.id).pending.value).toBeNull()
+  expect(api.getDispatchCommand).not.toHaveBeenCalled();expect(wrapper.text()).toContain('当前已提交');wrapper.unmount()
+})
+it('unlocks when a successful write is followed by a failed read',async()=>{
+  const {wrapper,state}=await open('SUBMIT_REVIEW')
+  vi.mocked(api.submitDispatchReview).mockImplementation(async(_,body)=>command('SUBMIT_REVIEW',body.idempotencyKey))
+  vi.mocked(api.getDispatch).mockRejectedValueOnce(new Error('current detail unavailable'))
+  await state.submit();await flushPromises()
+  expect(useDispatchCommandRecovery(()=>identity.id).pending.value).toBeNull()
+  expect(wrapper.text()).not.toContain('原操作结果尚待核对')
+  vi.mocked(api.getDispatch).mockResolvedValue(detail({recordVersion:1}))
   await state.submit()
-  expect(api.submitDispatchReview).toHaveBeenCalledTimes(1)
-  expect(api.getDispatchCommand).not.toHaveBeenCalled()
-  expect(wrapper.emitted('saved')).toHaveLength(1)
-  wrapper.unmount()
+  expect(api.submitDispatchReview).toHaveBeenCalledTimes(2)
+  expect(api.getDispatchCommand).not.toHaveBeenCalled();wrapper.unmount()
 })
 
 it.each(['ADD_CARGO', 'REMOVE_CARGO'] as const)('blocks a fresh %s command and directs cargo changes to smart dispatch', async action => {
@@ -179,23 +174,13 @@ it.each(['ADD_CARGO', 'REMOVE_CARGO'] as const)('blocks a fresh %s command and d
     expect(wrapper.emitted('saved')).toBeUndefined()
   } finally { wrapper.unmount() }
 })
-it.each(['ADD_CARGO', 'REMOVE_CARGO'] as const)('preserves the exact pending %s command for recovery in smart dispatch', async action => {
-  const recovery = useDispatchCommandRecovery(() => identity.id)
-  recovery.begin('PC/ORIGINAL', action, { recordVersion: '9007199254740993', idempotencyKey: 'original-key', reason: 'original reason', cargo: [{ sourceVersion: 'original-source' }] }, action === 'REMOVE_CARGO' ? { itemId: 'original-item' } : {})
-  recovery.pending.value!.attempted = true
-  const original = JSON.parse(JSON.stringify(recovery.pending.value))
-  const { wrapper, state } = await open('EDIT')
-  try {
-    expect(wrapper.text()).toContain('请从智能排车恢复原请求')
-    await state.submit(); await state.retryError()
-    expect(recovery.pending.value).toEqual(original)
-    expect(api.addDispatchCargo).not.toHaveBeenCalled()
-    expect(api.removeDispatchItem).not.toHaveBeenCalled()
-    expect(api.updateDispatch).not.toHaveBeenCalled()
-    expect(api.getDispatchCommand).not.toHaveBeenCalled()
-    expect(wrapper.emitted('saved')).toBeUndefined()
-    expect(wrapper.emitted('rejected')).toBeUndefined()
-  } finally { wrapper.unmount() }
+it.each(['ADD_CARGO','REMOVE_CARGO'] as const)('ignores old %s records when opening another operation',async action=>{
+  sessionStorage.setItem('dispatch-command:'+identity.id,JSON.stringify({dispatchNo:'PC/ORIGINAL',action,attempted:true,body:{idempotencyKey:'old'}}))
+  const {wrapper,state}=await open('EDIT')
+  expect(useDispatchCommandRecovery(()=>identity.id).pending.value).toBeNull()
+  expect(sessionStorage.getItem('dispatch-command:'+identity.id)).toBeNull()
+  expect(wrapper.text()).not.toContain('请从智能排车恢复原请求')
+  expect(api.addDispatchCargo).not.toHaveBeenCalled();expect(api.removeDispatchItem).not.toHaveBeenCalled();wrapper.unmount()
 })
 
 it('requires an exception type and submits optional direction, description and images once', async () => {
@@ -249,33 +234,30 @@ it('rechecks review eligibility after save and leaves the saved editor open if b
   expect(api.submitDispatchReview).not.toHaveBeenCalled(); expect(state.detail.recordVersion).toBe(1)
   expect(wrapper.text()).toContain('预约资料未齐全'); expect(wrapper.emitted('update:modelValue')).toBeUndefined(); wrapper.unmount()
 })
-it('retains the follow-up review intent through an unknown save and does not save twice on recovery', async () => {
-  const { wrapper, state } = await open('EDIT')
-  vi.mocked(api.updateDispatch).mockRejectedValueOnce(new Error('save outcome unknown'))
+it('allows a fresh save and review after a failed save without persisting review intent',async()=>{
+  const {wrapper,state}=await open('EDIT')
+  vi.mocked(api.updateDispatch).mockRejectedValueOnce(new Error('save unknown'))
   await state.submit(true)
-  const pending = useDispatchCommandRecovery(() => identity.id).pending.value!
-  expect(pending.submitReviewAfterSave).toBe(true)
-  expect(JSON.parse(sessionStorage.getItem(`dispatch-command:${identity.id}`)!).submitReviewAfterSave).toBe(true)
-  vi.mocked(api.getDispatchCommand).mockResolvedValueOnce(command('EDIT', String(pending.body.idempotencyKey)))
-  vi.mocked(api.getDispatch).mockResolvedValueOnce(detail({ recordVersion: 1, actions: { SUBMIT_REVIEW: { allowed: true, blockCode: null, blockReason: null } } })).mockResolvedValueOnce(detail({ recordVersion: 2 }))
-  vi.mocked(api.submitDispatchReview).mockImplementationOnce(async (_, body) => ({ ...command('SUBMIT_REVIEW', body.idempotencyKey), recordVersion: 2 }))
-  await state.submit()
-  expect(api.updateDispatch).toHaveBeenCalledTimes(1); expect(api.submitDispatchReview).toHaveBeenCalledTimes(1)
-  expect(useDispatchCommandRecovery(() => identity.id).pending.value).toBeNull(); wrapper.unmount()
+  expect(useDispatchCommandRecovery(()=>identity.id).pending.value).toBeNull()
+  expect(sessionStorage.getItem('dispatch-command:'+identity.id)).toBeNull()
+  vi.mocked(api.updateDispatch).mockImplementationOnce(async(_,body)=>command('EDIT',body.idempotencyKey))
+  vi.mocked(api.getDispatch).mockResolvedValueOnce(detail({recordVersion:1,actions:{SUBMIT_REVIEW:{allowed:true,blockCode:null,blockReason:null}}})).mockResolvedValueOnce(detail({recordVersion:2}))
+  vi.mocked(api.submitDispatchReview).mockImplementationOnce(async(_,body)=>({...command('SUBMIT_REVIEW',body.idempotencyKey),recordVersion:2}))
+  await state.submit(true)
+  expect(api.updateDispatch).toHaveBeenCalledTimes(2);expect(api.submitDispatchReview).toHaveBeenCalledOnce()
+  expect(api.getDispatchCommand).not.toHaveBeenCalled();wrapper.unmount()
 })
-it('recovers an unknown review submission without saving the vehicle again', async () => {
-  const { wrapper, state } = await open('EDIT')
-  vi.mocked(api.updateDispatch).mockImplementationOnce(async (_, body) => command('EDIT', body.idempotencyKey))
-  vi.mocked(api.getDispatch).mockResolvedValueOnce(detail({ recordVersion: 1, actions: { SUBMIT_REVIEW: { allowed: true, blockCode: null, blockReason: null } } }))
-  vi.mocked(api.submitDispatchReview).mockRejectedValueOnce(new Error('review outcome unknown'))
+it('allows a new save-and-review click after review submission fails',async()=>{
+  const {wrapper,state}=await open('EDIT')
+  vi.mocked(api.updateDispatch).mockImplementation(async(_,body)=>command('EDIT',body.idempotencyKey))
+  vi.mocked(api.getDispatch).mockResolvedValue(detail({recordVersion:1,actions:{EDIT:{allowed:true,blockCode:null,blockReason:null},SUBMIT_REVIEW:{allowed:true,blockCode:null,blockReason:null}}}))
+  vi.mocked(api.submitDispatchReview).mockRejectedValueOnce(new Error('review unknown'))
   await state.submit(true)
-  const pending = useDispatchCommandRecovery(() => identity.id).pending.value!
-  expect(pending.action).toBe('SUBMIT_REVIEW'); expect(pending.body).toMatchObject({ recordVersion: 1, remark: null })
-  vi.mocked(api.getDispatchCommand).mockResolvedValueOnce({ ...command('SUBMIT_REVIEW', String(pending.body.idempotencyKey)), recordVersion: 2 })
-  vi.mocked(api.getDispatch).mockResolvedValueOnce(detail({ recordVersion: 2 }))
-  await state.submit()
-  expect(api.updateDispatch).toHaveBeenCalledTimes(1); expect(api.submitDispatchReview).toHaveBeenCalledTimes(1)
-  expect(wrapper.emitted('update:modelValue')).toContainEqual([false]); wrapper.unmount()
+  expect(useDispatchCommandRecovery(()=>identity.id).pending.value).toBeNull()
+  vi.mocked(api.submitDispatchReview).mockImplementationOnce(async(_,body)=>command('SUBMIT_REVIEW',body.idempotencyKey))
+  await state.submit(true)
+  expect(api.updateDispatch).toHaveBeenCalledTimes(2);expect(api.submitDispatchReview).toHaveBeenCalledTimes(2)
+  expect(api.getDispatchCommand).not.toHaveBeenCalled();wrapper.unmount()
 })
 
 it('persists the explicit publication choice with the existing vehicle save', async () => {

src/modules/overseas-warehouse/components/DispatchWorkflowDialog.vue

@@ -166,26 +166,23 @@ async function submit(submitReviewAfterSave = false) {
       if (value.dispatchNo === currentNo.value) detail.value = value
       return value
     }
-    let result = await recovery.execute(send, readCurrent, api.getDispatchCommand)
+    let result = await recovery.execute(send, readCurrent)
     if (!result) return
     if (continueReview) {
       emit('saved')
       if (!canDispatchAction(detail.value?.actions, 'SUBMIT_REVIEW', access.can)) throw new DispatchInputError(detail.value?.actions.SUBMIT_REVIEW?.blockReason || '车辆信息已保存，当前不能提交审核，请核对资料')
       recovery.begin(result.dispatchNo, 'SUBMIT_REVIEW', { recordVersion: requireVersion(detail.value?.recordVersion), idempotencyKey: crypto.randomUUID(), remark: null })
       editorRequestKey = String(pending.value?.body.idempotencyKey || '')
-      result = await recovery.execute(send, readCurrent, api.getDispatchCommand)
+      result = await recovery.execute(send, readCurrent)
       if (!result) return
     }
     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 ? '操作结果尚未确认，请保留原请求核对' : '本次操作未通过，请核对后再提交')
-    // Recovery clears only a fresh, definite rejection. A later refusal must not erase an unknown write.
-    if (!pending.value && isDefiniteDispatchRejection(cause)) {
-      editorRequestKey = ''
-      emit('rejected', error.value)
-      await refreshFacts()
-    }
+    error.value = getApiErrorDetails(cause, cause instanceof DispatchInputError ? cause.message : '本次操作失败，请重试')
+    editorRequestKey = ''
+    if (isDefiniteDispatchRejection(cause)) emit('rejected', error.value)
+    if (!(cause instanceof DispatchInputError)) await refreshFacts()
   } finally { submitting.value = false }
 }
 async function refreshFacts() {
@@ -214,12 +211,11 @@ function moveStop(index: number, offset: number) { const target = index + offset
 watch([open, () => props.dispatchNo, () => props.action, () => props.operation], ([value]) => { if (value) void load(); else { generation++ } }, { immediate: true })
 </script>
 <template>
-  <AppDialog v-model="open" class="admin-density-dialog admin-density admin-workbench is-dialog" :title="(currentOperation === 'ROUTE' ? '调整卸货顺序' : dispatchActionLabels[currentAction]) + ' · ' + (currentNo || '—')" :width="width" :fullscreenable="width !== '560px'" :show-cancel="!isReview" :loading="loading" :confirm-loading="submitting || busy || uploadingEvidence" :confirm-disabled="cargoAction || loading || uploadingEvidence || !pending && !allowed" :confirm-text="cargoAction ? '请从智能排车修改' : pending?.result ? '刷新页面资料' : pending ? '核对并重试原请求' : currentAction === 'MARK_EXCEPTION' ? '保存' : '确认提交'" @confirm="submit()">
+  <AppDialog v-model="open" class="admin-density-dialog admin-density admin-workbench is-dialog" :title="(currentOperation === 'ROUTE' ? '调整卸货顺序' : dispatchActionLabels[currentAction]) + ' · ' + (currentNo || '—')" :width="width" :fullscreenable="width !== '560px'" :show-cancel="!isReview" :loading="loading" :confirm-loading="submitting || busy || uploadingEvidence" :confirm-disabled="cargoAction || loading || uploadingEvidence || !pending && !allowed" :confirm-text="cargoAction ? '请从智能排车修改' : currentAction === 'MARK_EXCEPTION' ? '保存' : '确认提交'" @confirm="submit()">
     <div class="density-dialog-sections">
       <el-alert v-if="cargoAction" :title="cargoEntryMessage" type="warning" :closable="false" show-icon />
       <el-alert v-if="dispatchRejectionReason(detail?.reviews)" title="已退回客服处理，请核对原因后重新提交调度审核。" :description="dispatchRejectionReason(detail?.reviews)" type="warning" :closable="false" show-icon />
-      <el-alert v-if="pending && !cargoAction" role="status" :title="pending.result ? '操作已完成，页面资料待刷新；刷新不会再次提交。' : '原操作结果尚待核对，当前使用原版本和原请求内容。'" :type="pending.result ? 'info' : 'warning'" :closable="false" show-icon />
-      <LoadErrorState v-if="error && !cargoAction" :title="pending?.result ? '操作已完成，页面资料待刷新' : '排车操作未完成'" :message="error.message" :loading="loading || busy || uploadingEvidence" :retry-text="pending?.result ? '刷新页面资料' : pending ? '核对原请求' : '刷新当前资料'" @retry="retryError"><template #details><ApiErrorMeta :details="error" /></template></LoadErrorState>
+      <LoadErrorState v-if="error && !cargoAction" title="排车操作未完成" :message="error.message" :loading="loading || busy || uploadingEvidence" retry-text="刷新当前资料" @retry="retryError"><template #details><ApiErrorMeta :details="error" /></template></LoadErrorState>
       <el-alert v-if="detail && !allowed && !pending" :title="detail?.actions[currentAction]?.blockReason || '当前操作未获得允许，请核对权限与作业状态'" type="warning" :closable="false" show-icon />
       <el-form v-if="detail && !cargoAction" class="density-form density-dialog-sections" label-position="left" label-width="130px" :disabled="frozen || loading || uploadingEvidence || !allowed">
         <section v-if="currentOperation === 'ROUTE' && route" class="density-dialog-section" data-tone="source" aria-label="本车卸货顺序"><h3 class="density-dialog-section__title">卸货顺序</h3>
@@ -268,7 +264,7 @@ watch([open, () => props.dispatchNo, () => props.action, () => props.operation],
     <template v-if="vehicleEditor" #footer="{ close }">
       <el-button :disabled="submitting || busy || uploadingEvidence" @click="close">取消</el-button>
       <el-button v-if="!pending" :disabled="submitting || loading || uploadingEvidence || !allowed" @click="submit()">保存</el-button>
-      <el-button type="primary" :loading="submitting || busy" :disabled="loading || uploadingEvidence || !pending && !allowed" @click="submit(true)">{{ pending?.result ? '刷新页面资料' : pending ? '核对并重试原请求' : '提交审核' }}</el-button>
+      <el-button type="primary" :loading="submitting || busy" :disabled="loading || uploadingEvidence || !pending && !allowed" @click="submit(true)">提交审核</el-button>
     </template>
     <template v-else-if="isReview && !pending" #footer>
       <div class="workflow-review-actions">

src/modules/overseas-warehouse/components/SmartDispatchDialog.layout.test.ts

@@ -186,23 +186,21 @@ describe('new dispatch native layout', () => {
     expect(view(dialog).get('[aria-label="第 1 辆车"]').text()).toContain('托数 1/30')
     expect(view(dialog).find('[aria-label="托盘明细"] tr[draggable]').exists()).toBe(false)
   })
-  it('retains the exact first-group command after an unknown result without creating a second draft', async () => {
-    const empty: DispatchDraft = { ...draft(), containers: [], sources: [] }
+  it('unlocks after a failed first container and accepts a new cargo click',async()=>{
+    const empty:DispatchDraft={...draft(),containers:[],sources:[]}
+    vi.mocked(api.listDispatchDrafts).mockResolvedValue([empty])
     vi.mocked(api.createDispatchDraft).mockResolvedValue(empty)
-    vi.mocked(api.createDispatchDraftContainer).mockRejectedValueOnce(new Error('network unknown')).mockResolvedValueOnce({ ...empty, recordVersion: 1, containers: [{ draftContainerId: 'first-group', sequenceNo: 1, capacity: 30, sourceKeys: [] }] })
-    const { dialog } = await render(); await selectWarehouse(dialog)
-    await selectFirstOrder(dialog)
-    await view(dialog).get('button[aria-label^="将托盘 "]').trigger('click'); await flushPromises()
-    const original = vi.mocked(api.createDispatchDraftContainer).mock.calls[0]![0]
-    expect(dialog.props('confirmDisabled')).toBe(false)
-    dialog.vm.$emit('confirm'); await flushPromises()
-    expect(api.createDispatchDraft).toHaveBeenCalledTimes(1)
-    expect(api.createDispatchDraftContainer).toHaveBeenNthCalledWith(2, original)
-    expect(api.lockDispatchDraftPallet).not.toHaveBeenCalled()
-    expect(dialog.findComponent(DispatchResourceFields).exists()).toBe(false)
-    expect(api.convertDispatchDraft).not.toHaveBeenCalled()
+    vi.mocked(api.createDispatchDraftContainer).mockRejectedValueOnce(new Error('network unknown')).mockResolvedValueOnce({...empty,recordVersion:1,containers:[{draftContainerId:'first-group',sequenceNo:1,capacity:30,sourceKeys:[]}]})
+    const {dialog}=await render();await selectWarehouse(dialog);await selectFirstOrder(dialog)
+    await view(dialog).get('button[aria-label^="将托盘 "]').trigger('click');await flushPromises()
+    expect(dialog.props('confirmDisabled')).toBe(true)
+    expect(field(dialog,'建单方式').getComponent({name:'ElRadioGroup'}).props('disabled')).toBe(false)
+    await view(dialog).get('button[aria-label^="将托盘 "]').trigger('click');await flushPromises()
+    const calls=vi.mocked(api.createDispatchDraftContainer).mock.calls
+    expect(calls).toHaveLength(2);expect(calls[1]![0].idempotencyKey).not.toBe(calls[0]![0].idempotencyKey)
+    expect(api.createDispatchDraft).toHaveBeenCalledOnce();expect(api.lockDispatchDraftPallet).toHaveBeenCalledOnce()
   })
-  it('requires an active cargo group before accepting per-group settings while keeping setup controls available', async () => {
+  it('keeps publication available before cargo selection without extra planning fields', async () => {
     const { dialog } = await render()
     expect(view(dialog).find('[aria-label="排车设置"] table').exists()).toBe(false)
     expect(view(dialog).find('[aria-label="排车设置"] .density-dialog-note').exists()).toBe(false)
@@ -215,14 +213,16 @@ describe('new dispatch native layout', () => {
     expect(field(dialog, '建单方式').getComponent({ name: 'ElRadioGroup' }).props('disabled')).toBe(false)
     await restore(dialog)
     expect(dialog.findComponent(DispatchResourceFields).exists()).toBe(false)
-    expect(field(dialog, '备注').get('input').attributes('disabled')).toBeUndefined()
+    expect(view(dialog).get('.dispatch-candidate-query input[type="checkbox"]').attributes('disabled')).toBeUndefined()
   })
-  it('creates an unassigned empty dispatch while preserving optional dates and remark through fullscreen', async () => {
+  it('creates an empty dispatch with optional publication preserved through fullscreen', async () => {
     const { dialog } = await render(); await emptyMode(dialog); await selectWarehouse(dialog)
     expect(dialog.findComponent(DispatchResourceFields).exists()).toBe(false)
-    field(dialog, '计划发车时间').getComponent({ name: 'ElDatePicker' }).vm.$emit('update:modelValue', '2026-11-02T10:00:00Z')
-    field(dialog, '预计到达时间').getComponent({ name: 'ElDatePicker' }).vm.$emit('update:modelValue', '2026-11-02T18:00:00Z')
-    await field(dialog, '备注').get('input').setValue('本趟备注')
+    expect(view(dialog).find('[aria-label="排车计划时间与备注"]').exists()).toBe(false)
+    expect(view(dialog).findComponent({ name: 'ElDatePicker' }).exists()).toBe(false)
+    const publication = view(dialog).get('.dispatch-candidate-query input[type="checkbox"]')
+    expect(publication.element).toHaveProperty('checked', false)
+    await publication.setValue(true)
     expect(dialog.findComponent({ name: 'ElDialog' }).props('fullscreen')).toBe(true)
     await view(dialog).get('button[aria-label="退出全屏"]').trigger('click'); await flushPromises()
     expect(dialog.findComponent({ name: 'ElDialog' }).props('fullscreen')).toBe(false)
@@ -231,7 +231,7 @@ describe('new dispatch native layout', () => {
     expect(view(dialog).text()).toContain('空单暂不能核平、装车或发车')
     expect(view(dialog).find('[aria-label="智能排车三栏选货"]').exists()).toBe(false)
     await view(dialog).findAll('button').find(button => button.text() === '保存空排车单')!.trigger('click'); await flushPromises()
-    expect(api.createDispatch).toHaveBeenCalledExactlyOnceWith({ idempotencyKey: expect.any(String), warehouseId: '321', cargo: [], batchAllocations: [], plannedDepartureAt: '2026-11-02T10:00:00Z', estimatedArrivalAt: '2026-11-02T18:00:00Z', remark: '本趟备注', vehicle: null, driver: null })
+    expect(api.createDispatch).toHaveBeenCalledExactlyOnceWith({ idempotencyKey: expect.any(String), publishLooseboardDemand: true, warehouseId: '321', cargo: [], batchAllocations: [], plannedDepartureAt: null, estimatedArrivalAt: null, remark: null, vehicle: null, driver: null })
   })
   it('creates with only the warehouse and never requests vehicle or driver directories', async () => {
     const { dialog } = await render(); await emptyMode(dialog); await selectWarehouse(dialog)
@@ -241,15 +241,14 @@ describe('new dispatch native layout', () => {
     expect(listVehicles).not.toHaveBeenCalled()
     expect(listDrivers).not.toHaveBeenCalled()
   })
-  it('keeps each group configuration independent and verifies proven conversions without creating them twice', async () => {
+  it('applies publication to all cars and keeps it editable after conversion read failure', async () => {
     vi.mocked(api.getDispatch).mockRejectedValueOnce(new Error('details not ready')).mockImplementation(async no => detail({ dispatchNo: no, recordVersion: 1 }))
     const { wrapper, dialog } = await render(); await restore(dialog)
-    await field(dialog, '备注').get('input').setValue('第一组')
+    await view(dialog).get('.dispatch-candidate-query input[type="checkbox"]').setValue(true)
     const radios = view(dialog).get('[aria-label="车辆装载"]').findAll('input[type="radio"]')
     await radios[1]!.setValue(true); await flushPromises()
-    await field(dialog, '备注').get('input').setValue('第二组')
     await radios[0]!.setValue(true); await flushPromises()
-    expect((field(dialog, '备注').get('input').element as HTMLInputElement).value).toBe('第一组')
+    expect(view(dialog).get('.dispatch-candidate-query input[type="checkbox"]').element).toHaveProperty('checked', true)
     expect(dialog.findComponent({ name: 'ElDialog' }).props('fullscreen')).toBe(true)
     await view(dialog).get('button[aria-label="退出全屏"]').trigger('click'); await flushPromises()
     expect(dialog.findComponent({ name: 'ElDialog' }).props('fullscreen')).toBe(false)
@@ -258,14 +257,14 @@ describe('new dispatch native layout', () => {
     expect(api.convertDispatchDraft).toHaveBeenCalledTimes(1)
     const request = vi.mocked(api.convertDispatchDraft).mock.calls[0]![0]
     expect(request.recordVersion).toBe(0)
-    expect(request.groups.map(group => [group.dispatch.vehicle, group.dispatch.driver, group.dispatch.remark])).toEqual([[null, null, '第一组'], [null, null, '第二组']])
+    expect(request.groups.map(group => [group.dispatch.publishLooseboardDemand, group.dispatch.plannedDepartureAt, group.dispatch.estimatedArrivalAt, group.dispatch.remark])).toEqual([[true, null, null, null], [true, null, null, null]])
     expect(wrapper.emitted('created')).toBeUndefined()
-    expect(view(dialog).text()).toContain('草稿操作结果未确认，原请求已保留')
-    dialog.findComponent(LoadErrorState).vm.$emit('retry'); await flushPromises()
-    expect(api.convertDispatchDraft).toHaveBeenCalledTimes(1)
+    expect(view(dialog).text()).toContain('本次排车操作失败，请重试')
+    dialog.vm.$emit('confirm'); await flushPromises()
+    expect(api.convertDispatchDraft).toHaveBeenCalledTimes(2)
     expect(wrapper.emitted('created')).toHaveLength(1)
   })
-  it('locks the real frame and all resource edits while pending and reuses the original conversion after failure', async () => {
+  it('prevents active double clicks but unlocks editing and starts a new conversion after failure', async () => {
     let reject!: (reason: unknown) => void
     vi.mocked(api.convertDispatchDraft).mockReturnValueOnce(new Promise((_, no) => { reject = no })).mockImplementationOnce(async body => ({ draftToken: body.draftToken, replayed: true, vehicles: body.groups.map((group, index) => ({ draftContainerId: group.draftContainerId, dispatch: command('CREATE', group.dispatch.idempotencyKey, `PC/${index + 1}`) })) }))
     const { wrapper, dialog } = await render(); await restore(dialog)
@@ -275,15 +274,16 @@ describe('new dispatch native layout', () => {
     expect(dialog.props('confirmText')).toBe('生成排车单')
     const original = JSON.parse(JSON.stringify(vi.mocked(api.convertDispatchDraft).mock.calls[0]![0])) as ConvertDraft
     expect(dialog.findComponent({ name: 'ElDialog' }).props()).toMatchObject({ showClose: false, closeOnPressEscape: false })
-    expect(field(dialog, '备注').get('input').attributes('disabled')).toBeDefined()
+    expect(view(dialog).get('.dispatch-candidate-query input[type="checkbox"]').attributes('disabled')).toBeDefined()
     reject(new ApiResponseError('转换结果尚未确认', 'A0503', 503, null, 'new-dispatch-request')); await flushPromises()
     expect(view(dialog).text()).toContain('new-dispatch-request')
-    expect(view(dialog).text()).toContain('原请求结果尚待核对')
-    expect(dialog.props('confirmText')).toBe('重试原请求')
+    expect(view(dialog).text()).not.toContain('原请求结果尚待核对')
+    expect(dialog.props('confirmText')).toBe('生成排车单')
+    expect(view(dialog).get('.dispatch-candidate-query input[type="checkbox"]').attributes('disabled')).toBeUndefined()
     expect(dialog.findComponent(DispatchResourceFields).exists()).toBe(false)
     await wrapper.setProps({ modelValue: false }); await wrapper.setProps({ modelValue: true }); await flushPromises()
     dialog.vm.$emit('confirm'); await flushPromises()
-    expect(vi.mocked(api.convertDispatchDraft).mock.calls[1]![0]).toEqual(original)
+    expect(vi.mocked(api.convertDispatchDraft).mock.calls[1]![0].idempotencyKey).not.toBe(original.idempotencyKey)
   })
   it('keeps all current-page orders and reveals complete pallet source details only after selecting an order', async () => {
     const rows = Array.from({ length: 20 }, (_, index) => candidate({ sourceKey: `SOURCE-${index}`, palletNo: `PALLET-${index}`, orderNo: `ORDER-${index}`, customerName: '很长的客户名称'.repeat(8) }))
@@ -344,40 +344,27 @@ describe('new dispatch native layout', () => {
     expect(view(dialog).text()).not.toContain('原请求结果尚待核对')
     expect(dialog.getComponent(SmartDispatchCargoBoard).props('disabled')).toBe(false)
   })
-  it.each(['rejection', 'unknown'] as const)('handles an empty-car deletion %s without confusing rejected and unknown results', async failure => {
-    const empty = { ...draft(), sources: [], containers: [{ ...draft().containers[0]!, sourceKeys: [] }] }
+  it.each(['rejection','unknown'] as const)('unlocks an empty-car deletion after %s and accepts another click',async failure=>{
+    const empty={...draft(),sources:[],containers:[{...draft().containers[0]!,sourceKeys:[]}]}
     vi.mocked(api.listDispatchDrafts).mockResolvedValue([empty])
-    vi.mocked(api.deleteDispatchDraftContainer).mockRejectedValueOnce(failure === 'rejection'
-      ? new ApiResponseError('仅空容器可以删除', 'A0409', 409, null, 'delete-request') : new Error('network unknown'))
-    const { dialog } = await render(); await restore(dialog)
-    await view(dialog).findAll('button').find(button => button.text() === '删除车辆')!.trigger('click'); await flushPromises()
-    expect(api.deleteDispatchDraftContainer).toHaveBeenCalledTimes(1)
-    expect(view(dialog).find('[aria-label="第 1 辆车"]').exists()).toBe(true)
-    expect(dialog.getComponent(SmartDispatchCargoBoard).props('disabled')).toBe(failure === 'unknown')
-    if (failure === 'rejection') {
-      expect(view(dialog).text()).toContain('仅空容器可以删除')
-      expect(view(dialog).text()).not.toContain('原请求结果尚待核对')
-      expect(sessionStorage.getItem(`dispatch-draft-command:${identity.id}`)).toBeNull()
-    } else {
-      const original = vi.mocked(api.deleteDispatchDraftContainer).mock.calls[0]!
-      vi.mocked(api.deleteDispatchDraftContainer).mockRejectedValueOnce(new ApiResponseError('仅空容器可以删除', 'A0409', 409))
-      dialog.vm.$emit('confirm'); await flushPromises()
-      expect(api.deleteDispatchDraftContainer).toHaveBeenNthCalledWith(2, ...original)
-      expect(view(dialog).text()).toContain('原请求结果尚待核对')
-      expect(sessionStorage.getItem(`dispatch-draft-command:${identity.id}`)).not.toBeNull()
-      vi.mocked(api.deleteDispatchDraftContainer).mockResolvedValueOnce({ ...empty, recordVersion: 1, containers: [] })
-      dialog.vm.$emit('confirm'); await flushPromises()
-      expect(api.deleteDispatchDraftContainer).toHaveBeenNthCalledWith(3, ...original)
-      expect(sessionStorage.getItem(`dispatch-draft-command:${identity.id}`)).toBeNull()
-    }
+    vi.mocked(api.deleteDispatchDraftContainer).mockRejectedValueOnce(failure==='rejection'?new ApiResponseError('仅空容器可以删除','A0409',409):new Error('network unknown'))
+    const {dialog}=await render();await restore(dialog)
+    await view(dialog).findAll('button').find(button=>button.text()==='删除车辆')!.trigger('click');await flushPromises()
+    expect(dialog.getComponent(SmartDispatchCargoBoard).props('disabled')).toBe(false)
+    expect(view(dialog).text()).not.toContain('原请求结果尚待核对')
+    expect(sessionStorage.getItem('dispatch-draft-command:'+identity.id)).toBeNull()
+    vi.mocked(api.deleteDispatchDraftContainer).mockResolvedValueOnce({...empty,recordVersion:1,containers:[]})
+    await view(dialog).findAll('button').find(button=>button.text()==='删除车辆')!.trigger('click');await flushPromises()
+    const calls=vi.mocked(api.deleteDispatchDraftContainer).mock.calls
+    expect(calls).toHaveLength(2);expect(calls[1]![2].idempotencyKey).not.toBe(calls[0]![2].idempotencyKey)
   })
-  it('clears a saved definite rejection on reopen while restoring the original draft', async () => {
+  it('clears a saved definite rejection on reopen without restoring the failed request', async () => {
     sessionStorage.setItem(`dispatch-draft-command:${identity.id}`, JSON.stringify({ action: 'DELETE', attempted: true, rejected: true, containerId: 'container-1', body: { draftToken: 'server-token', recordVersion: 0, idempotencyKey: 'rejected-key' } }))
     const { dialog } = await render()
     expect(view(dialog).text()).not.toContain('原请求结果尚待核对')
     expect(sessionStorage.getItem(`dispatch-draft-command:${identity.id}`)).toBeNull()
     expect(api.deleteDispatchDraftContainer).not.toHaveBeenCalled()
-    expect(view(dialog).get('[aria-label="第 1 辆车"]').text()).toContain('PALLET-1')
+    expect(view(dialog).text()).not.toContain('原请求结果尚待核对')
     expect(dialog.getComponent(SmartDispatchCargoBoard).props('disabled')).toBe(false)
   })
   it('keeps creation unavailable without its write permission', async () => {

src/modules/overseas-warehouse/components/SmartDispatchDialog.planning.test.ts

@@ -79,7 +79,6 @@ async function render() {
   return wrapper.getComponent(AppDialog)
 }
 function view(dialog: VueWrapper) { return dialog.getComponent({ name: 'ElDialogContent' }) }
-function field(dialog: VueWrapper, label: string) { return dialog.findAllComponents({ name: 'ElFormItem' }).find(row => row.props('label') === label)! }
 function button(dialog: VueWrapper, label: string) { return view(dialog).findAll('button').find(row => row.text() === label)! }
 function car(dialog: VueWrapper, index: number) { return view(dialog).get(`article[aria-label="第 ${index} 辆车"]`) }
 function cargoRow(dialog: VueWrapper, palletNo: string) { return view(dialog).get(`[aria-label="托盘 ${palletNo}"]`) }
@@ -128,24 +127,24 @@ describe('three-column cargo planning through visible controls', () => {
     expect(api.lockDispatchDraftPallet).not.toHaveBeenCalled()
     expect(dialog.props('confirmDisabled')).toBe(true)
   })
-  it('retains the first car cargo, isolates per-car fields and adds later cargo to the car selected again', async () => {
+  it('retains car cargo and the publication choice when switching cars', async () => {
     const dialog = await render(); await warehouseSelected(dialog); await join(dialog, 'PALLET-1')
-    await field(dialog, '备注').get('input').setValue('第一车独立备注')
+    await view(dialog).get('.dispatch-candidate-query input[type="checkbox"]').setValue(true)
     await button(dialog, '添加车辆').trigger('click'); await flushPromises()
     expect(car(dialog, 1).text()).toContain('PALLET-1')
     expect(car(dialog, 2).get('input[type="radio"]').element).toHaveProperty('checked', true)
     expect(dialog.findComponent(DispatchResourceFields).exists()).toBe(false)
-    await field(dialog, '备注').get('input').setValue('第二车独立备注'); await join(dialog, 'PALLET-2')
+    await join(dialog, 'PALLET-2')
     expect(vi.mocked(api.lockDispatchDraftPallet).mock.calls[1]![0].draftContainerId).toBe('container-2')
     await chooseCar(dialog, 1)
     expect(dialog.findComponent(DispatchResourceFields).exists()).toBe(false)
-    expect((field(dialog, '备注').get('input').element as HTMLInputElement).value).toBe('第一车独立备注')
+    expect(view(dialog).get('.dispatch-candidate-query input[type="checkbox"]').element).toHaveProperty('checked', true)
     await join(dialog, 'PALLET-3')
     expect(vi.mocked(api.lockDispatchDraftPallet).mock.calls[2]![0].draftContainerId).toBe('container-1')
     expect(car(dialog, 1).text()).toContain('PALLET-3'); expect(car(dialog, 2).text()).toContain('PALLET-2')
     await chooseCar(dialog, 2)
     expect(dialog.findComponent(DispatchResourceFields).exists()).toBe(false)
-    expect((field(dialog, '备注').get('input').element as HTMLInputElement).value).toBe('第二车独立备注')
+    expect(view(dialog).get('.dispatch-candidate-query input[type="checkbox"]').element).toHaveProperty('checked', true)
   })
   it('selects the newly added ID even when its response lists the new container first and old container last', async () => {
     const dialog = await render(); await warehouseSelected(dialog); await join(dialog, 'PALLET-1')
@@ -183,24 +182,20 @@ describe('three-column cargo planning through visible controls', () => {
     expect(view(dialog).text()).not.toContain('原请求结果尚待核对')
     expect(sessionStorage.getItem(`dispatch-draft-command:${identity.id}`)).toBeNull()
   })
-  it.each(['CREATE', 'CONTAINER'] as const)('stops after an unknown %s and retries its exact command without auto-locking or recreating', async step => {
-    lostReply = step
-    const dialog = await render(); await warehouseSelected(dialog); await join(dialog, 'PALLET-1')
+  it.each(['CREATE','CONTAINER'] as const)('unlocks after a failed %s and permits a new cargo click',async step=>{
+    lostReply=step
+    const dialog=await render();await warehouseSelected(dialog);await join(dialog,'PALLET-1')
     expect(api.lockDispatchDraftPallet).not.toHaveBeenCalled()
-    const before = step === 'CREATE' ? clone(vi.mocked(api.createDispatchDraft).mock.calls[0]![0]) : clone(vi.mocked(api.createDispatchDraftContainer).mock.calls[0]![0])
-    await button(dialog, '重试原请求').trigger('click'); await flushPromises()
-    if (step === 'CREATE') {
-      expect(api.createDispatchDraft).toHaveBeenNthCalledWith(2, before)
-      expect(api.createDispatchDraftContainer).not.toHaveBeenCalled()
-    } else {
-      expect(api.createDispatchDraftContainer).toHaveBeenNthCalledWith(2, before)
-      expect(api.createDispatchDraft).toHaveBeenCalledTimes(1)
+    expect(view(dialog).text()).not.toContain('原请求结果尚待核对')
+    expect(sessionStorage.getItem('dispatch-draft-command:'+identity.id)).toBeNull()
+    await join(dialog,'PALLET-1')
+    expect(api.lockDispatchDraftPallet).toHaveBeenCalledOnce()
+    if(step==='CREATE'){
+      const calls=vi.mocked(api.createDispatchDraft).mock.calls
+      expect(calls).toHaveLength(2);expect(calls[1]![0].idempotencyKey).not.toBe(calls[0]![0].idempotencyKey)
+    }else{
+      expect(api.createDispatchDraftContainer).toHaveBeenCalledOnce();expect(api.createDispatchDraft).toHaveBeenCalledOnce()
     }
-    expect(api.lockDispatchDraftPallet).not.toHaveBeenCalled()
-    await join(dialog, 'PALLET-1')
-    expect(api.createDispatchDraft).toHaveBeenCalledTimes(step === 'CREATE' ? 2 : 1)
-    expect(api.createDispatchDraftContainer).toHaveBeenCalledTimes(step === 'CONTAINER' ? 2 : 1)
-    expect(api.lockDispatchDraftPallet).toHaveBeenCalledTimes(1)
   })
   it('keeps the preparation chain frozen while CREATE is in flight', async () => {
     let resolve!: (value: DispatchDraft) => void

src/modules/overseas-warehouse/components/SmartDispatchDialog.test.ts

@@ -7,7 +7,6 @@ import { listAllPlatformWarehouses } from '@/modules/warehouses'
 import * as api from '../api/dispatches'
 import { candidate, command, detail, sharedPalletCandidates } from '../dispatchTestFixtures'
 import type { ConvertDraft, DispatchDraft, Version } from '../dispatchContracts'
-import { useDispatchCommandRecovery } from '../dispatchCommandRecovery'
 const identity = vi.hoisted(() => ({ id: 'smart-operator' }))
 const push = vi.hoisted(() => vi.fn())
 vi.mock('@/core/auth/auth', () => ({ useAuthStore: () => ({ user: identity }) }))
@@ -33,15 +32,13 @@ it('switches to existing cargo inside the same dialog without creating a draft o
   expect(wrapper.emitted('update:modelValue')).toBeUndefined()
   wrapper.unmount()
 })
-it.each(['ADD_CARGO', 'REMOVE_CARGO'] as const)('opens %s recovery in existing cargo without reading creation drafts', async action => {
-  const recovery = useDispatchCommandRecovery(() => identity.id)
-  recovery.begin('PC/1', action, { recordVersion: 0, idempotencyKey: 'existing-key' })
-  const wrapper = mount(SmartDispatchDialog, options); await flushPromises()
-  expect(wrapper.findComponent({ name: 'SmartDispatchExistingCargo' }).exists()).toBe(true)
-  expect(api.listDispatchDrafts).not.toHaveBeenCalled()
-  expect(listAllPlatformWarehouses).not.toHaveBeenCalled()
-  expect(recovery.pending.value?.body.idempotencyKey).toBe('existing-key')
-  wrapper.unmount()
+it.each(['ADD_CARGO','REMOVE_CARGO'] as const)('ignores old %s browser requests and opens a fresh workspace',async action=>{
+  sessionStorage.setItem('dispatch-command:'+identity.id,JSON.stringify({dispatchNo:'PC/1',action,attempted:true,body:{idempotencyKey:'old'}}))
+  const wrapper=mount(SmartDispatchDialog,options);await flushPromises()
+  expect(wrapper.findComponent({name:'SmartDispatchExistingCargo'}).exists()).toBe(false)
+  expect(api.listDispatchDrafts).toHaveBeenCalledOnce()
+  expect(sessionStorage.getItem('dispatch-command:'+identity.id)).toBeNull()
+  expect(wrapper.text()).not.toContain('原请求结果尚待核对');wrapper.unmount()
 })
 it('converts a filtered relabel group with both authoritative sources and locks it through one HTTP command', async () => {
   const [first, second] = sharedPalletCandidates(), original = draft()
@@ -68,7 +65,7 @@ it('allows one atomic removal of a restored group that is no longer selectable',
 })
 const options = { props: { modelValue: true, orders: [] }, global: { plugins: [ElementPlus] } }
 beforeEach(() => { vi.clearAllMocks(); sessionStorage.clear(); identity.id = crypto.randomUUID(); vi.stubGlobal('ResizeObserver', class { observe() {} unobserve() {} disconnect() {} }); vi.mocked(listAllPlatformWarehouses).mockResolvedValue([{ id: '321', warehouseName: '洛杉矶仓' }] as Awaited<ReturnType<typeof listAllPlatformWarehouses>>); vi.mocked(api.listDispatchDrafts).mockResolvedValue([draft()]); vi.mocked(api.listDispatchCandidates).mockResolvedValue({ total: 1, page: 1, size: 20, pages: 1, candidates: [source()], complete: true, snapshotAt: '2026-10-19T00:00:00Z' }); vi.mocked(api.getDispatch).mockResolvedValue(detail({ recordVersion: 1 })) })
-it.each([0, '0', '9007199254740993'])('transmits original authoritative batch version %s in complete draft conversion and exact retries', async recordVersion => {
+it.each([0, '0', '9007199254740993'])('transmits original authoritative batch version %s in conversion and refreshes the batch version on a new click', async recordVersion => {
   const original = draft()
   original.sources[0]!.appointmentBatches = [{ batchKey: 'FBA_APPOINTMENT:1', batchNo: 'AP-1', customerId: 'C1', recordVersion, sources: [{ sourceKey: 'ORDER:1', destinationKey: 'FBA:ONT8', packageCount: 2 }] }]
   vi.mocked(api.listDispatchDrafts).mockResolvedValue([original])
@@ -80,7 +77,10 @@ it.each([0, '0', '9007199254740993'])('transmits original authoritative batch ve
     const request = JSON.parse(JSON.stringify(vi.mocked(api.convertDispatchDraft).mock.calls[0]![0])) as ConvertDraft
     expect(request.groups[0]!.dispatch.batchAllocations).toEqual([{ planPalletId: '11', batchKey: 'FBA_APPOINTMENT:1', customerId: 'C1', sourceKey: 'ORDER:1', destinationKey: 'FBA:ONT8', packageCount: 2, recordVersion }])
     original.sources[0]!.appointmentBatches[0]!.recordVersion = '9007199254740994'
-    await state.submit(); expect(api.convertDispatchDraft).toHaveBeenNthCalledWith(2, request)
+    await state.submit()
+    const next=vi.mocked(api.convertDispatchDraft).mock.calls[1]![0]
+    expect(next.idempotencyKey).not.toBe(request.idempotencyKey)
+    expect(next.groups[0]!.dispatch.batchAllocations[0]!.recordVersion).toBe('9007199254740994')
   } finally { wrapper.unmount() }
 })
 it.each([undefined, null, 'bad', 9007199254740992])('requires rereading a restored candidate with missing or invalid batch version %s', async recordVersion => {
@@ -113,11 +113,11 @@ it('restores an explicit draft and submits complete server source versions in ea
   expect(api.convertDispatchDraft).toHaveBeenCalledWith(expect.objectContaining({ recordVersion: 0, draftToken: 'server-token', groups: [expect.objectContaining({ draftContainerId: '100000000000000001', dispatch: expect.objectContaining({ cargo: [source().selection, original.sources[1]!.selection] }) })] }))
   expect(wrapper.emitted('created')).toHaveLength(1); wrapper.unmount()
 })
-it('retains conversion payload and key after an unknown result instead of rebuilding from fresh versions', async () => {
+it('releases an unknown conversion and starts a fresh request on the next click', async () => {
   vi.mocked(api.convertDispatchDraft).mockRejectedValueOnce(new Error('network unknown')).mockImplementationOnce(async request => ({ draftToken: request.draftToken, replayed: true, vehicles: request.groups.map(group => ({ draftContainerId: group.draftContainerId, dispatch: command('CREATE', group.dispatch.idempotencyKey) })) }))
   const wrapper = mount(SmartDispatchDialog, options); await flushPromises(); const state = wrapper.vm as unknown as { restoreDraft: (token: string) => void; submit: () => Promise<void> }
   state.restoreDraft('server-token'); await flushPromises(); await state.submit(); await state.submit()
-  expect(api.convertDispatchDraft).toHaveBeenCalledTimes(2); expect(vi.mocked(api.convertDispatchDraft).mock.calls[1]![0]).toEqual(vi.mocked(api.convertDispatchDraft).mock.calls[0]![0]); wrapper.unmount()
+  expect(api.convertDispatchDraft).toHaveBeenCalledTimes(2); expect(vi.mocked(api.convertDispatchDraft).mock.calls[1]![0].idempotencyKey).not.toBe(vi.mocked(api.convertDispatchDraft).mock.calls[0]![0].idempotencyKey); wrapper.unmount()
 })
 it('does not discard draft selections when recovery fails and never submits an incomplete source list', async () => {
   vi.mocked(api.listDispatchDrafts).mockRejectedValue(new Error('draft unavailable'))
@@ -127,26 +127,28 @@ it('accepts a partial candidate page without requiring the filtered whole set',
   vi.mocked(api.listDispatchCandidates).mockResolvedValue({ total: 21, page: 1, size: 20, pages: 2, candidates: [source()], complete: false, snapshotAt: '' })
   const wrapper = mount(SmartDispatchDialog, options); await flushPromises(); const state = wrapper.vm as unknown as { restoreDraft: (token: string) => void }; state.restoreDraft('server-token'); await flushPromises(); expect(wrapper.getComponent({ name: 'ElDialogContent' }).text()).not.toContain('尚未完整返回'); wrapper.unmount()
 })
-it('keeps planning remarks independent with unassigned resources and reuses a proven conversion after a detail read fails', async () => {
+it('keeps planning remarks independent with unassigned resources and permits resubmission after a failed detail read', async () => {
   const original = draft(); original.containers.push({ draftContainerId: 'container-B', sequenceNo: 2, capacity: 15, sourceKeys: ['source-B'] }); original.sources.push(candidate({ sourceKey: 'source-B', customerId: 'B' }))
   vi.mocked(api.listDispatchDrafts).mockResolvedValue([original])
   vi.mocked(api.convertDispatchDraft).mockImplementation(async request => ({ draftToken: request.draftToken, replayed: false, vehicles: request.groups.map((group, index) => ({ draftContainerId: group.draftContainerId, dispatch: command('CREATE', group.dispatch.idempotencyKey, `PC/${index + 1}`) })) }))
   vi.mocked(api.getDispatch).mockRejectedValueOnce(new Error('detail unavailable')).mockImplementation(async no => detail({ dispatchNo: no, recordVersion: 1 }))
   const wrapper = mount(SmartDispatchDialog, options); await flushPromises()
-  const state = wrapper.vm as unknown as { restoreDraft(token: string): void; submit(): Promise<void>; activeContainerId: string; form: { remark: string } }
-  state.restoreDraft('server-token'); await flushPromises(); state.form.remark = '车甲'
-  state.activeContainerId = 'container-B'; state.form.remark = '车乙'
+  const state = wrapper.vm as unknown as { restoreDraft(token: string): void; submit(): Promise<void> }
+  state.restoreDraft('server-token'); await flushPromises()
   await state.submit(); expect(wrapper.emitted('created')).toBeUndefined()
-  await state.submit(); expect(api.convertDispatchDraft).toHaveBeenCalledTimes(1)
+  await state.submit(); expect(api.convertDispatchDraft).toHaveBeenCalledTimes(2)
   const groups = vi.mocked(api.convertDispatchDraft).mock.calls[0]![0].groups
-  expect(groups.map(group => [group.dispatch.vehicle, group.dispatch.driver, group.dispatch.remark])).toEqual([[null, null, '车甲'], [null, null, '车乙']])
+  expect(groups.map(group => [group.dispatch.vehicle, group.dispatch.driver, group.dispatch.remark])).toEqual([[null, null, null], [null, null, null]])
   expect(wrapper.emitted('created')).toHaveLength(1); wrapper.unmount()
 })
-it('never sends an existing departure command through the empty creation transport', async () => {
-  useDispatchCommandRecovery(() => identity.id).begin('PC/1', 'DEPART', { recordVersion: 0, idempotencyKey: 'original-key' })
-  const wrapper = mount(SmartDispatchDialog, options); await flushPromises()
-  await (wrapper.vm as unknown as { submit(): Promise<void> }).submit()
-  expect(api.createDispatch).not.toHaveBeenCalled(); expect(api.convertDispatchDraft).not.toHaveBeenCalled(); expect(wrapper.getComponent({ name: 'ElDialogContent' }).text()).toContain('从列表的原请求恢复入口'); wrapper.unmount()
+it('clears an old departure request without blocking new empty creation',async()=>{
+  sessionStorage.setItem('dispatch-command:'+identity.id,JSON.stringify({dispatchNo:'PC/1',action:'DEPART',attempted:true,body:{idempotencyKey:'old'}}))
+  vi.mocked(api.createDispatch).mockImplementation(async body=>command('CREATE',body.idempotencyKey))
+  const wrapper=mount(SmartDispatchDialog,options);await flushPromises()
+  const state=wrapper.vm as unknown as {mode:string;submit():Promise<void>}
+  state.mode='empty';await flushPromises();await state.submit()
+  expect(api.createDispatch).toHaveBeenCalledOnce()
+  expect(sessionStorage.getItem('dispatch-command:'+identity.id)).toBeNull();wrapper.unmount()
 })
 it('rejects a restored source whose batch customer differs from its real cargo owner', async () => {
   const original = draft(); original.sources[0]!.appointmentBatches = [{ batchKey: 'batch-1', batchNo: 'BATCH-1', recordVersion: 0, customerId: 'other-customer', sources: [{ sourceKey: 'source-1', destinationKey: 'CODE:ONT8', packageCount: 2 }] }]
@@ -175,14 +177,14 @@ it('keeps server draft cargo across pages, resets filters and sends regional tab
   } finally { wrapper.unmount() }
 })
 
-it('defaults publication on for every new dispatch and carries opt-out in the atomic draft conversion', async () => {
+it.each([false, true])('defaults publication off and carries publication %s in the atomic draft conversion', async publish => {
   vi.mocked(api.convertDispatchDraft).mockImplementation(async request => ({ draftToken: request.draftToken, replayed: false, vehicles: request.groups.map(group => ({ draftContainerId: group.draftContainerId, dispatch: command('CREATE', group.dispatch.idempotencyKey) })) }))
   const wrapper = mount(SmartDispatchDialog, options); await flushPromises()
-  const state = wrapper.vm as unknown as { restoreDraft(token: string): void; submit(): Promise<void>; form: { publishLooseboardDemand: boolean } }
+  const state = wrapper.vm as unknown as { restoreDraft(token: string): void; submit(): Promise<void>; publishLooseboardDemand: boolean }
   state.restoreDraft('server-token'); await flushPromises()
-  expect(state.form.publishLooseboardDemand).toBe(true)
-  state.form.publishLooseboardDemand = false
+  expect(state.publishLooseboardDemand).toBe(false)
+  state.publishLooseboardDemand = publish
   await state.submit()
-  expect(api.convertDispatchDraft).toHaveBeenCalledWith(expect.objectContaining({ groups: [expect.objectContaining({ dispatch: expect.objectContaining({ publishLooseboardDemand: false }) })] }))
+  expect(api.convertDispatchDraft).toHaveBeenCalledWith(expect.objectContaining({ groups: [expect.objectContaining({ dispatch: expect.objectContaining({ publishLooseboardDemand: publish }) })] }))
   wrapper.unmount()
 })

src/modules/overseas-warehouse/components/SmartDispatchDialog.vue

@@ -17,7 +17,7 @@ import { useDispatchCandidates } from '../useDispatchCandidates'
 import type { Candidate, ConvertedDraft, ConvertDraft, CreateDispatch, DispatchDraft, DraftSelection, VersionCommand } from '../dispatchContracts'
 import { DispatchInputError, requireVersion, requireBatchVersions, requireSelectionGroup, expandSelectionGroups } from '../dispatchContracts'
 import { dispatchActionPermissions } from '../dispatchPresentation'
-import { useDispatchCommandRecovery, validateCurrentDispatch, isDefiniteDispatchRejection } from '../dispatchCommandRecovery'
+import { useDispatchCommandRecovery, validateCurrentDispatch } from '../dispatchCommandRecovery'
 import type { InboundOrderListItem } from '../types'
 import SmartDispatchCargoBoard from './SmartDispatchCargoBoard.vue'
 import SmartDispatchExistingCargo from './SmartDispatchExistingCargo.vue'
@@ -28,12 +28,9 @@ const emit = defineEmits<{ 'update:modelValue': [value: boolean]; created: [] }>
 const router = useRouter(), auth = useAuthStore(), access = useAccessPreviewStore()
 const recovery = useDispatchCommandRecovery(() => auth.user?.id || '')
 const owner = auth.user?.id || '', storageKey = `dispatch-draft-command:${owner}`
-type DraftCommand = { action: 'CREATE' | 'CONTAINER' | 'LOCK' | 'UNLOCK' | 'DELETE' | 'RELEASE' | 'CONVERT'; body: Record<string, unknown>; containerId?: string; priorContainerIds?: string[]; attempted: boolean; rejected: boolean; result?: ConvertedDraft }
+type DraftCommand = { action: 'CREATE' | 'CONTAINER' | 'LOCK' | 'UNLOCK' | 'DELETE' | 'RELEASE' | 'CONVERT'; body: Record<string, unknown>; containerId?: string; priorContainerIds?: string[] }
 const pending = ref<DraftCommand | null>(null)
-if (owner && sessionStorage.getItem(storageKey)) pending.value = JSON.parse(sessionStorage.getItem(storageKey)!) as DraftCommand
-// Only a recorded first-attempt rejection proves that no write occurred.
-let rejectedDraftToken = pending.value?.rejected && !pending.value.result ? String(pending.value.body.draftToken || '') : ''
-if (pending.value?.rejected && !pending.value.result) { pending.value = null; sessionStorage.removeItem(storageKey) }
+if (owner) sessionStorage.removeItem(storageKey)
 const workspace = ref<'create' | 'existing'>('create'), existingBusy = ref(false)
 const settingsExpanded = ref(false)
 const mode = ref<'cargo' | 'empty'>('cargo'), warehouseId = ref(''), warehouses = ref<PlatformWarehouseResource[]>([])
@@ -44,18 +41,11 @@ const { candidates, page, size, total } = candidatePage
 const loading = computed(() => working.value || candidatePage.loading.value)
 const query = reactive({ orderNo: '', destinationWarehouseCode: '', sourceStage: '' })
 const warehouseTab = ref<SmartDispatchWarehouseTab>('ALL')
-const settings = reactive<Record<string, { form: { plannedDepartureAt: string; estimatedArrivalAt: string; remark: string; publishLooseboardDemand: boolean } }>>({})
-const currentSettings = computed(() => {
-  const key = mode.value === 'empty' ? 'empty' : activeContainerId.value || 'unselected'
-  settings[key] ||= { form: { plannedDepartureAt: '', estimatedArrivalAt: '', remark: '', publishLooseboardDemand: true } }
-  return settings[key]!
-})
-const form = computed(() => currentSettings.value.form)
-const frozen = computed(() => !canCreate.value || preparing.value || saving.value || Boolean(pending.value) || Boolean(recovery.pending.value))
-const needsRecovery = computed(() => Boolean(pending.value || recovery.pending.value) && !saving.value && !preparing.value && !recovery.busy.value)
+const publishLooseboardDemand = ref(false)
+const frozen = computed(() => !canCreate.value || preparing.value || saving.value || recovery.busy.value)
 const canCreate = computed(() => access.can(dispatchActionPermissions.CREATE))
 const canEditCargo = computed(() => access.can(dispatchActionPermissions.ADD_CARGO))
-const workspaceFrozen = computed(() => loading.value || preparing.value || saving.value || existingBusy.value || Boolean(pending.value) || Boolean(recovery.pending.value))
+const workspaceFrozen = computed(() => loading.value || preparing.value || saving.value || existingBusy.value || recovery.busy.value)
 const planIds = computed(() => [...new Set(props.orders.map(row => row.planId).filter(Boolean))])
 const currentContainer = computed(() => draft.value?.containers.find(row => row.draftContainerId === activeContainerId.value))
 const populatedGroupCount = computed(() => draft.value?.containers.filter(row => row.sourceKeys.length).length || 0)
@@ -113,25 +103,17 @@ function changeSize(value: number) { size.value = value; void search() }
 
 let generation = 0
 let candidateFilterKey = ''
-function persist() {
-  if (!owner || owner !== auth.user?.id) throw new DispatchInputError('登录身份已变化，请重新进入排车列表')
-  if (pending.value) sessionStorage.setItem(storageKey, JSON.stringify(pending.value)); else sessionStorage.removeItem(storageKey)
-}
 async function init() {
   const sequence = ++generation
   working.value = true; error.value = null
   try {
-    if (recovery.pending.value && ['ADD_CARGO', 'REMOVE_CARGO'].includes(recovery.pending.value.action)) workspace.value = 'existing'
-    else if (pending.value || recovery.pending.value?.action === 'CREATE') workspace.value = 'create'
-    else if (!canCreate.value && canEditCargo.value) workspace.value = 'existing'
+    if (!canCreate.value && canEditCargo.value) workspace.value = 'existing'
     if (workspace.value === 'existing' || !canCreate.value) return
-    if (recovery.pending.value?.action === 'CREATE') { mode.value = 'empty'; warehouseId.value = String(recovery.pending.value.body.warehouseId || '') }
     const [directory, saved] = await Promise.all([listAllPlatformWarehouses({ warehouseType: 'OVERSEAS', status: 'ACTIVE' }), api.listDispatchDrafts()])
     if (sequence !== generation) return
     warehouses.value = directory; drafts.value = saved
-    const resumeToken = pending.value?.body.draftToken || rejectedDraftToken
+    const resumeToken = draft.value?.draftToken
     if (resumeToken) draft.value = saved.find(row => row.draftToken === resumeToken) || null
-    rejectedDraftToken = ''
     if (draft.value) warehouseId.value = draft.value.warehouseId
     if (!warehouseId.value) {
       const selectedWarehouses = new Set(props.orders.map(row => row.originWarehouseId).filter(Boolean))
@@ -159,12 +141,11 @@ async function loadCandidates(sequence = generation) {
 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; warehouseTab.value = 'ALL'; activeContainerId.value = value.containers[0]?.draftContainerId || ''; void search() }
-function creation(cargo: Candidate[], containerId?: string): CreateDispatch {
+function creation(cargo: Candidate[]): CreateDispatch {
   candidatePage.assertCurrent(cargo)
   requireBatchVersions(cargo.flatMap(row => row.appointmentBatches))
   if (cargo.some(row => row.warehouseId !== warehouseId.value || !row.sourceVersion || row.sourceVersion !== row.selection.sourceVersion || row.appointmentBatches.some(batch => batch.customerId !== row.customerId))) throw new DispatchInputError('货物仓库、来源版本或预约客户不一致，请重新读取')
-  const config = containerId ? settings[containerId] : currentSettings.value
-  return { publishLooseboardDemand: config?.form.publishLooseboardDemand ?? true, idempotencyKey: crypto.randomUUID(), warehouseId: warehouseId.value, vehicle: null, driver: null, plannedDepartureAt: config?.form.plannedDepartureAt || null, estimatedArrivalAt: config?.form.estimatedArrivalAt || null, remark: config?.form.remark || null, cargo: expandSelectionGroups(cargo), batchAllocations: cargo.flatMap(row => row.appointmentBatches.flatMap(batch => batch.sources.map(source => { if (!row.selection.planPalletId) throw new DispatchInputError('批次分配缺少真实计划来源，请核对'); return { planPalletId: row.selection.planPalletId, batchKey: batch.batchKey, customerId: batch.customerId, ...source, recordVersion: batch.recordVersion } }))) }
+  return { publishLooseboardDemand: publishLooseboardDemand.value, idempotencyKey: crypto.randomUUID(), warehouseId: warehouseId.value, vehicle: null, driver: null, plannedDepartureAt: null, estimatedArrivalAt: null, remark: null, cargo: expandSelectionGroups(cargo), batchAllocations: cargo.flatMap(row => row.appointmentBatches.flatMap(batch => batch.sources.map(source => { if (!row.selection.planPalletId) throw new DispatchInputError('批次分配缺少真实计划来源，请核对'); return { planPalletId: row.selection.planPalletId, batchKey: batch.batchKey, customerId: batch.customerId, ...source, recordVersion: batch.recordVersion } }))) }
 }
 async function draftAction(action: DraftCommand['action'], source?: Candidate, containerId?: string): Promise<boolean> {
   if (!canCreate.value || loading.value || saving.value || pending.value) return false
@@ -190,22 +171,23 @@ async function draftAction(action: DraftCommand['action'], source?: Candidate, c
           const groups = current.containers.filter(row => row.sourceKeys.length).map(row => {
             const cargo = row.sourceKeys.map(keyValue => current.sources.find(value => value.sourceKey === keyValue))
             if (cargo.some(rowValue => !rowValue)) throw new DispatchInputError('草稿来源尚未恢复完整，请重新读取')
-            return { draftContainerId: row.draftContainerId, dispatch: creation(cargo as Candidate[], row.draftContainerId) }
+            return { draftContainerId: row.draftContainerId, dispatch: creation(cargo as Candidate[]) }
           })
           if (!groups.length) throw new DispatchInputError('请至少选择一组真实货物；空单请使用先建空单')
           body = { ...common, groups } satisfies ConvertDraft
         }
       }
-      pending.value = { action, body: JSON.parse(JSON.stringify(body)) as Record<string, unknown>, containerId, ...(action === 'CONTAINER' ? { priorContainerIds: current!.containers.map(row => row.draftContainerId) } : {}), attempted: false, rejected: false }; persist()
+      if (!owner || owner !== auth.user?.id) throw new DispatchInputError('登录身份已变化，请重新进入排车列表')
+      pending.value = { action, body: JSON.parse(JSON.stringify(body)) as Record<string, unknown>, containerId, ...(action === 'CONTAINER' ? { priorContainerIds: current!.containers.map(row => row.draftContainerId) } : {}) }
     }
     await retryDraft()
     return true
-  } catch (cause) { error.value = getApiErrorDetails(cause, cause instanceof DispatchInputError ? cause.message : '草稿操作结果未确认，原请求已保留'); return false }
+  } catch (cause) { error.value = getApiErrorDetails(cause, cause instanceof DispatchInputError ? cause.message : '本次排车操作失败，请重试'); return false }
 }
 async function retryDraft() {
   if (!pending.value || saving.value) return
-  const command = pending.value, previousAttempt = command.attempted
-  saving.value = true; command.attempted = true; persist()
+  const command = pending.value
+  saving.value = true
   try {
     const body = command.body
     let result: DispatchDraft | ConvertedDraft
@@ -216,52 +198,55 @@ async function retryDraft() {
       case 'UNLOCK': result = await api.unlockDispatchDraftPallet(body as unknown as DraftSelection); break
       case 'RELEASE': result = await api.releaseDispatchDraft(body as unknown as VersionCommand & { draftToken: string }); break
       case 'DELETE': result = await api.deleteDispatchDraftContainer(String(body.draftToken), command.containerId!, body as unknown as VersionCommand & { reason: string }); break
-      case 'CONVERT': result = command.result || await api.convertDispatchDraft(body as unknown as ConvertDraft); break
+      case 'CONVERT': result = await api.convertDispatchDraft(body as unknown as ConvertDraft); break
     }
     if (body.draftToken && result.draftToken !== body.draftToken) throw new DispatchInputError('草稿结果与原请求不一致')
     if (command.action === 'CONVERT') {
       const converted = result as ConvertedDraft, expected = (body as unknown as ConvertDraft).groups
-      if (converted.vehicles.length !== expected.length || new Set(converted.vehicles.map(row => row.dispatch.dispatchNo)).size !== expected.length || expected.some(group => !converted.vehicles.some(row => row.draftContainerId === group.draftContainerId && row.dispatch.action === 'CREATE' && row.dispatch.idempotencyKey === group.dispatch.idempotencyKey && Boolean(row.dispatch.dispatchNo)))) throw new DispatchInputError('整车转换结果与原草稿容器不一致，请核对原请求')
-      command.result = converted; persist()
+      if (converted.vehicles.length !== expected.length || new Set(converted.vehicles.map(row => row.dispatch.dispatchNo)).size !== expected.length || expected.some(group => !converted.vehicles.some(row => row.draftContainerId === group.draftContainerId && row.dispatch.action === 'CREATE' && row.dispatch.idempotencyKey === group.dispatch.idempotencyKey && Boolean(row.dispatch.dispatchNo)))) throw new DispatchInputError('整车转换结果与本次草稿容器不一致，请刷新当前排车')
       await Promise.all(converted.vehicles.map(async row => validateCurrentDispatch(await api.getDispatch(row.dispatch.dispatchNo), row.dispatch)))
-      pending.value = null; persist(); emit('created'); emit('update:modelValue', false); draft.value = null; ElMessage.success('整车排车单已创建'); await router.push({ name: 'overseas-dispatches' }); return
+      emit('created'); emit('update:modelValue', false); draft.value = null; ElMessage.success('整车排车单已创建'); await router.push({ name: 'overseas-dispatches' }); return
     }
     requireVersion((result as DispatchDraft).recordVersion)
     let addedContainerId: string | undefined
     if (command.action === 'CONTAINER') {
       const updated = result as DispatchDraft, previous = command.priorContainerIds
       const added = previous && updated.containers.filter(row => !previous.includes(row.draftContainerId))
-      if (!previous || !added || added.length !== 1 || added[0]!.capacity !== body.capacity || updated.containers.length !== previous.length + 1 || previous.some(id => !updated.containers.some(row => row.draftContainerId === id))) throw new DispatchInputError('新增车辆结果尚未核对，请保留原请求重试')
+      if (!previous || !added || added.length !== 1 || added[0]!.capacity !== body.capacity || updated.containers.length !== previous.length + 1 || previous.some(id => !updated.containers.some(row => row.draftContainerId === id))) throw new DispatchInputError('新增车辆结果异常，请刷新后重试')
       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()
     if (command.action !== 'CREATE' && command.action !== 'CONTAINER') await loadCandidates()
-  } catch (cause) { // A later rejection cannot erase an earlier unknown write result.
-    if (!previousAttempt && !command.result && isDefiniteDispatchRejection(cause)) pending.value = null
-    persist(); throw cause }
-  finally { saving.value = false }
+  } catch (cause) {
+    // 请求失败后读取服务器最新草稿，保留本地时间和备注，后续点击按当前版本重新提交。
+    if (command.body.draftToken) {
+      try {
+        const saved = await api.listDispatchDrafts()
+        drafts.value = saved; draft.value = saved.find(row => row.draftToken === command.body.draftToken) || null
+        activeContainerId.value = draft.value?.containers.find(row => row.draftContainerId === activeContainerId.value)?.draftContainerId || draft.value?.containers[0]?.draftContainerId || ''
+      } catch { /* 刷新失败只保留原错误，不锁住其他操作。 */ }
+    }
+    throw cause
+  } finally { pending.value = null; saving.value = false }
 }
 async function submit() {
   if (workspace.value === 'existing') return
   if (!canCreate.value || preparing.value || saving.value || loading.value) return
   error.value = null
   try {
-    if (pending.value) { await retryDraft(); return }
-    if (recovery.pending.value && recovery.pending.value.action !== 'CREATE') throw new DispatchInputError('另一次排车操作尚待核对，请从列表的原请求恢复入口继续')
-    if (!recovery.pending.value && mode.value === 'cargo') { await draftAction('CONVERT'); return }
-    if (!recovery.pending.value) { if (!warehouseId.value) throw new DispatchInputError('请选择真实起运仓'); recovery.begin('', 'CREATE', creation([])) }
-    const result = await recovery.execute(command => api.createDispatch(command.body as unknown as CreateDispatch), api.getDispatch, api.getDispatchCommand)
+    if (mode.value === 'cargo') { await draftAction('CONVERT'); return }
+    if (!warehouseId.value) throw new DispatchInputError('请选择真实起运仓')
+    recovery.begin('', 'CREATE', creation([]))
+    const result = await recovery.execute(command => api.createDispatch(command.body as unknown as CreateDispatch), api.getDispatch)
     if (result) { emit('created'); emit('update:modelValue', false); ElMessage.success(`空排车单 ${result.dispatchNo} 已创建`) }
-  } catch (cause) { error.value = getApiErrorDetails(cause, cause instanceof DispatchInputError ? cause.message : '建单结果尚未核对，请使用原请求重试') }
+  } catch (cause) { error.value = getApiErrorDetails(cause, cause instanceof DispatchInputError ? cause.message : '建单失败，请重试') }
 }
-watch(() => props.modelValue, value => { if (value) void init(); else { generation++; candidatePage.reset() } }, { immediate: true })
+watch(() => props.modelValue, value => { if (value) { publishLooseboardDemand.value = false; void init() } else { generation++; candidatePage.reset() } }, { immediate: true })
 </script>
 <template>
-  <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">
+  <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="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>
@@ -269,11 +254,10 @@ watch(() => props.modelValue, value => { if (value) void init(); else { generati
     <SmartDispatchExistingCargo v-if="workspace === 'existing' && modelValue" @saved="emit('created')" @busy="existingBusy = $event" />
     <template v-else-if="workspace === 'create'">
     <div class="density-dialog-sections dispatch-workspace">
-      <LoadErrorState v-if="error" title="排车未完成" :message="error.message" :loading="loading || saving || recovery.busy.value" @retry="pending || recovery.pending.value ? submit() : init()"><template #details><ApiErrorMeta :details="error" /></template></LoadErrorState>
-      <el-alert v-if="needsRecovery" role="status" title="原请求结果尚待核对，请勿更改选择、版本或重新建单。" type="warning" :closable="false" show-icon />
+      <LoadErrorState v-if="error" title="排车未完成" :message="error.message" :loading="loading || saving || recovery.busy.value" @retry="init()"><template #details><ApiErrorMeta :details="error" /></template></LoadErrorState>
         <section class="density-dialog-section dispatch-search" aria-label="候选货物查询">
           <div class="dispatch-candidate-query">
-            <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>
+            <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><el-checkbox v-model="publishLooseboardDemand" :disabled="frozen || loading">发布公共需求</el-checkbox></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">
@@ -298,16 +282,6 @@ watch(() => props.modelValue, value => { if (value) void init(); else { generati
           </template>
         </SmartDispatchCargoBoard>
       </template>
-      <el-form v-if="mode === 'empty' || currentContainer" label-position="left" label-width="130px" class="density-form density-dialog-sections" :disabled="frozen || loading">
-        <section class="density-dialog-section" aria-label="排车计划时间与备注">
-          <h3 class="density-dialog-section__title">{{ mode === 'empty' ? '计划时间与备注' : '第 ' + currentContainer!.sequenceNo + ' 辆车 · 计划时间与备注' }}<small>选填</small><InlineHelp title="计划时间与备注说明"><p>时间和备注分别保存在当前选中的排车安排中。车辆和司机在生成排车单后，通过“维护车辆”补充。</p></InlineHelp></h3>
-          <table class="density-table density-table--editable dispatch-create-table"><tbody>
-            <tr><td><el-form-item label="计划发车时间"><el-date-picker v-model="form.plannedDepartureAt" :disabled="frozen || loading || (mode === 'cargo' && !activeContainerId)" type="datetime" value-format="YYYY-MM-DDTHH:mm:ssZ" placeholder="可先保存，审核前补齐" /></el-form-item></td><td><el-form-item label="预计到达时间"><el-date-picker v-model="form.estimatedArrivalAt" :disabled="frozen || loading || (mode === 'cargo' && !activeContainerId)" type="datetime" value-format="YYYY-MM-DDTHH:mm:ssZ" placeholder="请选择预计到达时间（选填）" /></el-form-item></td></tr>
-            <tr><td colspan="2"><el-form-item label="散板需求"><el-checkbox v-model="form.publishLooseboardDemand" :disabled="frozen || loading || (mode === 'cargo' && !activeContainerId)">发布公共散板需求</el-checkbox></el-form-item></td></tr>
-            <tr><td colspan="2"><el-form-item label="备注"><el-input v-model="form.remark" :disabled="frozen || loading || (mode === 'cargo' && !activeContainerId)" /></el-form-item></td></tr>
-          </tbody></table>
-        </section>
-      </el-form>
     </div>
     </template>
   </AppDialog>
@@ -327,8 +301,6 @@ watch(() => props.modelValue, value => { if (value) void init(); else { generati
 :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); }
 .dispatch-setup-fields { display: flex; flex-wrap: wrap; align-items: center; gap: var(--admin-space-4) var(--admin-space-6); }
 .dispatch-setup-fields :deep(.el-form-item) { margin: 0; }

src/modules/overseas-warehouse/components/SmartDispatchExistingCargo.test.ts

@@ -91,7 +91,7 @@ it.each([0, '0', '9007199254740993'])('preserves precise appointment allocation
   vi.mocked(api.addDispatchCargo).mockRejectedValue(new Error('unknown'))
   const wrapper = await open(); await add(wrapper)
   expect(api.addDispatchCargo).toHaveBeenCalledWith('PC/1', expect.objectContaining({ batchAllocations: [{ planPalletId: '11', batchKey: 'B1', customerId: 'C1', recordVersion, sourceKey: 'S1', destinationKey: 'D1', packageCount: 2 }] }))
-  expect(wrapper.get('button[aria-label^="将托盘 "]').attributes('disabled')).toBeDefined()
+  expect(wrapper.get('button[aria-label^="将托盘 "]').attributes('disabled')).toBeUndefined()
 })
 
 it('requires a removal reason and submits the authoritative item ID and zero version', async () => {
@@ -147,28 +147,23 @@ it.each(['loading', 'permission', 'task-type', 'version', 'read-failure'] as con
   if (scenario === 'version') expect(wrapper.text()).toContain('一致版本')
 })
 
-it('auto-opens the original removal command after remount and checks its result without resending', async () => {
-  const wrapper = await open()
-  await button(wrapper, '移除货物').trigger('click')
-  await wrapper.get('textarea[aria-label="移除原因"]').setValue('原移除原因')
-  vi.mocked(api.removeDispatchItem).mockRejectedValue(new Error('unknown result'))
-  await button(wrapper, '确认移除').trigger('click'); await flushPromises()
-  const original = vi.mocked(api.removeDispatchItem).mock.calls[0]!
-  wrapper.unmount()
-  const resumed = await open(null)
-  expect(resumed.text()).toContain('PC/1')
-  const recovery = useDispatchCommandRecovery(() => identity.id)
-  expect(recovery.pending.value).toMatchObject({ dispatchNo: 'PC/1', itemId: '9007199254740993', body: original[2] })
-  vi.mocked(api.getDispatchCommand).mockImplementation(async (_, key) => command('REMOVE_CARGO', key))
-  vi.mocked(api.getDispatch).mockResolvedValue(current({ recordVersion: 1 }))
-  vi.mocked(api.getDispatchItems).mockResolvedValue(manifest({ recordVersion: 1, items: [] }))
-  await button(resumed, '核对并重试原请求').trigger('click'); await flushPromises()
-  expect(api.removeDispatchItem).toHaveBeenCalledTimes(1)
-  expect(recovery.pending.value).toBeNull()
-  expect(resumed.emitted('saved')).toHaveLength(1)
+it('unlocks a failed removal and accepts an updated reason on a fresh request',async()=>{
+  const wrapper=await open()
+  await button(wrapper,'移除货物').trigger('click');await wrapper.get('textarea[aria-label="移除原因"]').setValue('原移除原因')
+  vi.mocked(api.removeDispatchItem).mockRejectedValueOnce(new Error('unknown result'))
+  await button(wrapper,'确认移除').trigger('click');await flushPromises()
+  expect(useDispatchCommandRecovery(()=>identity.id).pending.value).toBeNull()
+  expect((wrapper.get('textarea[aria-label="移除原因"]').element as HTMLTextAreaElement).value).toBe('原移除原因')
+  await wrapper.get('textarea[aria-label="移除原因"]').setValue('重新安排')
+  vi.mocked(api.removeDispatchItem).mockImplementationOnce(async(_,__,body)=>command('REMOVE_CARGO',body.idempotencyKey))
+  await button(wrapper,'确认移除').trigger('click');await flushPromises()
+  const calls=vi.mocked(api.removeDispatchItem).mock.calls
+  expect(calls).toHaveLength(2);expect(calls[1]![2].reason).toBe('重新安排')
+  expect(calls[1]![2].idempotencyKey).not.toBe(calls[0]![2].idempotencyKey)
+  expect(api.getDispatchCommand).not.toHaveBeenCalled()
 })
 
-it('keeps a confirmed result pending if the subsequent manifest cannot be read', async () => {
+it('unlocks a completed request when its follow-up manifest read fails', async () => {
   const wrapper = await open()
   vi.mocked(api.addDispatchCargo).mockImplementation(async (_, body) => {
     vi.mocked(api.getDispatch).mockResolvedValue(current({ recordVersion: 1 }))
@@ -176,11 +171,11 @@ it('keeps a confirmed result pending if the subsequent manifest cannot be read',
     return command('ADD_CARGO', body.idempotencyKey)
   })
   await add(wrapper)
-  expect(useDispatchCommandRecovery(() => identity.id).pending.value?.result?.action).toBe('ADD_CARGO')
+  expect(useDispatchCommandRecovery(() => identity.id).pending.value).toBeNull()
   vi.mocked(api.getDispatchItems).mockResolvedValue(manifest({ recordVersion: 1 }))
-  await button(wrapper, '刷新当前资料').trigger('click'); await flushPromises()
+  await button(wrapper, '刷新本车').trigger('click'); await flushPromises()
   expect(api.addDispatchCargo).toHaveBeenCalledTimes(1)
-  expect(wrapper.emitted('saved')).toHaveLength(1)
+  expect(api.getDispatchCommand).not.toHaveBeenCalled()
 })
 
 it('does not let a late previous dispatch read overwrite the selected dispatch', async () => {

src/modules/overseas-warehouse/components/SmartDispatchExistingCargo.vue

@@ -31,7 +31,6 @@ const reading = ref(false), listing = ref(false), preparing = ref(false), stale
 const removing = ref<DispatchCargoItem | null>(null), reason = ref('')
 let generation = 0, listGeneration = 0, alive = true
 const cargoPending = computed(() => pending.value?.action === 'ADD_CARGO' || pending.value?.action === 'REMOVE_CARGO')
-const pendingMessage = computed(() => !cargoPending.value ? '另一个排车操作尚待核对，请返回原操作入口处理。' : pending.value?.result ? '货物调整已完成，请刷新当前资料；不会重复提交。' : '原货物调整结果尚待核对，保留原版本和原请求内容。')
 const frozen = computed(() => busy.value || preparing.value || Boolean(pending.value))
 const loading = computed(() => reading.value || candidatePage.loading.value)
 const editable = computed(() => !stale.value && detail.value?.status === 'ACTIVE' && detail.value.stage === 'BEFORE_LOADING' && detail.value.taskType === 'DELIVERY')
@@ -176,7 +175,7 @@ async function execute() {
     const result = await recovery.execute(send, async target => {
       const facts = await readFacts(target)
       return facts.current
-    }, api.getDispatchCommand)
+    })
     if (!result || !alive) return
     ElMessage.success(result.replayed ? '原货物调整结果已核对' : '本车货物已更新，请重新核对审核')
     emit('saved')
@@ -185,7 +184,16 @@ async function execute() {
   } catch (cause) {
     if (!alive) return
     stale.value = true
-    report(cause, pending.value?.result ? '货物已调整，当前资料待刷新' : pending.value ? '操作结果尚未确认，请核对原请求' : '本次货物调整未通过，请刷新当前资料')
+    report(cause, '本次货物调整失败，请刷新当前资料后重试')
+    const failure = error.value
+    try {
+      const facts = await readFacts(no)
+      if (!alive || selectedNo.value !== no) return
+      detail.value = facts.current; items.value = facts.cargo; stale.value = false
+      if (removing.value && !facts.cargo.items.some(row => row.dispatchItemId === removing.value?.dispatchItemId)) removing.value = null
+      await loadCandidates()
+    } catch { /* 读取失败保留原业务错误，仍允许切换排车或手动刷新。 */ }
+    finally { error.value = failure }
   }
 }
 async function retry() { if (cargoPending.value) await execute(); else if (selectedNo.value) await selectDispatch(selectedNo.value); else await loadList() }
@@ -200,8 +208,6 @@ onBeforeUnmount(() => { alive = false; generation++; listGeneration++; candidate
 
 <template>
   <div class="existing-cargo density-dialog-sections">
-    <el-alert v-if="pending" :title="pendingMessage" type="warning" :closable="false" show-icon />
-    <el-button v-if="cargoPending" :loading="busy" @click="execute">{{ pending?.result ? '刷新当前资料' : '核对并重试原请求' }}</el-button>
     <LoadErrorState v-if="error" title="排车货物资料待核对" :message="error.message" :loading="loading || busy" retry-text="重新核对" @retry="retry"><template #details><ApiErrorMeta :details="error" /></template></LoadErrorState>
     <section class="density-dialog-section existing-cargo-search" aria-label="已有排车查询">
     <div class="existing-cargo-query">

src/modules/overseas-warehouse/dispatchCommandRecovery.test.ts

@@ -3,154 +3,65 @@ import { ApiResponseError } from '@/shared/api/http'
 import { useDispatchCommandRecovery } from './dispatchCommandRecovery'
 import { command } from './dispatchTestFixtures'
 beforeEach(() => sessionStorage.clear())
-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: 'LOADING' }), read, vi.fn())).rejects.toThrow('装车完成')
-  expect(read).not.toHaveBeenCalled()
-  expect(recovery.pending.value?.result).toBeNull()
-  expect(recovery.pending.value?.body.idempotencyKey).toBe('key')
+it.each([new Error('network unknown'), new ApiResponseError('server failure','S0500',200), new ApiResponseError('gateway timeout','HTTP_504',504), new ApiResponseError('version changed','A0409',200)])('releases failed $message and permits a new request with edited input', async failure => {
+  const owner=crypto.randomUUID(), state=useDispatchCommandRecovery(()=>owner)
+  state.begin('PC/1','EDIT',{recordVersion:0,idempotencyKey:'first',remark:'original'})
+  await expect(state.execute(vi.fn().mockRejectedValue(failure),vi.fn())).rejects.toBe(failure)
+  expect(state.pending.value).toBeNull();expect(state.busy.value).toBe(false)
+  expect(sessionStorage.getItem(`dispatch-command:${owner}`)).toBeNull()
+  const reopened=useDispatchCommandRecovery(()=>owner)
+  reopened.begin('PC/1','EDIT',{recordVersion:2,idempotencyKey:'second',remark:'edited'})
+  const send=vi.fn().mockResolvedValue({...command('EDIT','second'),recordVersion:3})
+  await reopened.execute(send,vi.fn().mockResolvedValue({dispatchNo:'PC/1',recordVersion:3}))
+  expect(send.mock.calls[0]![0].body).toEqual({recordVersion:2,idempotencyKey:'second',remark:'edited'})
+  expect(reopened.pending.value).toBeNull()
 })
-it('retains the exact original version and body when POST outcome is unknown and a newer detail was read', async () => {
-  const owner = crypto.randomUUID(), recovery = useDispatchCommandRecovery(() => owner)
-  recovery.begin('PC/1', 'LOADING_COMPLETE', { recordVersion: 0, idempotencyKey: 'key', remark: 'original' })
-  const send = vi.fn().mockRejectedValueOnce(new Error('network unknown')).mockResolvedValueOnce(command('LOADING_COMPLETE'))
-  const read = vi.fn().mockResolvedValue({ dispatchNo: 'PC/1', recordVersion: 50 }), find = vi.fn().mockRejectedValue(new ApiResponseError('not found', 'HTTP_404'))
-  await expect(recovery.execute(send, read, find)).rejects.toThrow('network unknown')
-  await recovery.execute(send, read, find)
-  expect(send.mock.calls[1]![0].body).toEqual({ recordVersion: 0, idempotencyKey: 'key', remark: 'original' })
-  expect(recovery.pending.value).toBeNull()
+it.each(['{broken',JSON.stringify({attempted:true,result:null,action:'EDIT'})])('clears saved failed requests without restoring them',saved=>{
+  const owner=crypto.randomUUID()
+  sessionStorage.setItem(`dispatch-command:${owner}`,saved)
+  const state=useDispatchCommandRecovery(()=>owner)
+  expect(state.pending.value).toBeNull();expect(state.busy.value).toBe(false)
+  expect(sessionStorage.getItem(`dispatch-command:${owner}`)).toBeNull()
 })
-it('keeps a proven result across GET failure and does not send the command a second time', 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')), 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('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'))
-  await reopened.execute(send, read, find)
-  expect(send).toHaveBeenCalledTimes(1); expect(find).not.toHaveBeenCalled()
-  expect(reopened.pending.value).toBeNull(); expect(sessionStorage.getItem(`dispatch-command:${owner}`)).toBeNull()
+it('prevents double clicks only during the active request',async()=>{
+  const owner=crypto.randomUUID(),state=useDispatchCommandRecovery(()=>owner)
+  state.begin('PC/1','EDIT',{recordVersion:0,idempotencyKey:'first'})
+  let finish!:(result:ReturnType<typeof command>)=>void
+  const send=vi.fn().mockReturnValue(new Promise(done=>{finish=done}))
+  const read=vi.fn().mockResolvedValue({dispatchNo:'PC/1',recordVersion:1})
+  const running=state.execute(send,read),another=useDispatchCommandRecovery(()=>owner)
+  expect(another.busy.value).toBe(true)
+  expect(()=>another.begin('PC/2','EDIT',{recordVersion:0,idempotencyKey:'second'})).toThrow('正在提交')
+  await another.execute(send,read);expect(send).toHaveBeenCalledTimes(1)
+  finish(command('EDIT','first'));await running
+  expect(another.pending.value).toBeNull();expect(another.busy.value).toBe(false)
+  expect(()=>another.begin('PC/2','EDIT',{recordVersion:0,idempotencyKey:'second'})).not.toThrow()
 })
-it('shares one pending command between empty-create and workflow dialogs and refuses a new command', () => {
-  const owner = crypto.randomUUID(), first = useDispatchCommandRecovery(() => owner), second = useDispatchCommandRecovery(() => owner)
-  first.begin('PC/1', 'EDIT', { recordVersion: 0, idempotencyKey: 'key' })
-  expect(second.pending.value?.dispatchNo).toBe('PC/1')
-  expect(() => second.begin('', 'CREATE', { idempotencyKey: 'new' })).toThrow('原请求')
+it('unlocks even when a successful write is followed by a failed detail read',async()=>{
+  const owner=crypto.randomUUID(),state=useDispatchCommandRecovery(()=>owner)
+  state.begin('PC/1','EDIT',{recordVersion:0,idempotencyKey:'key'})
+  await expect(state.execute(vi.fn().mockResolvedValue(command('EDIT')),vi.fn().mockRejectedValue(new Error('read failed')))).rejects.toThrow('read failed')
+  expect(state.pending.value).toBeNull();expect(state.busy.value).toBe(false)
 })
-it('does not discard an earlier unknown write on a later business rejection', async () => {
-  const recovery = useDispatchCommandRecovery(() => crypto.randomUUID())
-  expect(() => recovery.begin('PC/1', 'EDIT', { recordVersion: 0, idempotencyKey: 'key' })).toThrow('账号')
-  const owner = crypto.randomUUID(), stable = useDispatchCommandRecovery(() => owner)
-  stable.begin('PC/1', 'EDIT', { recordVersion: 0, idempotencyKey: 'key' })
-  const send = vi.fn().mockRejectedValueOnce(new Error('unknown')).mockRejectedValueOnce(new ApiResponseError('version conflict', 'A0409'))
-  const find = vi.fn().mockRejectedValue(new ApiResponseError('not found', 'HTTP_404'))
-  await expect(stable.execute(send, vi.fn(), find)).rejects.toThrow('unknown')
-  await expect(stable.execute(send, vi.fn(), find)).rejects.toThrow('version conflict')
-  stable.discardRejected(); expect(stable.pending.value).not.toBeNull()
-  expect(find).toHaveBeenCalledWith('PC/1', 'key')
-  expect(send.mock.calls[1]![0].body).toEqual({ recordVersion: 0, idempotencyKey: 'key' })
-  expect(stable.pending.value?.rejected).toBe(false)
-  const saved = JSON.parse(sessionStorage.getItem(`dispatch-command:${owner}`)!)
-  expect(saved).toMatchObject({ attempted: true, rejected: false, result: null, body: { recordVersion: 0, idempotencyKey: 'key' } })
-  expect(useDispatchCommandRecovery(() => owner).pending.value).toEqual(saved)
+it('keeps loading-stage and response identity checks without retaining failed requests',async()=>{
+  const owner=crypto.randomUUID(),state=useDispatchCommandRecovery(()=>owner),read=vi.fn()
+  state.begin('PC/1','LOADING_COMPLETE',{recordVersion:0,idempotencyKey:'key'})
+  await expect(state.execute(vi.fn().mockResolvedValue({...command('LOADING_COMPLETE'),stage:'LOADING'}),read)).rejects.toThrow('装车完成')
+  expect(read).not.toHaveBeenCalled();expect(state.pending.value).toBeNull()
+  state.begin('PC/1','EDIT',{recordVersion:0,idempotencyKey:'key'})
+  await expect(state.execute(vi.fn().mockResolvedValue(command('EDIT','different')),read)).rejects.toThrow('不一致')
+  expect(read).not.toHaveBeenCalled();expect(state.pending.value).toBeNull()
 })
-it('rejects a mismatched business number/action/key instead of treating it as successful', 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', 'different')), read, vi.fn())).rejects.toThrow('不一致')
-  expect(read).not.toHaveBeenCalled(); expect(recovery.pending.value).not.toBeNull()
+it('preserves large version precision and unlocks after a mismatched detail',async()=>{
+  const owner=crypto.randomUUID(),state=useDispatchCommandRecovery(()=>owner)
+  state.begin('PC/1','EDIT',{recordVersion:'9007199254740992',idempotencyKey:'key'})
+  await expect(state.execute(vi.fn().mockResolvedValue({...command('EDIT'),recordVersion:'9007199254740993'}),vi.fn().mockResolvedValue({dispatchNo:'PC/1',recordVersion:'9007199254740992'}))).rejects.toThrow('详情版本早于')
+  expect(state.pending.value).toBeNull()
 })
-it('does not release a proven result for an older detail version, including versions beyond safe integer precision', async () => {
-  const owner = crypto.randomUUID(), recovery = useDispatchCommandRecovery(() => owner)
-  recovery.begin('PC/1', 'LOADING_COMPLETE', { recordVersion: '9007199254740992', idempotencyKey: 'key' })
-  const send = vi.fn().mockResolvedValue({ ...command('LOADING_COMPLETE'), recordVersion: '9007199254740993' }), find = vi.fn()
-  await expect(recovery.execute(send, vi.fn().mockResolvedValue({ dispatchNo: 'PC/1', recordVersion: '9007199254740992' }), find)).rejects.toThrow('详情版本早于')
-  expect(recovery.pending.value?.result).not.toBeNull()
-  await recovery.execute(send, vi.fn().mockResolvedValue({ dispatchNo: 'PC/1', recordVersion: '9007199254740994' }), find)
-  expect(send).toHaveBeenCalledTimes(1); expect(recovery.pending.value).toBeNull()
-})
-it('treats an internal server error as unknown instead of authorizing a new command', async () => {
-  const owner = crypto.randomUUID(), recovery = useDispatchCommandRecovery(() => owner)
-  recovery.begin('PC/1', 'EDIT', { recordVersion: 0, idempotencyKey: 'key' })
-  await expect(recovery.execute(vi.fn().mockRejectedValue(new ApiResponseError('server failure', 'A0500', 500)), vi.fn(), vi.fn())).rejects.toThrow('server failure')
-  recovery.discardRejected(); expect(recovery.pending.value?.rejected).toBe(false)
-})
-it.each(['400', '401', '403', '404', '409', '410', '422'].flatMap(code => [code, `A0${code}`, `HTTP_${code}`]))(
-  'clears the first definite rejection %s from memory and storage and preserves its original error', async code => {
-    const owner = crypto.randomUUID(), recovery = useDispatchCommandRecovery(() => owner)
-    recovery.begin('PC/1', 'SUBMIT_REVIEW', { recordVersion: 0, idempotencyKey: 'rejected-key' })
-    const rejection = new ApiResponseError('明确拒绝', code)
-    const send = vi.fn().mockRejectedValue(rejection), read = vi.fn(), find = vi.fn()
-    await expect(recovery.execute(send, read, find)).rejects.toBe(rejection)
-    expect(send).toHaveBeenCalledTimes(1)
-    expect(read).not.toHaveBeenCalled(); expect(find).not.toHaveBeenCalled()
-    expect(recovery.pending.value).toBeNull(); expect(recovery.busy.value).toBe(false)
-    expect(sessionStorage.getItem(`dispatch-command:${owner}`)).toBeNull()
-    const reopened = useDispatchCommandRecovery(() => owner)
-    expect(reopened.pending.value).toBeNull()
-    expect(() => reopened.begin('PC/1', 'EDIT', { recordVersion: 2, idempotencyKey: 'fresh-key' })).not.toThrow()
-  },
-)
-it('cleans an explicitly rejected legacy browser record when its scope is restored', () => {
-  const owner = crypto.randomUUID(), key = `dispatch-command:${owner}`
-  sessionStorage.setItem(key, JSON.stringify({ dispatchNo: 'PC/1', action: 'SUBMIT_REVIEW',
-    body: { recordVersion: 0, idempotencyKey: 'terminal-key' }, attempted: true, rejected: true, result: null }))
-  const recovery = useDispatchCommandRecovery(() => owner)
-  expect(recovery.pending.value).toBeNull(); expect(sessionStorage.getItem(key)).toBeNull()
-  expect(() => recovery.begin('PC/1', 'EDIT', { recordVersion: 1, idempotencyKey: 'new-key' })).not.toThrow()
-})
-it('cleans a terminal rejected record already shared by dialogs in the same scope', () => {
-  const owner = crypto.randomUUID(), first = useDispatchCommandRecovery(() => owner)
-  first.begin('PC/1', 'SUBMIT_REVIEW', { recordVersion: 0, idempotencyKey: 'terminal-key' })
-  first.pending.value!.attempted = true; first.pending.value!.rejected = true
-  sessionStorage.setItem(`dispatch-command:${owner}`, JSON.stringify(first.pending.value))
-  const second = useDispatchCommandRecovery(() => owner)
-  expect(second.pending).toBe(first.pending)
-  expect(first.pending.value).toBeNull(); expect(sessionStorage.getItem(`dispatch-command:${owner}`)).toBeNull()
-})
-it('retains a restored unknown record without explicit rejection proof and reconciles its original key', async () => {
-  const owner = crypto.randomUUID(), key = `dispatch-command:${owner}`
-  const original = { dispatchNo: 'PC/1', action: 'EDIT', body: { recordVersion: 0, idempotencyKey: 'unknown-key', remark: 'original' },
-    attempted: true, rejected: false, result: null }
-  sessionStorage.setItem(key, JSON.stringify(original))
-  const recovery = useDispatchCommandRecovery(() => owner)
-  expect(recovery.pending.value).toEqual(original)
-  const rejection = new ApiResponseError('later rejection', 'A0409')
-  const send = vi.fn().mockRejectedValue(rejection), read = vi.fn()
-  const find = vi.fn().mockRejectedValue(new ApiResponseError('not found', 'HTTP_404'))
-  await expect(recovery.execute(send, read, find)).rejects.toBe(rejection)
-  expect(find).toHaveBeenCalledWith('PC/1', 'unknown-key')
-  expect(send.mock.calls[0]![0].body).toEqual(original.body)
-  expect(read).not.toHaveBeenCalled()
-  expect(recovery.pending.value).toEqual(original); expect(JSON.parse(sessionStorage.getItem(key)!)).toEqual(original)
-})
-it('only rereads a restored proven result and keeps it when the detail read still fails', async () => {
-  const owner = crypto.randomUUID(), key = `dispatch-command:${owner}`
-  const original = { dispatchNo: 'PC/1', action: 'LOADING_COMPLETE', body: { recordVersion: 0, idempotencyKey: 'key' },
-    attempted: true, rejected: false, result: command('LOADING_COMPLETE') }
-  sessionStorage.setItem(key, JSON.stringify(original))
-  const recovery = useDispatchCommandRecovery(() => owner)
-  const send = vi.fn(), find = vi.fn(), failure = new Error('detail unavailable')
-  const read = vi.fn().mockRejectedValueOnce(failure).mockResolvedValueOnce({ dispatchNo: 'PC/1', recordVersion: 1 })
-  await expect(recovery.execute(send, read, find)).rejects.toBe(failure)
-  expect(recovery.pending.value).toEqual(original); expect(JSON.parse(sessionStorage.getItem(key)!)).toEqual(original)
-  await recovery.execute(send, read, find)
-  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()
+it('rejects an account change before sending and releases state',async()=>{
+  let owner=crypto.randomUUID();const state=useDispatchCommandRecovery(()=>owner)
+  state.begin('PC/1','EDIT',{recordVersion:0,idempotencyKey:'key'});owner=crypto.randomUUID()
+  const send=vi.fn()
+  await expect(state.execute(send,vi.fn())).rejects.toThrow('账号已变化')
+  expect(send).not.toHaveBeenCalled();expect(state.pending.value).toBeNull();expect(state.busy.value).toBe(false)
 })

src/modules/overseas-warehouse/dispatchCommandRecovery.ts

@@ -3,7 +3,7 @@ import { ApiResponseError } from '@/shared/api/http'
 import type { CommandResult, DispatchAction } from './dispatchContracts'
 import { requireVersion } from './dispatchContracts'
 
-export interface PendingDispatchCommand { dispatchNo: string; action: DispatchAction; body: Record<string, unknown>; attempted: boolean; result: CommandResult | null; rejected: boolean; operation?: 'ROUTE'; itemId?: string; submitReviewAfterSave?: boolean }
+export interface PendingDispatchCommand { dispatchNo: string; action: DispatchAction; body: Record<string, unknown>; operation?: 'ROUTE'; itemId?: string; submitReviewAfterSave?: boolean }
 const storageKey = (scope: string) => `dispatch-command:${scope}`
 const snapshot = <T>(value: T): T => JSON.parse(JSON.stringify(value)) as T
 const sessions = new Map<string, { pending: ReturnType<typeof ref<PendingDispatchCommand | null>>; busy: ReturnType<typeof ref<boolean>> }>()
@@ -13,74 +13,46 @@ export function isDefiniteDispatchRejection(error: unknown) {
 export function validateCommandResult(result: CommandResult, pending: PendingDispatchCommand) {
   if (!result || result.dispatchNo !== pending.dispatchNo && pending.action !== 'CREATE'
     || result.action !== pending.action || result.idempotencyKey !== pending.body.idempotencyKey
-    || !result.dispatchNo || !result.result) throw new Error('操作结果与原排车请求不一致，请保留原请求核对')
+    || !result.dispatchNo || !result.result) throw new Error('操作结果与本次排车请求不一致，请刷新后重试')
   requireVersion(result.recordVersion)
-  if (pending.action === 'LOADING_COMPLETE' && !['AFTER_LOADING', 'DELIVERING'].includes(result.stage)) 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
   if (current?.dispatchNo !== result.dispatchNo) throw new Error('恢复详情与原排车单不一致')
   const latest = String(requireVersion(current.recordVersion)).replace(/^0+(?=\d)/, '')
   const confirmed = String(requireVersion(result.recordVersion)).replace(/^0+(?=\d)/, '')
-  if (latest.length < confirmed.length || latest.length === confirmed.length && latest < confirmed) throw new Error('详情版本早于已确认操作，请保留原请求重读')
+  if (latest.length < confirmed.length || latest.length === confirmed.length && latest < confirmed) throw new Error('详情版本早于已确认操作，请刷新后重试')
 }
 
-/** A response proves the original command; a subsequent GET supplies current UI facts. */
+/** 仅在当前请求期间防止连点；失败立即释放页面，不持久化或恢复历史请求。 */
 export function useDispatchCommandRecovery(scope: () => string) {
   const owner = scope()
-  const saved = owner ? sessionStorage.getItem(storageKey(owner)) : null
+  if (owner) sessionStorage.removeItem(storageKey(owner))
   const existing = sessions.get(owner)
   const pending = existing?.pending || ref<PendingDispatchCommand | null>(null)
   const busy = existing?.busy || ref(false)
-  if (!existing && saved) {
-    try { pending.value = JSON.parse(saved) as PendingDispatchCommand }
-    catch { throw new Error('本次排车请求记录损坏，请保留现场核对') }
-  }
+  if (!busy.value) pending.value = null
   if (!existing) sessions.set(owner, { pending, busy })
-  function persist() {
+  function requireOwner() {
     if (!owner || owner !== scope()) throw new Error('账号已变化，请重新进入排车列表')
-    if (pending.value) sessionStorage.setItem(storageKey(owner), JSON.stringify(pending.value))
-    else sessionStorage.removeItem(storageKey(owner))
   }
   function begin(dispatchNo: string, action: DispatchAction, body: object, target: Pick<PendingDispatchCommand, 'operation' | 'itemId' | 'submitReviewAfterSave'> = {}) {
-    if (pending.value) throw new Error('上次排车操作结果尚未核对，请先恢复原请求')
-    pending.value = { dispatchNo, action, body: snapshot(body) as Record<string, unknown>, attempted: false, result: null, rejected: false, ...target }
-    persist()
+    requireOwner()
+    if (busy.value) throw new Error('操作正在提交，请稍候')
+    pending.value = { dispatchNo, action, body: snapshot(body) as Record<string, unknown>, ...target }
   }
-  async function execute(send: (command: PendingDispatchCommand) => Promise<CommandResult>, read: (dispatchNo: string) => Promise<unknown>, find: (dispatchNo: string, key: string) => Promise<CommandResult>) {
+  async function execute(send: (command: PendingDispatchCommand) => Promise<CommandResult>, read: (dispatchNo: string) => Promise<unknown>) {
     if (busy.value || !pending.value) return
     const command = pending.value
-    const previouslyAttempted = command.attempted
     busy.value = true
     try {
-      persist()
-      if (!command.result && previouslyAttempted && command.dispatchNo) {
-        try { const found = await find(command.dispatchNo, String(command.body.idempotencyKey)); validateCommandResult(found, command); command.result = found }
-        catch (error) { if (!(error instanceof ApiResponseError) || !['404', 'A0404', 'HTTP_404'].includes(String(error.code))) throw error }
-      }
-      if (!command.result) {
-        command.attempted = true; persist()
-        try { const sent = await send(snapshot(command)); validateCommandResult(sent, command); command.result = sent }
-        catch (error) {
-          // A later rejection cannot erase an earlier unknown write result.
-          if (!previouslyAttempted && isDefiniteDispatchRejection(error)) {
-            pending.value = null
-          }
-          persist(); throw error
-        }
-      }
-      validateCommandResult(command.result, command); persist()
-      validateCurrentDispatch(await read(command.result.dispatchNo), command.result)
-      pending.value = null; persist()
-      return command.result
-    } finally { busy.value = false }
+      requireOwner()
+      const result = await send(snapshot(command))
+      validateCommandResult(result, command)
+      validateCurrentDispatch(await read(result.dispatchNo), result)
+      return result
+    } finally { pending.value = null; busy.value = false }
   }
-  function discardRejected() {
-    if (busy.value || pending.value?.rejected !== true) return
-    pending.value = null; persist()
-  }
-  // Older browser records explicitly marked a first-attempt rejection as terminal.
-  // Only that recorded proof permits cleanup; unknown attempts and proven results remain.
-  discardRejected()
-  return { pending, busy, begin, execute, discardRejected }
+  return { pending, busy, begin, execute }
 }

src/modules/overseas-warehouse/pages/DispatchesView.test.ts

@@ -8,9 +8,8 @@ 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'
-import { command, detail, listRow, page, reviews } from '../dispatchTestFixtures'
+import { detail, listRow, page, reviews } from '../dispatchTestFixtures'
 import type { DispatchPage } from '../dispatchContracts'
-import { useDispatchCommandRecovery } from '../dispatchCommandRecovery'
 const identity = vi.hoisted(() => ({ id: '' }))
 const push = vi.hoisted(() => vi.fn())
 const can = vi.hoisted(() => vi.fn(() => true))
@@ -104,13 +103,13 @@ it('keeps return-to-review on the loading list with its service gate and permiss
   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()
-  expect(wrapper.text()).toContain('PC-OTHER 的确认装车完成结果尚待核对')
-  await wrapper.findAll('button').find(button => button.text() === '核对原请求')!.trigger('click')
-  const dialog = wrapper.get('dispatch-workflow-dialog-stub')
-  expect(dialog.attributes('dispatchno')).toBe('PC-OTHER'); expect(dialog.attributes('modelvalue')).toBe('true'); wrapper.unmount()
+it('does not let an old pending command hide or block filtered list operations',async()=>{
+  sessionStorage.setItem('dispatch-command:'+identity.id,JSON.stringify({dispatchNo:'PC-OTHER',action:'LOADING_COMPLETE',attempted:true,body:{idempotencyKey:'old'}}))
+  const wrapper=mount(DispatchesView,options);await flushPromises()
+  expect(wrapper.text()).not.toContain('结果尚待核对')
+  expect(wrapper.findAll('button').some(button=>button.text()==='核对原请求')).toBe(false)
+  expect(wrapper.getComponent({name:'DispatchWorkflowDialog'}).props('modelValue')).toBe(false)
+  expect(wrapper.text()).toContain('PC/1');wrapper.unmount()
 })
 it('centralizes cargo changes in smart dispatch and never exposes row add/remove actions', async () => {
   vi.mocked(listDispatches).mockResolvedValueOnce(page([listRow({ actions: { ADD_CARGO: { allowed: true, blockCode: null, blockReason: null }, REMOVE_CARGO: { allowed: true, blockCode: null, blockReason: null } } })]))
@@ -156,13 +155,13 @@ it.each([['DISPATCH_REVIEW', 1, '调度审核'], ['LOADING_REVIEW', 2, '理货
   expect(wrapper.getComponent({ name: 'DispatchWorkflowDialog' }).props()).toMatchObject({ modelValue: true, action, dispatchNo: 'PC/1' })
   wrapper.unmount()
 })
-it.each(['ADD_CARGO', 'REMOVE_CARGO'] as const)('recovers %s only inside smart dispatch', async action => {
-  useDispatchCommandRecovery(() => identity.id).begin('PC-OTHER', action, { recordVersion: 0, idempotencyKey: 'cargo-key' }, action === 'REMOVE_CARGO' ? { itemId: '17' } : undefined)
-  const wrapper = mount(DispatchesView, options); await flushPromises()
-  await wrapper.findAll('button').find(button => button.text() === '核对原请求')!.trigger('click')
-  expect(wrapper.getComponent({ name: 'SmartDispatchDialog' }).props('modelValue')).toBe(true)
-  expect(wrapper.getComponent({ name: 'DispatchWorkflowDialog' }).props('modelValue')).toBe(false)
-  wrapper.unmount()
+it.each(['ADD_CARGO','REMOVE_CARGO'] as const)('ignores old %s requests while allowing smart dispatch to open normally',async action=>{
+  sessionStorage.setItem('dispatch-command:'+identity.id,JSON.stringify({dispatchNo:'PC-OTHER',action,attempted:true,body:{idempotencyKey:'old'}}))
+  const wrapper=mount(DispatchesView,options);await flushPromises()
+  await wrapper.findAll('button').find(button=>button.text()==='智能排车')!.trigger('click')
+  expect(wrapper.getComponent({name:'SmartDispatchDialog'}).props('modelValue')).toBe(true)
+  expect(wrapper.getComponent({name:'DispatchWorkflowDialog'}).props('modelValue')).toBe(false)
+  expect(wrapper.text()).not.toContain('结果尚待核对');wrapper.unmount()
 })
 it.each([1, 2])('keeps only details in audit tab %s without its review permission', async index => {
   can.mockReturnValue(false)
@@ -397,16 +396,12 @@ it.each(['saved', 'rejected'] as const)('refreshes list actions after workflow %
   expect(wrapper.text()).not.toContain('结果尚待核对')
   wrapper.unmount()
 })
-it('describes a proven command awaiting its GET as completed instead of unknown', async () => {
-  const recovery = useDispatchCommandRecovery(() => identity.id)
-  recovery.begin('PC/1', 'SUBMIT_REVIEW', { recordVersion: 0, idempotencyKey: 'known-key' })
-  recovery.pending.value!.attempted = true
-  recovery.pending.value!.result = command('SUBMIT_REVIEW', 'known-key')
-  const wrapper = mount(DispatchesView, options); await flushPromises()
-  expect(wrapper.text()).toContain('操作已完成，页面资料待刷新')
+it('does not restore stored failed commands or expose replay controls in the list',async()=>{
+  sessionStorage.setItem('dispatch-command:'+identity.id,JSON.stringify({dispatchNo:'PC/1',action:'SUBMIT_REVIEW',attempted:true,result:{recordVersion:1},body:{idempotencyKey:'old'}}))
+  const wrapper=mount(DispatchesView,options);await flushPromises()
   expect(wrapper.text()).not.toContain('结果尚待核对')
-  await wrapper.findAll('button').find(button => button.text() === '刷新页面资料')!.trigger('click')
-  expect(wrapper.getComponent({ name: 'DispatchWorkflowDialog' }).props()).toMatchObject({ modelValue: true, action: 'SUBMIT_REVIEW', dispatchNo: 'PC/1' })
+  expect(wrapper.text()).not.toContain('刷新页面资料')
+  expect(wrapper.getComponent({name:'DispatchWorkflowDialog'}).props('modelValue')).toBe(false)
   wrapper.unmount()
 })
 it('clears an earlier input rejection after the corrected workflow succeeds', async () => {
@@ -433,3 +428,17 @@ it('opens the exception form from the dispatching row and hides it without permi
   expect((deniedRow.props('actions') as Array<{ key: string }>).map(item => item.key)).not.toContain('MARK_EXCEPTION')
   denied.unmount()
 })
+
+it.each([['DISPATCH_REVIEW',1,'DISPATCH_REJECTED'],['LOADING_REVIEW',2,'LOADING_REJECTED']] as const)('returns a rejected %s to vehicle information',async(action,index,reviewState)=>{
+  const allowed={allowed:true,blockCode:null,blockReason:null}
+  vi.mocked(listDispatches).mockResolvedValue(page([listRow({actions:{[action]:allowed}})]))
+  const wrapper=mount(DispatchesView,options);await flushPromises()
+  await wrapper.get('[aria-label="装车前审核分区"]').findAll('button')[index]!.trigger('click');await flushPromises()
+  const row=wrapper.findAllComponents(RowActions).find(entry=>entry.props('moreLabel')==='更多操作 · PC/1')!
+  row.vm.$emit('action',action);await flushPromises()
+  vi.mocked(getDispatch).mockResolvedValueOnce(detail({reviewState,stage:'BEFORE_LOADING'}))
+  wrapper.getComponent({name:'DispatchWorkflowDialog'}).vm.$emit('saved');await flushPromises()
+  expect(listDispatches).toHaveBeenLastCalledWith(expect.objectContaining({page:1,stage:'BEFORE_LOADING',beforeLoadingSection:'VEHICLE_INFO'}))
+  expect(wrapper.get('[aria-label="装车前审核分区"]').findAll('button')[0]!.attributes('aria-selected')).toBe('true')
+  wrapper.unmount()
+})

src/modules/overseas-warehouse/pages/DispatchesView.vue

@@ -7,7 +7,6 @@ import { ElMessage, ElMessageBox } from 'element-plus'
 import { appointmentReturnTarget } from '@/modules/appointment-calendar'
 import { TransportRouteDialog, routeLocation, type RouteLocation } from '@/modules/overseas-master-data'
 import { useAccessPreviewStore } from '@/core/access/accessPreview'
-import { useAuthStore } from '@/core/auth/auth'
 import { getApiErrorDetails, type ApiErrorDetails } from '@/shared/api/http'
 import AdminPage from '@/shared/components/AdminPage.vue'
 import ListPageLayout from '@/shared/components/ListPageLayout.vue'
@@ -28,10 +27,8 @@ import { cancelTransport, getTransport, transportLabels, type TransportType } fr
 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()
-const auth = useAuthStore(), recovery = useDispatchCommandRecovery(() => auth.user?.id || '')
 const rows = ref<DispatchListRow[]>([]), statistics = ref<DispatchStatistics | null>(null)
 const loading = ref(false), loadError = ref<ApiErrorDetails | null>(null), mutationError = ref<ApiErrorDetails | null>(null)
 const rejectionError = ref<ApiErrorDetails | null>(null)
@@ -177,12 +174,19 @@ async function cancelPickup(row: DispatchListRow) {
   finally { cancellingPickup.value = '' }
 }
 async function handleRejection(details: ApiErrorDetails) { rejectionError.value = details; await load() }
-async function handleSaved() { rejectionError.value = null; await load() }
-function recoverPending() {
-  const command = recovery.pending.value
-  if (!command) return
-  if (['CREATE', 'ADD_CARGO', 'REMOVE_CARGO'].includes(command.action)) { createOpen.value = true; return }
-  operation.value = command.operation; action.value = command.action; actionNo.value = command.dispatchNo; actionOpen.value = true
+async function handleSaved() {
+  rejectionError.value = null
+  if (actionNo.value && ['DISPATCH_REVIEW', 'LOADING_REVIEW'].includes(action.value)) {
+    try {
+      const current = await getDispatch(actionNo.value)
+      if (current.dispatchNo === actionNo.value && current.stage === 'BEFORE_LOADING' && ['DISPATCH_REJECTED', 'LOADING_REJECTED'].includes(current.reviewState)) {
+        stage.value = 'BEFORE_LOADING'; section.value = 'VEHICLE_INFO'; page.value = 1
+        model.value.status = 'ACTIVE'
+        if (model.value.vehicleStatus) model.value.vehicleStatus = 'WAIT_DEPARTURE'
+      }
+    } catch (cause) { mutationError.value = getApiErrorDetails(cause, '审核已处理，当前排车状态读取失败，请刷新') }
+  }
+  await load()
 }
 async function openBol(row: DispatchListRow) {
   if (bolLoadingNo.value || !canDownloadBol(row)) return
@@ -204,7 +208,6 @@ onBeforeUnmount(() => { sequence++ })
   <AdminPage class="admin-density admin-workbench"><ListPageLayout aria-label="海外仓排车列表">
     <OperationErrorToast :details="mutationError" />
     <LoadErrorState v-if="rejectionError" title="排车操作未完成" :message="rejectionError.message" :show-retry="false"><template #details><ApiErrorMeta :details="rejectionError" /></template></LoadErrorState>
-    <p v-if="recovery.pending.value" role="status">{{ recovery.pending.value.dispatchNo || '新排车单' }} 的{{ dispatchActionLabels[recovery.pending.value.action] }}{{ recovery.pending.value.result ? '操作已完成，页面资料待刷新。' : '结果尚待核对。' }}<el-button link :disabled="recovery.busy.value" @click="recoverPending">{{ recovery.pending.value.result ? '刷新页面资料' : '核对原请求' }}</el-button></p>
     <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>

src/modules/overseas-warehouse/pages/InboundOrdersView.vue

@@ -266,7 +266,7 @@ onMounted(() => { void load() })
   <AppDialog class="admin-density-dialog admin-workbench is-dialog" v-model="planEditOpen" :title="`编辑入库单 · ${planEditTarget?.orderNo || '—'}`" fullscreenable confirm-text="保存" :loading="planEditLoading" :confirm-disabled="planEditLoading || !planEditForm.warehouseId" :confirm-loading="planEditSaving" @confirm="submitPlanEdit"><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>{{ planEditTarget?.orderNo || '—' }}</td></tr></tbody></table></section>
     <LoadErrorState v-if="mutationError" compact title="入库单保存失败" :message="mutationError.message" :loading="planEditSaving" retry-text="重试保存" @retry="submitPlanEdit"><template #details><ApiErrorMeta :details="mutationError" /></template></LoadErrorState>
-    <section class="density-dialog-section" data-tone="work" aria-label="目的仓登记"><h3 class="density-dialog-section__title">目的仓登记</h3><el-form class="density-form" label-position="left" label-width="100px" :disabled="planEditLoading || planEditSaving"><table class="density-table density-table--editable"><tbody><tr><td><el-form-item label="目的仓" required><el-select v-model="planEditForm.warehouseId" filterable placeholder="请选择目的仓" @change="(id: string) => { const w = warehouses.find((item) => item.id === id); planEditForm.warehouseCode = w?.warehouseCode || ''; planEditForm.warehouseName = w?.warehouseName || '' }"><el-option v-for="warehouse in warehouses" :key="warehouse.id" :label="`${warehouse.warehouseName}（${warehouse.warehouseCode}）`" :value="warehouse.id" /></el-select></el-form-item></td></tr></tbody></table></el-form></section>
+    <section class="density-dialog-section" aria-label="目的仓登记"><h3 class="density-dialog-section__title">目的仓登记</h3><el-form class="density-form" label-position="left" label-width="100px" :disabled="planEditLoading || planEditSaving"><table class="density-table density-table--editable"><tbody><tr><td><el-form-item label="目的仓" required><el-select v-model="planEditForm.warehouseId" filterable placeholder="请选择目的仓" @change="(id: string) => { const w = warehouses.find((item) => item.id === id); planEditForm.warehouseCode = w?.warehouseCode || ''; planEditForm.warehouseName = w?.warehouseName || '' }"><el-option v-for="warehouse in warehouses" :key="warehouse.id" :label="`${warehouse.warehouseName}（${warehouse.warehouseCode}）`" :value="warehouse.id" /></el-select></el-form-item></td></tr></tbody></table></el-form></section>
   </div></AppDialog>
   </AdminPage>
 </template>

src/modules/overseas-warehouse/pages/LastMileOrdersView.behavior.test.ts

@@ -11,6 +11,7 @@ import DataTable from '@/shared/components/DataTable.vue'
 import AppDialog from '@/shared/components/AppDialog.vue'
 import QueryToolbar from '@/shared/components/QueryToolbar.vue'
 import { listAllPlatformWarehouses } from '@/modules/warehouses'
+import { listContainerArrivalTimes } from '@/modules/container-loading'
 import {
   changeContainerReceivingWarehouse,
   createManualInboundPlan,
@@ -35,6 +36,10 @@ vi.mock('@/shared/downloadCsv', () => ({ saveCsv: vi.fn() }))
 const routerPush = vi.hoisted(() => vi.fn())
 vi.mock('vue-router', () => ({ useRouter: () => ({ push: routerPush }) }))
 vi.mock('@/modules/warehouses', () => ({ listAllPlatformWarehouses: vi.fn() }))
+vi.mock('@/modules/container-loading', async () => ({
+  ...await import('../../container-loading/warehouseArrival'),
+  listContainerArrivalTimes: vi.fn(),
+}))
 vi.mock('../api/lastMileOrders', () => ({
   getReturnOrderStatistics: vi.fn(),
   listLastMileOrders: vi.fn(), listContainerPlanProgress: vi.fn(), getContainerPlanProgress: vi.fn(),
@@ -54,6 +59,10 @@ function memoryStorage(): Storage {
 }
 
 const bookingId = '2092873463568597001'
+const arrivalTime = {
+  sourceContainerBookingId: bookingId, estimatedWarehouseArrivalAt: '2026-09-01T08:00:00',
+  actualWarehouseArrivalAt: null, version: 1, planCount: 0, plannedDate: '2026-09-01', isDefault: false,
+}
 const emptyReturnStatistics = { totals: { orderCount: 0, skuTypes: 0, expectedQuantity: 0, receivedQuantity: 0, remainingQuantity: 0, receivedBoxCount: 0, receivedParcelCount: 0, receivedPalletCount: 0 }, pageDimensions: [] }
 beforeEach(() => {
   vi.mocked(getReturnOrderStatistics).mockReset().mockResolvedValue(emptyReturnStatistics)
@@ -171,6 +180,12 @@ async function selectRows(wrapper: Awaited<ReturnType<typeof mountView>>, rows:
   await wrapper.vm.$nextTick()
 }
 
+/** 定向验证入库弹框，独立于列表页签和批量操作入口。 */
+async function openArrivalPlan(wrapper: Awaited<ReturnType<typeof mountView>>, source = selectedRow()) {
+  ;(wrapper.vm as unknown as { openInboundPlan(source: object): void }).openInboundPlan(source)
+  await flushPromises()
+}
+
 function button(wrapper: Awaited<ReturnType<typeof mountView>>, text: string) {
   return wrapper.findAll('button').find((item) => item.text().includes(text))
 }
@@ -359,6 +374,7 @@ describe('LastMileOrdersView pending order and container conversion', () => {
       orders: [{ orderId: '2092873463568596994', customerId, orderNo: 'LMO-1', inboundCode: 'IN-1', orderStatus: 'INBOUND_PLANNED', planId: '2092873463568597010', planNo: 'LIP-1', planStatus: 'PENDING_RECEIVING', planValid: true, plannedArrivalAt: '2026-09-01T08:00:00' }],
     })
     vi.mocked(createManualInboundPlan).mockReset().mockResolvedValue({} as never)
+    vi.mocked(listContainerArrivalTimes).mockReset().mockResolvedValue([arrivalTime])
     vi.mocked(getContainerInboundPlanPreview).mockReset().mockResolvedValue(preview as never)
     vi.mocked(getLastMileOrderManualNodes).mockReset().mockResolvedValue({ orderId: '2092873463568596994', manualOverrideEnabled: false, nodes: [], version: 0 })
     vi.mocked(updateLastMileOrderHold).mockReset().mockResolvedValue({ orderId: '2092873463568596994', held: true, chargeable: true, version: 1 })
@@ -627,11 +643,35 @@ describe('LastMileOrdersView pending order and container conversion', () => {
     expect(confirm).toBeUndefined()
   })
 
-  it('blocks manual plan creation when the cabinet has no frozen expected arrival time', async () => {
+  it.each([
+    [{ ...arrivalTime, estimatedWarehouseArrivalAt: '2026-10-25T09:30:00', plannedDate: '2026-10-25' }, '2026-10-25 09:30'],
+    [{ ...arrivalTime, estimatedWarehouseArrivalAt: null, version: 0, plannedDate: '2026-11-01', isDefault: true }, '2026-11-01（默认推算）'],
+    [{ ...arrivalTime, estimatedWarehouseArrivalAt: null, version: 0, planCount: 1, plannedDate: '2026-11-02' }, '2026-11-02'],
+  ])('reads the latest cabinet arrival on opening and permits planning with %s', async (arrival, expectedText) => {
+    vi.mocked(listContainerArrivalTimes).mockResolvedValue([arrival])
     const wrapper = await openPending()
-    await selectRows(wrapper, [selectedRow({ estimatedWarehouseAt: '', warehouseEta: '—' })])
-    await button(wrapper, '入库')!.trigger('click')
+    await openArrivalPlan(wrapper, arrival.estimatedWarehouseArrivalAt ? selectedRow() : selectedRow({ estimatedWarehouseAt: '', warehouseEta: '—' }))
+
+    expect(listContainerArrivalTimes).toHaveBeenCalledWith([bookingId])
+    const source = wrapper.get('[aria-label="入库来源"]')
+    expect(source.text()).toContain(expectedText)
+    if (!arrival.estimatedWarehouseArrivalAt) expect(source.text()).not.toContain('00:00')
+    const dialog = wrapper.findAllComponents(AppDialog).find(item => item.props('title').startsWith('入库计划 ·'))!
+    expect(dialog.props('confirmDisabled')).toBe(false)
+    dialog.vm.$emit('confirm')
     await flushPromises()
+    expect(createManualInboundPlan).toHaveBeenCalledTimes(1)
+    expect(vi.mocked(createManualInboundPlan).mock.calls[0][0]).not.toHaveProperty('plannedArrivalDate')
+  })
+
+  it.each([
+    { arrivals: [] },
+    { arrivals: [{ ...arrivalTime, estimatedWarehouseArrivalAt: null, plannedDate: null }] },
+    { arrivals: [{ ...arrivalTime, version: -1 }] },
+  ])('blocks manual planning when the authoritative cabinet arrival is missing or inconsistent: $arrivals', async ({ arrivals }) => {
+    vi.mocked(listContainerArrivalTimes).mockResolvedValue(arrivals)
+    const wrapper = await openPending()
+    await openArrivalPlan(wrapper)
 
     const confirm = [...document.body.querySelectorAll('button')]
       .find((item) => item.textContent?.includes('保存并生成入库单')) as HTMLButtonElement
@@ -639,6 +679,37 @@ describe('LastMileOrdersView pending order and container conversion', () => {
     expect(createManualInboundPlan).not.toHaveBeenCalled()
   })
 
+  it('shows arrival read failures and does not reuse the list timestamp', async () => {
+    vi.mocked(listContainerArrivalTimes).mockRejectedValue(new ApiResponseError('到仓来源暂不可读', 'A0503', 503))
+    const wrapper = await openPending()
+    await openArrivalPlan(wrapper)
+    const dialog = wrapper.findAllComponents(AppDialog).find(item => item.props('title').startsWith('入库计划 ·'))!
+    expect(dialog.text()).toContain('到仓来源暂不可读')
+    expect(dialog.get('[aria-label="入库来源"]').text()).not.toContain('2026-09-01')
+    expect(dialog.props('confirmDisabled')).toBe(true)
+    dialog.vm.$emit('confirm'); await flushPromises()
+    expect(createManualInboundPlan).not.toHaveBeenCalled()
+  })
+
+  it('keeps confirmation blocked during arrival loading and ignores an older opening of the same order', async () => {
+    let resolveOld!: (value: typeof arrivalTime[]) => void
+    vi.mocked(listContainerArrivalTimes).mockReturnValueOnce(new Promise(resolve => { resolveOld = resolve }))
+    const wrapper = await openPending()
+    await openArrivalPlan(wrapper)
+    const dialog = wrapper.findAllComponents(AppDialog).find(item => item.props('title').startsWith('入库计划 ·'))!
+    expect(dialog.props('confirmDisabled')).toBe(true)
+    dialog.vm.$emit('confirm'); await flushPromises()
+    expect(createManualInboundPlan).not.toHaveBeenCalled()
+    dialog.vm.$emit('update:modelValue', false)
+    await wrapper.vm.$nextTick()
+    vi.mocked(listContainerArrivalTimes).mockResolvedValueOnce([{ ...arrivalTime, estimatedWarehouseArrivalAt: '2026-10-26T10:00:00', plannedDate: '2026-10-26' }])
+    await openArrivalPlan(wrapper)
+    expect(dialog.get('[aria-label="入库来源"]').text()).toContain('2026-10-26 10:00')
+    resolveOld([arrivalTime]); await flushPromises()
+    expect(dialog.get('[aria-label="入库来源"]').text()).toContain('2026-10-26 10:00')
+    expect(dialog.props('confirmDisabled')).toBe(false)
+  })
+
   it('locks one-click dropship manual plans to the frozen source pallet count', async () => {
     vi.mocked(getContainerInboundPlanPreview).mockResolvedValue({
       ...preview,

src/modules/overseas-warehouse/pages/LastMileOrdersView.vue

@@ -7,6 +7,7 @@ import { ChevronDown, ChevronUp, Download, Pencil, PackagePlus, SlidersHorizonta
 import { ElMessage, ElMessageBox } from 'element-plus'
 import { useRouter } from 'vue-router'
 import { listAllPlatformWarehouses, type PlatformWarehouseSummaryResource } from '@/modules/warehouses'
+import { listContainerArrivalTimes, projectWarehouseArrival, type ContainerArrivalTime } from '@/modules/container-loading'
 import { getApiErrorDetails, type ApiErrorDetails } from '@/shared/api/http'
 import AdminPage from '@/shared/components/AdminPage.vue'
 import AppDialog from '@/shared/components/AppDialog.vue'
@@ -110,12 +111,23 @@ const inboundPlanSourcePalletCount = ref<number | null>(null)
 const inboundPlanPreviewLoading = ref(false)
 const inboundPlanPreviewError = ref('')
 const inboundPlanIsDropship = computed(() => actionTarget.value?.orderTypeCode === 'ONE_CLICK_DROPSHIP')
-const inboundPlanSubmitDisabled = computed(() => !actionTarget.value?.estimatedWarehouseAt
+const inboundPlanArrival = ref<ContainerArrivalTime | null>(null)
+const inboundPlanArrivalLoading = ref(false)
+const inboundPlanArrivalError = ref('')
+let inboundPlanArrivalRequest = 0
+const inboundPlanArrivalProjection = computed(() => {
+  const arrival = inboundPlanArrival.value
+  return projectWarehouseArrival(arrival ? { ...arrival, plannedAt: arrival.estimatedWarehouseArrivalAt } : undefined)
+})
+const inboundPlanSubmitDisabled = computed(() => inboundPlanArrivalLoading.value || !inboundPlanArrivalProjection.value.date
   || (inboundPlanIsDropship.value
     && (inboundPlanPreviewLoading.value || inboundPlanSourcePalletCount.value == null
       || inboundPlanSourcePalletCount.value <= 0)))
 const inboundPlanForm = reactive({ inboundCode: '', palletCount: 1, palletType: 'WOOD' as 'STANDARD' | 'WOOD' | 'PAPER', assigned: false, mergeRequired: false, urgent: false, remark: '' })
-const inboundPlanExpectedArrival = computed(() => actionTarget.value?.warehouseEta || '—')
+const inboundPlanExpectedArrival = computed(() => {
+  const { date, time, isDefault } = inboundPlanArrivalProjection.value
+  return date ? `${date}${time ? ` ${time}` : ''}${isDefault ? '（默认推算）' : ''}` : '—'
+})
 const holdOpen = ref(false)
 const holdForm = reactive({ held: true, chargeable: true, reason: '' })
 const manualNodesOpen = ref(false)
@@ -633,9 +645,37 @@ function openInboundPlan(source?: object) {
   inboundPlanPreviewError.value = ''
   Object.assign(inboundPlanForm, { inboundCode: target.inboundCode === '—' ? '' : target.inboundCode, palletCount: inboundPlanMinimumPalletCount.value, palletType: 'WOOD', assigned: false, mergeRequired: false, urgent: false, remark: '' })
   actionError.value = null
+  inboundPlanArrival.value = null
+  inboundPlanArrivalError.value = ''
   inboundPlanOpen.value = true
+  void refreshInboundPlanArrival(target)
   void refreshManualPalletMinimum(target)
 }
+/** 每次打开重新读取柜级权威日期，避免使用列表旧值或在页面推算默认日期。 */
+async function refreshInboundPlanArrival(target: LastMileOrderListItem) {
+  const request = ++inboundPlanArrivalRequest
+  inboundPlanArrivalLoading.value = true
+  try {
+    if (!target.sourceContainerBookingId) {
+      inboundPlanArrivalError.value = '尾程订单未绑定来源柜，无法取得预计到仓时间'
+      return
+    }
+    const arrivals = await listContainerArrivalTimes([target.sourceContainerBookingId])
+    if (request !== inboundPlanArrivalRequest || !inboundPlanOpen.value) return
+    const arrival = arrivals.find(item => item.sourceContainerBookingId === target.sourceContainerBookingId)
+    if (!arrival || arrival.version < 0) {
+      inboundPlanArrivalError.value = '来源柜预计到仓日期缺失或不一致，请先核对柜级时间'
+      return
+    }
+    inboundPlanArrival.value = arrival
+  } catch (error) {
+    if (request === inboundPlanArrivalRequest && inboundPlanOpen.value) {
+      inboundPlanArrivalError.value = getApiErrorDetails(error, '预计到仓时间加载失败，请重新打开入库计划重试').message
+    }
+  } finally {
+    if (request === inboundPlanArrivalRequest) inboundPlanArrivalLoading.value = false
+  }
+}
 async function refreshManualPalletMinimum(target: LastMileOrderListItem) {
   if (!target.sourceContainerBookingId) return
   inboundPlanPreviewLoading.value = true
@@ -671,7 +711,7 @@ async function submitInboundPlan() {
     ElMessage.warning('一件代发必须按头程已封托托盘数整体生成入库计划')
     return
   }
-  if (!row || !row.overseasWarehouseId || !row.estimatedWarehouseAt || !frozenInboundCode || frozenInboundCode === '—' || inboundPlanForm.palletCount < inboundPlanMinimumPalletCount.value) {
+  if (!row || !row.overseasWarehouseId || inboundPlanArrivalLoading.value || !inboundPlanArrivalProjection.value.date || !frozenInboundCode || frozenInboundCode === '—' || inboundPlanForm.palletCount < inboundPlanMinimumPalletCount.value) {
     ElMessage.warning('当前柜须已分配接柜仓、具备预计到仓时间，并完整填写托数')
     return
   }
@@ -1279,17 +1319,18 @@ onMounted(() => { void load() })
       </LoadErrorState>
     </el-form>
   </AppDialog>
-  <AppDialog class="admin-density-dialog admin-workbench is-dialog" v-model="inboundPlanOpen" :title="`入库计划 · ${actionTarget?.orderNo || '—'}`" width="min(720px, calc(100vw - 28px))" fullscreenable confirm-text="保存并生成入库单" :loading="inboundPlanPreviewLoading" :confirm-loading="actionLoading" :confirm-disabled="inboundPlanSubmitDisabled" @confirm="submitInboundPlan">
-    <el-alert title="保存后生成入库单；清关完成后入库计划不可更改。" type="info" :closable="false" show-icon />
+  <AppDialog class="admin-density-dialog admin-workbench is-dialog" v-model="inboundPlanOpen" :title="`入库计划 · ${actionTarget?.orderNo || '—'}`" width="min(720px, calc(100vw - 28px))" fullscreenable confirm-text="保存并生成入库单" :loading="inboundPlanPreviewLoading || inboundPlanArrivalLoading" :confirm-loading="actionLoading" :confirm-disabled="inboundPlanSubmitDisabled" @confirm="submitInboundPlan">
+    <el-alert title="保存后生成入库单；首个入库计划生成后，整柜预计到仓时间不可更改。" type="info" :closable="false" show-icon />
     <el-alert v-if="inboundPlanPreviewError" :title="inboundPlanPreviewError" type="error" :closable="false" show-icon />
+    <el-alert v-if="inboundPlanArrivalError" :title="inboundPlanArrivalError" type="error" :closable="false" show-icon />
     <el-form class="command-form density-form density-dialog-sections" label-position="left" label-width="110px" :disabled="actionLoading">
-      <section class="density-dialog-section" data-tone="source" aria-label="入库来源"><h3 class="density-dialog-section__title">入库来源 <InlineHelp title="入库来源说明">取整柜预计到仓时间，同柜所有入库计划保持一致；已生成计划后锁定。接柜仓按柜统一；如需变更，请在柜子工作台执行“变更接柜仓”。</InlineHelp></h3>
+      <section class="density-dialog-section" data-tone="source" aria-label="入库来源"><h3 class="density-dialog-section__title">入库来源 <InlineHelp title="入库来源说明">优先使用整柜人工维护的预计到仓时间；未维护时，按到港当地日期加两个自然日默认推算。首个入库计划生成后冻结日期，同柜计划保持一致。接柜仓按柜统一；如需变更，请在柜子工作台执行“变更接柜仓”。</InlineHelp></h3>
         <table class="density-table last-mile-dialog-facts"><tbody>
           <tr><th scope="row">预计到仓时间</th><td>{{ inboundPlanExpectedArrival }} <el-button v-if="access.can('platform:firstleg:terminal-drayage:list') && actionTarget?.containerNo" link type="primary" @click="router.push({ name: 'overseas-container-workbench', query: { keyword: actionTarget.containerNo } })">前往货柜维护预计到仓</el-button></td></tr>
           <tr><th scope="row">计划入库仓</th><td>{{ inboundPlanWarehouseLabel || '—' }}</td></tr><tr><th scope="row">入仓码</th><td>{{ inboundPlanForm.inboundCode || '—' }}</td></tr>
         </tbody></table>
       </section>
-      <section class="density-dialog-section" data-tone="work" aria-label="入库计划登记"><h3 class="density-dialog-section__title">计划登记</h3>
+      <section class="density-dialog-section" aria-label="入库计划登记"><h3 class="density-dialog-section__title">计划登记</h3>
         <table class="density-table density-table--editable last-mile-command-table"><tbody>
           <tr><td><el-form-item label="托数" required><span v-if="inboundPlanIsDropship" class="frozen-pallet-count">{{ inboundPlanForm.palletCount }}</span><el-input-number v-else v-model="inboundPlanForm.palletCount" :min="inboundPlanMinimumPalletCount" :max="999" controls-position="right" /><span class="density-dialog-note" v-if="inboundPlanIsDropship">一件代发固定按头程已封托托盘数整体入库，不可增减。</span><span class="density-dialog-note" v-else>按柜级预览至少 {{ inboundPlanMinimumPalletCount }} 托，可增加，不能减少。</span></el-form-item></td><td><el-form-item label="托盘类型"><el-select v-model="inboundPlanForm.palletType" placeholder="请选择托盘类型"><el-option label="标准托盘" value="STANDARD" /><el-option label="木托盘" value="WOOD" /><el-option label="纸托盘" value="PAPER" /></el-select></el-form-item></td></tr>
           <tr><td><el-form-item label="是否分配"><el-switch v-model="inboundPlanForm.assigned" inline-prompt active-text="是" inactive-text="否" /></el-form-item></td><td><el-form-item label="允许合托"><el-switch v-model="inboundPlanForm.mergeRequired" inline-prompt active-text="是" inactive-text="否" /><InlineHelp title="合托提示说明">仅作为现场可选提示，不强制工人合托。</InlineHelp></el-form-item></td></tr>

src/modules/overseas-warehouse/pages/PalletsView.test.ts

@@ -33,7 +33,7 @@ describe('PalletsView', () => {
   })
 
   it('loads the all-warehouse pallet list and summary when the page opens', async () => {
-    vi.mocked(getPalletSummary).mockResolvedValueOnce({ totalCount: 250, idleCount: 100, occupiedCount: 98, scrappedCount: 52 })
+    vi.mocked(getPalletSummary).mockResolvedValueOnce({ totalCount: 1250, idleCount: 1100, occupiedCount: 98, scrappedCount: 52 })
 
     const wrapper = mount(PalletsView, { attachTo: document.body, global: { plugins: [ElementPlus] } })
     await flushPromises()
@@ -42,10 +42,10 @@ describe('PalletsView', () => {
     expect(getPalletSummary).toHaveBeenCalledWith('', { page: 1, size: 10, keyword: undefined, palletType: undefined, status: undefined })
     expect(wrapper.get('[aria-label="托盘管理列表"]').text()).toContain('PLT-1')
     expect(wrapper.get('[aria-label="托盘管理列表"]').text()).not.toContain('请先选择仓库后查询')
-    expect(wrapper.get('[aria-label="海外托盘数量概览"]').text()).toContain('托盘总数250')
-    expect(wrapper.get('[aria-label="海外托盘数量概览"]').text()).toContain('闲置托盘100')
-    expect(wrapper.get('[aria-label="海外托盘数量概览"]').text()).toContain('占用托盘98')
-    expect(wrapper.get('[aria-label="海外托盘数量概览"]').text()).toContain('已报废52')
+    const cards = wrapper.get('[aria-label="海外托盘数量概览"]').findAll('article')
+    expect(cards.map(card => card.get('h2').text())).toEqual(['托盘总数', '闲置托盘', '占用托盘', '已报废'])
+    expect(cards.map(card => card.get('strong').text())).toEqual(['1,250', '1,100', '98', '52'])
+    expect(cards.map(card => card.get('.workbench-metric-value > span').text())).toEqual(['个', '个', '个', '个'])
   })
 
   it('prints one pallet from the all-warehouse list and allows retry after failure', async () => {

src/modules/overseas-warehouse/pages/PalletsView.vue

@@ -2,7 +2,7 @@
 import '@/styles/adminWorkbench.css'
 import '@/styles/adminDensity.css'
 import { computed, onMounted, reactive, ref } from 'vue'
-import { Plus } from '@lucide/vue'
+import { Layers, Package, PackageCheck, PackageX, Plus } from '@lucide/vue'
 import { ElMessage } from 'element-plus'
 import { useRouter } from 'vue-router'
 import { useAccessPreviewStore } from '@/core/access/accessPreview'
@@ -167,7 +167,24 @@ onMounted(initialize)
 
 <template>
   <AdminPage class="admin-density admin-workbench"><OperationErrorToast :details="mutationError" />
-  <section class="summary-grid workbench-panel is-flush" aria-label="海外托盘数量概览"><article><span>托盘总数</span><strong>{{ summary.totalCount }}</strong></article><article><span>闲置托盘</span><strong class="idle">{{ summary.idleCount }}</strong></article><article><span>占用托盘</span><strong class="occupied">{{ summary.occupiedCount }}</strong></article><article><span>已报废</span><strong>{{ summary.scrappedCount }}</strong></article></section>
+  <section class="summary-grid" aria-label="海外托盘数量概览">
+    <article class="workbench-metric workbench-tone is-compact" data-tone="blue">
+      <div class="workbench-metric-heading"><span class="workbench-icon is-compact"><Layers aria-hidden="true" /></span><h2 class="workbench-metric-label">托盘总数</h2></div>
+      <div class="workbench-metric-value"><strong>{{ summary.totalCount.toLocaleString('zh-CN') }}</strong><span>个</span></div>
+    </article>
+    <article class="workbench-metric workbench-tone is-compact" data-tone="green">
+      <div class="workbench-metric-heading"><span class="workbench-icon is-compact"><PackageCheck aria-hidden="true" /></span><h2 class="workbench-metric-label">闲置托盘</h2></div>
+      <div class="workbench-metric-value"><strong>{{ summary.idleCount.toLocaleString('zh-CN') }}</strong><span>个</span></div>
+    </article>
+    <article class="workbench-metric workbench-tone is-compact" data-tone="purple">
+      <div class="workbench-metric-heading"><span class="workbench-icon is-compact"><Package aria-hidden="true" /></span><h2 class="workbench-metric-label">占用托盘</h2></div>
+      <div class="workbench-metric-value"><strong>{{ summary.occupiedCount.toLocaleString('zh-CN') }}</strong><span>个</span></div>
+    </article>
+    <article class="workbench-metric workbench-tone is-compact" data-tone="rose">
+      <div class="workbench-metric-heading"><span class="workbench-icon is-compact"><PackageX aria-hidden="true" /></span><h2 class="workbench-metric-label">已报废</h2></div>
+      <div class="workbench-metric-value"><strong>{{ summary.scrappedCount.toLocaleString('zh-CN') }}</strong><span>个</span></div>
+    </article>
+  </section>
   <ListPageLayout aria-label="托盘管理列表">
 
 
@@ -203,13 +220,9 @@ onMounted(initialize)
 </template>
 
 <style scoped>
-.summary-grid span { color:var(--workbench-muted); font-size:var(--admin-font-caption); }.summary-grid .idle { color:var(--el-color-success); }.summary-grid .occupied { color:var(--el-color-warning); }
 .pallet-editor-table { table-layout: fixed; }
 .pallet-editor-table td:not([colspan]) { width: 50%; }
 
-.summary-grid { display: flex; gap: 0; flex-wrap: wrap; }
-.summary-grid article { display: flex; gap: var(--admin-space-3); padding: var(--admin-space-3) var(--admin-space-5); border: 0; border-radius: 0; background:var(--workbench-surface); flex: 1 1 200px; align-items: baseline; border-right: 1px solid var(--workbench-border); }
-.summary-grid article:last-child { border-right: 0; }
-.summary-grid strong { font-size: var(--admin-font-body); }
+.summary-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: var(--workbench-grid-gap); }
 
 </style>

src/modules/overseas-warehouse/pages/prototypeContract.test.ts

@@ -271,7 +271,8 @@ describe('overseas warehouse first-batch prototype contract', () => {
     expect(dialog).not.toContain('一次排车只能装同一客户')
     expect(dialog).not.toContain('ensureDraftToken')
     expect(dialog).not.toContain('preArrangeDispatch')
-    expect(dialog).toContain('原请求结果尚待核对')
+    expect(dialog).not.toContain('原请求结果尚待核对')
+    expect(dialog).not.toContain('sessionStorage.setItem')
     expect(dialog).not.toContain('v-model="route"')
     const vehicleSpecs = source('../dispatchVehicleSpecs.ts')
     expect(vehicleSpecs).toContain("label: '大车（30托）'")

src/modules/unified-orders/pages/UnifiedOrdersView.requests.test.ts

@@ -190,6 +190,28 @@ describe('UnifiedOrdersView list request coordination', () => {
     }
   })
 
+  it.each(['全部', '测量数据审核'])('keeps the %s tab bar mounted without a loading text row during query', async (label) => {
+    const wrapper = mountView()
+    await flushPromises()
+    if (label !== '全部') {
+      await wrapper.findAll('[role="tab"]').find(tab => tab.text() === label)!.trigger('click')
+      await flushPromises()
+    }
+    const tabList = wrapper.get('[role="tablist"]').element
+    let resolveCounts!: (value: { counts: {} }) => void
+    vi.mocked(getPlatformUnifiedOrderStatusCounts).mockImplementationOnce(() => new Promise(resolve => { resolveCounts = resolve }))
+    wrapper.getComponent({ name: 'QueryToolbar' }).vm.$emit('search')
+    await flushPromises()
+    expect(wrapper.get('[role="tablist"]').element).toBe(tabList)
+    expect(wrapper.get('[role="tablist"]').attributes('aria-busy')).toBe('true')
+    expect(wrapper.find('.order-status-feedback').exists()).toBe(false)
+    resolveCounts({ counts: {} })
+    await flushPromises()
+    expect(wrapper.get('[role="tablist"]').element).toBe(tabList)
+    expect(wrapper.get('[role="tablist"]').attributes('aria-busy')).toBe('false')
+    wrapper.unmount()
+  })
+
   it.each(['success', 'failure'] as const)('ignores an older tab request %s after the current tab has loaded', async (outcome) => {
     const wrapper = mountView()
     await flushPromises()

src/modules/unified-orders/pages/UnifiedOrdersView.test.ts

@@ -565,7 +565,7 @@ describe('UnifiedOrdersView contract', () => {
     expect(source).toContain('label="尺寸图片"')
     expect(source).toContain(':file-id="row.intelligentImageFileId"')
     expect(source).toContain('openMeasurementEvidence(row.intelligentImageFileId')
-    expect(source).toContain('v-for="weightResult in measurementDetail.weightResults"')
+    expect(source).toContain('<el-table :data="measurementDetail?.weightResults ?? []" row-key="id" border stripe empty-text="暂无称重图片与确认结果">')
     expect(source).toContain(':file-id="weightResult.fileId"')
     expect(source).toContain('openMeasurementEvidence(weightResult.fileId')
     expect(source).toContain('measurementDetail?.actualGrossWeightKg')

src/modules/unified-orders/pages/UnifiedOrdersView.vue

@@ -2732,30 +2732,37 @@ function orderDialogTitle(action: string, inboundCode?: string | null) {
                     </el-table>
                   </div>
                   <div class="measurement-total"><strong>合计</strong><span>箱数：{{ measurementTotals(actualMeasurementRows).count ?? '—' }}</span><span>总毛重：{{ formatNumber(measurementTotals(actualMeasurementRows).gross) }}</span><span>总体积：{{ formatMeasurementVolume(measurementTotals(actualMeasurementRows).volume) }}</span><span>总材积重：{{ formatNumber(measurementTotals(actualMeasurementRows).volumetric) }}</span><span>重量体积：{{ formatMeasurementVolume(measurementTotals(actualMeasurementRows).weightVolume) }}</span></div>
-                  <section class="weight-evidence" aria-label="称重图片与服务端确认重量">
-                    <div class="weight-evidence__heading">
-                      <div><h4>称重图片与确认重量</h4></div>
-                      <dl><dt>实际总毛重</dt><dd>{{ formatNumber(measurementDetail?.actualGrossWeightKg) }} kg</dd></dl>
+                  <section class="measurement-section" aria-label="称重图片与服务端确认重量">
+                    <div class="measurement-section-title"><h3>称重图片与确认重量</h3></div>
+                    <div class="detail-table-wrap">
+                      <el-table :data="measurementDetail?.weightResults ?? []" row-key="id" border stripe empty-text="暂无称重图片与确认结果">
+                        <el-table-column label="称重图片" width="148">
+                          <template #default="{ row: weightResult }">
+                            <MeasurementEvidenceThumbnail
+                              :customer-id="String(detail.summary.tenantId)"
+                              :inbound-id="String(detail.summary.inboundId)"
+                              :file-id="weightResult.fileId"
+                              :alt="`称重图片 · ${weightResult.palletType || '未记录类型'}`"
+                              empty-text="未绑定称重图片"
+                              @open="openMeasurementEvidence(weightResult.fileId, `称重图片 · ${weightResult.palletType || '未记录类型'}`)"
+                            />
+                          </template>
+                        </el-table-column>
+                        <el-table-column label="托盘类型" min-width="160">
+                          <template #default="{ row: weightResult }">{{ weightResult.palletType || '未记录类型' }}</template>
+                        </el-table-column>
+                        <el-table-column label="服务端确认毛重(kg)" min-width="180" align="right">
+                          <template #default="{ row: weightResult }">{{ formatNumber(weightResult.grossWeightKg) }}</template>
+                        </el-table-column>
+                        <el-table-column label="托盘皮重(kg)" min-width="140" align="right">
+                          <template #default="{ row: weightResult }">{{ formatNumber(weightResult.palletTareWeightKg) }}</template>
+                        </el-table-column>
+                        <el-table-column label="货物重量(kg)" min-width="140" align="right">
+                          <template #default="{ row: weightResult }">{{ formatNumber(weightResult.netWeightKg) }}</template>
+                        </el-table-column>
+                      </el-table>
                     </div>
-                    <div v-if="measurementDetail?.weightResults.length" class="weight-evidence-grid">
-                      <article v-for="weightResult in measurementDetail.weightResults" :key="weightResult.id" class="weight-evidence-card">
-                        <MeasurementEvidenceThumbnail
-                          :customer-id="String(detail.summary.tenantId)"
-                          :inbound-id="String(detail.summary.inboundId)"
-                          :file-id="weightResult.fileId"
-                          :alt="`称重结果 ${weightResult.id} 的称重图片`"
-                          empty-text="未绑定称重图片"
-                          @open="openMeasurementEvidence(weightResult.fileId, `称重图片 · ${weightResult.palletType || '未记录类型'}`)"
-                        />
-                        <dl>
-                          <div><dt>托盘类型</dt><dd>{{ weightResult.palletType || '未记录类型' }}</dd></div>
-                          <div><dt>服务端确认毛重</dt><dd>{{ formatNumber(weightResult.grossWeightKg) }} kg</dd></div>
-                          <div><dt>托盘皮重</dt><dd>{{ formatNumber(weightResult.palletTareWeightKg) }} kg</dd></div>
-                          <div><dt>货物重量</dt><dd>{{ formatNumber(weightResult.netWeightKg) }} kg</dd></div>
-                        </dl>
-                      </article>
-                    </div>
-                    <p v-else class="compact-empty">暂无称重图片与确认结果</p>
+                    <div class="measurement-total"><strong>合计</strong><span>实际总毛重：{{ formatNumber(measurementDetail?.actualGrossWeightKg) }} kg</span></div>
                   </section>
                 </div>
                </section>
@@ -2810,8 +2817,7 @@ function orderDialogTitle(action: string, inboundCode?: string | null) {
               @keydown="handleTabKeydown($event, index)"
             ><span>{{ tab.label }}</span><span v-if="tabCount(tab.value) !== undefined" class="order-status-count">（{{ tabCount(tab.value) }}）</span></button>
           </div>
-          <div v-if="statusCountsLoading" class="order-status-feedback" role="status">页签数量加载中…</div>
-          <div v-else-if="statusCountsError" class="order-status-feedback" role="status">
+          <div v-if="statusCountsError" class="order-status-feedback" role="status">
             <span>{{ statusCountsError.message }}</span>
             <el-button link type="primary" @click="loadStatusCounts">重试数量</el-button>
             <ApiErrorMeta :details="statusCountsError" />
@@ -2854,8 +2860,7 @@ function orderDialogTitle(action: string, inboundCode?: string | null) {
         ><span>{{ tab.label }}</span><span v-if="tabCount(tab.value) !== undefined" class="order-status-count">（{{ tabCount(tab.value) }}）</span></button>
       </div>
 
-          <div v-if="statusCountsLoading" class="order-status-feedback" role="status">页签数量加载中…</div>
-          <div v-else-if="statusCountsError" class="order-status-feedback" role="status">
+          <div v-if="statusCountsError" class="order-status-feedback" role="status">
             <span>{{ statusCountsError.message }}</span>
             <el-button link type="primary" @click="loadStatusCounts">重试数量</el-button>
             <ApiErrorMeta :details="statusCountsError" />
@@ -3264,19 +3269,6 @@ function orderDialogTitle(action: string, inboundCode?: string | null) {
 .measurement-total { display: flex; min-height: var(--admin-control-height, 32px); flex-wrap: wrap; align-items: center; justify-content: flex-end; gap: var(--admin-space-1, 4px) 20px; padding: var(--admin-space-2, 6px) var(--admin-space-4, 10px); border: 1px solid var(--workbench-border); border-top: 0; background: var(--admin-label-bg, #f8fafc); color: #475467; font-size: var(--admin-font-caption, 12px); font-variant-numeric: tabular-nums; }
 
 .measurement-total strong { margin-right: auto; color: var(--workbench-text); font-size: var(--admin-font-body, 13px); }
-.weight-evidence { margin-top: var(--admin-space-5, 12px); padding: var(--admin-space-4, 10px) 0 0; border-top: 1px solid var(--workbench-border); background: var(--admin-surface, #fff); }
-.weight-evidence__heading { display: flex; align-items: center; justify-content: space-between; gap: var(--admin-space-6, 16px); margin-bottom: var(--admin-space-3, 8px); }
-.weight-evidence__heading h4 { margin: 0; color: var(--workbench-text); font-size: var(--admin-font-section, 14px); }
-.weight-evidence__heading p { margin: 5px 0 0; color: var(--workbench-muted); font-size: var(--admin-font-caption, 12px); }
-.weight-evidence__heading dl { margin: 0; text-align: right; }
-.weight-evidence__heading dt { color: var(--workbench-muted); font-size: var(--admin-font-caption, 11px); }
-.weight-evidence__heading dd { margin: 0; color: var(--workbench-text); font-size: var(--admin-font-body, 13px); font-weight: 600; }
-.weight-evidence-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(280px, 1fr)); gap: var(--admin-space-3, 8px); }
-.weight-evidence-card { display: grid; grid-template-columns: 96px minmax(0, 1fr); align-items: center; min-width: 0; padding: var(--admin-space-3, 8px); border: 1px solid var(--workbench-border); background: var(--admin-surface, #fff); }
-.weight-evidence-card > dl { display: grid; gap: var(--admin-space-1, 4px); margin: 0; padding: 0 0 0 var(--admin-space-3, 8px); }
-.weight-evidence-card > dl > div { display: flex; min-width: 0; justify-content: space-between; gap: var(--admin-space-5, 12px); }
-.weight-evidence-card dt { color: var(--workbench-muted); font-size: var(--admin-font-caption, 11px); }
-.weight-evidence-card dd { min-width: 0; margin: 0; color: var(--workbench-text); font-size: var(--admin-font-caption, 12px); font-weight: 650; text-align: right; overflow-wrap: anywhere; }
 .measurement-original-preview { display: block; width: 100%; max-height: min(72vh, 760px); object-fit: contain; border-radius: 8px; background: #f2f4f7; }
 .hold-section { padding-bottom: var(--admin-space-5, 12px); border-bottom: 1px solid var(--workbench-border); }
 .other-notes-section { padding-top: var(--admin-space-4, 10px); }
@@ -3306,10 +3298,8 @@ function orderDialogTitle(action: string, inboundCode?: string | null) {
 .notes-list span { display: block; margin-top: 5px; color: var(--workbench-muted); font-size: var(--admin-font-caption, 12px); }
 @media (max-width: 960px) { .order-info-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); } .measurement-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); } }
 @media (max-width: 720px) { .page-intro { align-items: stretch; flex-direction: column; } .page-intro :deep(.el-button) { width: 100%; min-height: 44px; } .table-actions :deep(.el-button) { width: 100%; min-height: 40px; } .row-actions { flex-wrap: wrap; } .order-detail-header { align-items: stretch; flex-direction: column; } .order-detail-heading { flex-wrap: wrap; } .detail-header-actions { display: grid; grid-template-columns: 1fr; } .detail-header-actions :deep(.el-button) { min-height: 40px; } .order-info-grid, .measurement-grid { grid-template-columns: 1fr; } .order-info-grid > div.wide { grid-column: auto; } .detail-tabs button { padding: 0 18px; } .detail-panel { padding: 16px; } .measurement-section-title { align-items: flex-start; flex-wrap: wrap; padding: 12px; } .measurement-section-summary { width: 100%; flex-basis: calc(100% - 34px); flex-wrap: wrap; justify-content: flex-start; gap: 6px 16px; white-space: normal; } .measurement-section-title > svg { margin-left: auto; } .measurement-total { flex-wrap: wrap; justify-content: flex-start; gap: 6px 16px; } .measurement-total strong { width: 100%; } }
-@media (max-width: 720px) { .weight-evidence__heading { flex-direction: column; } .weight-evidence__heading dl { text-align: left; } }
 @media (max-width: 720px) { .fee-overview { grid-template-columns: 1fr; } .fee-overview > div + div { border-top: 1px solid var(--workbench-border); border-left: 0; } }
 @media (max-width: 720px) { .measurement-section-title { align-items: stretch; flex-direction: column; } .measurement-section-toggle { align-items: flex-start; flex-wrap: wrap; } .measurement-section-toggle > svg { margin-left: auto; } .measurement-section-mode { width: 100%; flex-basis: auto; } }
-@media (max-width: 420px) { .weight-evidence { padding: 10px; } .weight-evidence-grid { grid-template-columns: 1fr; } }
 </style>
 
 <style src="@/styles/adminDensity.css"></style>

src/styles/adminDensity.css

@@ -285,6 +285,11 @@
   --el-input-hover-border-color: var(--el-color-primary);
   --el-input-bg-color: var(--admin-surface);
 }
+:is(.admin-density, .admin-density-dialog) .density-form--outlined :is(.el-input, .el-textarea) {
+  --el-input-border-color: var(--el-border-color);
+  --el-input-hover-border-color: var(--el-border-color-hover);
+  --el-input-bg-color: var(--admin-surface);
+}
 :is(.admin-density, .admin-density-dialog) .density-table-editor { display: flex; align-items: center; gap: var(--admin-space-3); min-width: 0; }
 :is(.admin-density, .admin-density-dialog) .density-table-editor .el-input-number { flex: 1; width: 100%; min-width: 0; }
 :is(.admin-density, .admin-density-dialog) .density-table--editable .el-input__inner { text-align: left; }

src/styles/adminDensity.test.ts

@@ -288,6 +288,27 @@ describe('approved Admin density ownership', () => {
     expect(view.styles.map(style => style.content).join('\n')).not.toContain('--el-input-border-color')
   })
 
+  it('outlines opted-in customer forms without overriding native focus, validation or disabled styles', () => {
+    const rules = new Map<string, Record<string, string>>()
+    cssRoot(shared).walkRules(rule => {
+      const values: Record<string, string> = {}
+      rule.walkDecls(decl => { values[decl.prop] = decl.value })
+      rules.set(rule.selector, values)
+    })
+    expect(rules.get(':is(.admin-density, .admin-density-dialog) .density-form--outlined :is(.el-input, .el-textarea)')).toEqual({
+      '--el-input-border-color': 'var(--el-border-color)',
+      '--el-input-hover-border-color': 'var(--el-border-color-hover)',
+      '--el-input-bg-color': 'var(--admin-surface)',
+    })
+    const customerRules = new Map<string, Record<string, string>>()
+    cssRoot(read('modules/customers/customerDensity.css')).walkRules(rule => {
+      const values: Record<string, string> = {}
+      rule.walkDecls(decl => { values[decl.prop] = decl.value })
+      customerRules.set(rule.selector, values)
+    })
+    expect(customerRules.get('.customer-editor-dialog .density-form--outlined .el-input-number .el-input__inner')).toEqual({ 'text-align': 'left' })
+  })
+
   it('outlines only the three opted-in customer billing editors without overriding native focus or disabled styles', () => {
     const rules = new Map<string, Record<string, string>>()
     cssRoot(shared).walkRules(rule => {