test(admin): verify guidance on hover without inline expansion

AGENTS.md

@@ -36,61 +36,52 @@
 
 ## 模块快速路由
 
-表中 `modules/`、`core/`、`shared/`、`app/` 和 `main.ts` 均相对 `src/`；裸文件名沿用同一单元格最近目录。模块细节只在最近指引维护，应用层保留入口。
+按短表定位后按需查 [业务细则](docs/business-index.md)；涉及业务行为变更时必须核对对应细则及最近模块指引。从应用根执行 `rg -n -F '任务词或文件名' docs/business-index.md`，只读命中条款。
 
-| 业务 | Admin 入口 | 联查 |
-|---|---|---|
-| 登录、会话与统一 Token | `modules/auth/`、`core/auth/` | 国内 `auth/`、`iam/`；海外请求客户端再读 `shared/api/AGENTS.md` |
-| 启动与懒加载资源恢复 | `main.ts`、`core/routing/navigationRecovery.ts` | 仅识别动态模块/Chunk 资源过期；30 秒内同目标最多自动恢复一次，存在未保存编辑时必须先确认 |
-| 工作台与指标 | `modules/dashboard/` | 指标所属模块与服务端，不复制领域契约 |
-| 自营销量、库存与数据采集 | `modules/self-operated/AGENTS.md` | 三个入口 `/self-operated/sales`、`/self-operated/inventory`、`/self-operated/collection`；后端 `lastleg-service/selfoperated/analytics/`，正式合同见 `../../docs/自营业务/README.md`。 |
-| 船期日历 | `modules/sailing-calendar/` | 当前日历入口覆盖渠道、周模板、单次船期、收货截止时间和按渠道货量统计；后端按 `firstleg/` 船期接口定位，不读取已归档的货柜开发规划 |
-| 预约管理、预约列表、跨客户同仓预约 | `modules/appointment-calendar/`；入仓单预约沿 `modules/overseas-warehouse/` | 统一规则见 `../../docs/海外仓业务/README.md` 的预约送仓；同仓跨客户共用预约，客户归属在货物明细；到港只读 Firstleg，送仓归 Lastleg |
-| FBA 无匹配价格、人工定价 | `modules/inbounds/fee/api.ts` 的 `createManualInboundQuote`、`types.ts`；页面消费沿 `InboundFeePanel.vue` 核对 | `POST /manual-quote` 提交计费重量、体积、单价、原因和 `Idempotency-Key`；Backend `PlatformFbaPricingController.manualQuote` → `FbaPricingService.manualQuote`，权限 `firstleg:inbound:confirm-send-fee`。仅 FBA、已有实际测量且当前价格未命中时允许，客户已确认费用禁止改价；`MANUAL_QUOTE` 快照允许价格记录与版本为空，不伪造价格簿关联。API 回归 `modules/inbounds/fee/api.test.ts`，不能以 API 存在代替页面接入完成 |
-| PDA版本、APK下载、WGT热更新发布与停发 | `modules/pda-releases/pages/PdaReleasesView.vue`、`modules/pda-releases/api/pdaReleases.ts`、`modules/pda-releases/routes.ts` | 系统菜单 `/system/pda-releases`；列表权限 `platform:pda-release:list`，上传/发布/停发权限 `platform:pda-release:manage`。国内/海外按 `domestic/overseas` 分开查询，上传只创建草稿，发布与停发需确认；管理请求使用国内 HTTP 的 `/platform/v1/files/pda-releases`，后端见 `file/AGENTS.md`，设备安装与重启查对应 PDA 的更新工具 |
-| 客户、企业审核、客户统计 | `modules/customers/` | `iam/`、`auth/`、`file/`、`firstleg/customerstatistics/`；公司联系电话只作企业联系信息，不修改管理员/成员登录手机号且不要求跨企业唯一。审核必填资质仅营业执照与统一社会信用代码；法人身份证选填，可随资质包提交，也可在已有营业执照后单独补传或替换 |
-| 供应商、国内整柜 | `modules/suppliers/`、`modules/domestic-containers/` | Backend `warehouse/` 及对应 OpenAPI |
-| 平台仓库与仓储资源 | 仓库主档 `modules/warehouses/`，国内资源 `modules/warehouse-resources/` | 全部仓库 ID、类型、状态、地址和能力归国内 `warehouse/`；海外 `warehouse-overseas-service/` 只维护引用同一 warehouseId 的库位、托盘和锁 |
-| 平台用户、RBAC、导航 | `modules/iam/`、`core/access/`、`core/navigation/` | `auth/`、`iam/`、平台权限契约 |
-| 国内/海外 PDA 独立人员与海外仓绑定 | `modules/iam/pages/InternalUsersView.vue`、`modules/iam/api/platformIam.ts` | 国内 `CN_FIRSTLEG_PDA_OPERATOR` 与海外 `OVERSEAS_WAREHOUSE_PDA_OPERATOR` 互斥；只有海外角色必须且只能绑定一个 `overseasWarehouseId`，候选来自国内 Warehouse 平台仓库 API 的公共 `OVERSEAS + ACTIVE + RECEIVING` 收货仓 |
-| 消息中心 | `modules/notifications/` | Backend `iam/.../notification/`；仅顶部消息中心，不进入左侧菜单 |
-| 订单列表、批量审核预览、详情、商品图片与入库费用 | `modules/unified-orders/`、`modules/first-leg-orders/`；平台商品图片由 `modules/unified-orders/api/unifiedOrders.ts` 按客户与 fileId 下载 | `order/`、`firstleg/`、Finance；旧系统导入固定归属“IT测试公司”，前端不提交或选择客户，逐行结果展示入仓码与失败原因。图片读取归 `file/` 的 `PlatformProductImageController`。Order 状态为 `SUBMITTED` 时统一列表必须保持 `PENDING_REVIEW/APPROVE_ORDER`，不得被已存在的 Firstleg 准备中入库投影覆盖。批量审核弹框通过 `unifiedOrders.ts` 的 `/orders/first-leg/batch-review-preview` 一次取回全部预览，按服务端 `canApprove/blockReason` 展示，不逐票请求详情或用内部 ID 作标题 |
-| 客户原始申报资料编辑与渠道变更 | `modules/unified-orders/components/OrderDeclarationEditorDialog.vue`、`api/unifiedOrders.ts`、`pages/UnifiedOrdersView.vue` | 使用订单版本和货物 `itemNo` 整体提交，不允许增删货物行；只编辑客户申报快照，不覆盖仓库/PDA 实测、测量审核或计费事实。渠道变化需二次确认并由 Backend `order/` 联查 `firstleg/` 的分柜、同柜、装柜与重新计价门禁；国内收货仓或中转仓变化必须重新下单 |
-| 入库扣货、解除与凭证历史 | `modules/unified-orders/pages/UnifiedOrdersView.vue`、`modules/inbounds/core/api.ts`、`types.ts` | 页面只消费服务端 `holdFlag/currentHoldReason/canHold/canRelease/actionBlockReason/history`；扣货与解除提交当前入库版本、幂等键、必填原因和可选凭证，凭证下载只走 Firstleg 授权入口。Backend `firstleg/` 的 `InboundHoldService`、`InboundHoldGuard`、`InboundHoldEvidenceService`，文件归 `file/` |
-| 入库、测量、称重库位状态、客户箱规策略与计价主数据 | 测量弹框/工作区 `modules/inbounds/measurement/InboundMeasurementDialog.vue`、`InboundMeasurementPanel.vue`，称重 `modules/inbounds/weight/components/WeightOcrPanel.vue`；主数据 `modules/fba-pricing/`、`modules/dimension-config/`、`modules/customers/components/CustomerBillingRulesPanel.vue`、`modules/fee-items/` | 客户固定四档箱规，默认计算方式为 `ADD/MULTIPLY`；测量行可选实际尺寸、箱规尺寸策略或客户默认尺寸系数，保存后以 Backend `firstleg/` 返回的外箱尺寸、体积重和计费基数为准，不在页面独立重算。费用确认的实际箱数、毛重和体积优先汇总当前 `actualMeasurementRows`，不得用可能滞后的工作区顶层合计覆盖明细。称重页在每张图片卡片只展示服务端 `locationCode/slotStatus/sharedOverflow`，不渲染或自行推导整票预留引导；删除图片须提示槽位仍归本票保留，不得按图片数组下标推导托盘或库位 |
-| 一件代发托盘打印 | `modules/unified-orders/pages/UnifiedOrdersView.vue` 的“托盘打印”页签、`modules/inbounds/core/DropshipPalletPrintPanel.vue`、`core/api.ts` | 仅一件代发订单展示；测量审核预生成托盘码后由 Admin 电脑端打印，支持本票全部托盘合并打印和单托补打。PDA 只扫码组托，不承担 PDF 下载或打印机连接 |
-| 入库单扣货、解除、凭证与历史 | `modules/inbounds/pages/InboundOrdersView.vue`、详情工作区、`modules/inbounds/core/api.ts` | 列表展示服务端 `holdFlag/currentHoldReason` 并支持筛选；详情只按 `canHold/canRelease/actionBlockReason` 开放操作。扣货与解除提交当前 `version`、原因和独立幂等键，可选凭证先按明确客户与入库单上传；历史文件只调用专用下载入口，不把上传成功但未提交命令的文件冒充扣货证据 |
-| 客户专属价格簿、柜级阶梯运费与受控调价 | 列表/上传 `modules/fba-pricing/carrier-rates/pages/CarrierRatesView.vue`，版本详情/仓库映射/确认 `modules/fba-pricing/carrier-rates/pages/CarrierRateDetailView.vue`，路由 `modules/fba-pricing/routes.ts`；`modules/inbounds/fee/`、`modules/unified-orders/components/InboundFeeDetailManager.vue` | 列表与上传后按 `versionId` 进入 `fba-carrier-rate-detail` 独立详情页，价格行只读；回归入口 `modules/fba-pricing/carrier-rates/pages/CarrierRatesView.test.ts`。价格簿页面显式选择公共报价或具体客户；列表、上传、确认只作用于该 `customerId`，不得混合版本。计价优先消费客户专属 ACTIVE 版本，无专属版本才回退公共 ACTIVE；柜级阶梯金额和各客户分摊只展示服务端结果。调整计费量只能在服务端返回的上下 10% 范围内并提交当前费用版本、原因与二次确认；私人仓尾程派送费使用稳定 `PRIVATE_LAST_MILE_DELIVERY` 代码且只对 `PRIVATE` 目的地开放；一件代发须在预装确认前完成试算，计价后保持服务端 `WAIT_PALLETIZE` 状态 |
-| 财务、客户资金账户与柜级公共费用分摊 | `modules/finance/`，继续读该目录 `AGENTS.md`；客户账户 `pages/FinanceCustomerAccountsView.vue`，柜费 `modules/loading-lists/components/ContainerFeesPanel.vue`、`api/containerFees.ts` | `finance/`、`firstleg/`、`file/`、`docs/财务管理/`；实际、冻结、可用余额、授信与流水只消费 Finance 权威结果，充值审核和手工充扣携带版本与幂等键。跨客户公共柜费只按服务端柜内客户/订单事实分摊，金额必须守恒，创建与审核、驳回、调整、作废均整组原子处理 |
-| 货柜双工作台、排柜、预装/装柜清单、真实柜号后补与整柜报关 | 国内 `modules/container-loading/pages/DomesticContainersView.vue`、海外 `OverseasContainersView.vue`，共享详情实现 `ContainerDetailView.vue`；预装详情 `modules/loading-lists/pages/PreloadPlanDetailView.vue`，资料/PDA 证据 `components/ContainerOverviewPanel.vue`，报关 `components/ContainerCustomsPanel.vue` | 国内“送柜报关”只消费 `/containers/domestic` 与服务端 `allowedActions`，承载模拟柜、订舱关联、智能装柜；模拟柜创建选择与智能装柜一致的 9 类计划渠道，未关联订舱前实际渠道为空，订舱关联候选按计划渠道组匹配并同时展示订舱号与提单号、装柜清单页签、出口报关和国内出仓；创建柜次时自动生成唯一预装计划，预装详情先调用 `/loading-plans/{planId}/lifecycle`，完成后深链进入国内货柜详情的装柜清单页签，独立装柜清单导航 `/loading-lists` 复用已确认清单 API，查看进入独立详情路由 `/loading-lists/:planId`，保留返回列表和打印；独立清单详情与货柜清单页签共同使用 `useLoadingListDetail.ts` 加载、校验和处理错误，`LoadingListDetailDrawer.vue` 统一密度、摘要、明细、历史及打印入口，打印实现归 `printLoadingList.ts`，外层只保留返回目标与货柜专属 PDA/报关区域；货柜列表经 `ContainerWorkbenchView.vue` 在国内装柜与海外清关提柜之间按权限切换。订舱关联允许真实集装箱号为空，但确认预装和创建 PDA 任务前必须补齐；历史已建但缺号的任务仍可在预装详情首次补录，保存后恢复 PDA 可进入状态；全买单柜继续使用 `complete-all-buy`。海外“清关提柜”只消费 `/containers/overseas`，承载船节点、目的港清关、DO/PU、码头车队和还空；原预约/实际提柜展示位改为整柜预计/实际到仓，预计到仓在列表内人工快捷维护并经海外接口同步整柜尾程订单，实际到仓只读海外 PDA 首次开始收货时间。还空截止事实由服务端基于卸柜完成时间加 72 小时计算，前端不重算。两端统一使用 `containerBookingId`，列表范围由服务端 `scope=ACTIVE/HISTORY` 分页，禁止浏览器筛选或本地推导写资格。后端为 `LoadingListService`、`firstleg/customs/container/`、`firstleg/terminaldrayage/` 和 `lastleg-service/`，文件归 `file/` |
-| 合柜报关 / 同柜不可拆组 | `modules/unified-orders/api/coLoadGroups.ts`、`pages/UnifiedOrdersView.vue`；装柜消费 `modules/container-loading/pages/SmartLoadingWorkbenchView.vue` | 前端只提交订单 ID；Backend `firstleg/loading/coload/` 展开并冻结每票全部可用入仓片段。成员数是入仓片段数，不等于订单票数；只要求同国内仓、同渠道，允许跨客户及不同目的仓港；分配、移除、取消均整组处理 |
-| 全局智能装柜工作台、入仓码候选与箱数分配 | `modules/container-loading/components/SmartLoadingDialog.vue` 内嵌 `pages/GlobalSmartLoadingView.vue`，柜次页 `SmartLoadingWorkbenchView.vue`，以及 `smartLoadingChannelGroups.ts`、`smartLoadingItems.ts`、`api/platformContainerLoading.ts`；全局页当前不注册独立路由 | Backend `firstleg/` 的 `/inbound-candidates`、`/containers`、`/inbound-assignments`、`/plans/{planId}/pending-review-assignments`、`/group-assignments`、`/unpicked-items`。`orderStatuses` 最多四项且未传表示全部未完成状态；候选状态多选覆盖待审核、待测量、待分柜、装柜中，状态只用于筛选展示，按钮资格以服务端 `canAssign` 为准；待审核/待测量可提前占位但不得提前确认预装或启动 PDA。计划箱数编辑上限、已用和未用展示只消费服务端 `totalPackageCount/remainingPackageCount`，不得从候选页或本地规格重新拼算。人工加入允许跨渠道，智能推荐仍按柜次渠道。柜次容量和限重取服务端字段；同柜组作为单卡整组分页、分配和移除，任一成员已拣时整组保留 |
-| 国内货柜履约订舱资料、打印、关联候选与出仓前船期 | `modules/ocean-bookings/` 的 `components/OceanBookingDocumentsPanel.vue`、`OceanBookingPrintDialog.vue`，以及 `modules/container-loading/`、`modules/port-schedules/` | 订舱草稿按当前版本维护资料，放舱后资料与表单只读；打印对草稿与已放舱订舱均开放，按当前已保存资料生成，未填写字段显示“—”。`platformOceanBookings.ts` 的 `/link-candidates` 只消费服务端分页，`containerCount` 是柜型需求 `quantity` 总和；Backend `firstleg/oceanbooking/`、`file/`、`print/`、`firstleg/portschedule/` |
-| 订舱级拖车预约 | `modules/trucking/api/platformTrucking.ts` 的 `/candidates`、`components/TruckAppointmentForm.vue`、`pages/TruckAppointmentCreateView.vue`、`TruckAppointmentsView.vue` | 表单只选择服务端返回的 `RELEASED` 订舱与 `TRUCKING + truckingScope=DOMESTIC` 国内拖车供应商，不选择或提交客户、柜次、装柜计划或真实集装箱号；清关提柜固定选择 `OVERSEAS` 海外车队，类型在供应商主档单选维护；提单号和仓库由订舱冻结事实带入。一个订舱最多一张非终态拖车单，重复创建转入现有单继续编辑；PDA 完成不自动推进拖车。附件为平台作用域且不重复提单文件；Backend `TruckAppointmentService`、`truck-appointments-v1.yaml` |
-| 目的港码头拖车与还空预警 | 海外清关提柜工作台/详情 `modules/container-loading/pages/OverseasContainersView.vue`、`OverseasContainerDetailView.vue`，API `modules/container-loading/api/terminalDrayages.ts`、`containerArrivalTimes.ts` | 与订舱级拖车预约是不同生命周期；按 `containerBookingId` 读取服务端状态、`allowedActions` 和历史，不能复用订舱级拖车表单或自行推进状态。列表“预计到仓”列直接提供人工日期时间选择器，保存时通过 Lastleg 柜级版本和幂等键原子更新该柜全部尾程订单，已有入库计划后禁止修改；“实际到仓”只读 `ll_receiving_container_session.receiving_at`，即海外 PDA 首次开始收货时间。还空截止、超时天/小时只展示服务端基于权威卸柜完成时间加 72 小时计算的结果；Backend `firstleg/terminaldrayage/`、`lastleg-service/`，邮件记录通过 `terminalDrayages.ts` 查询与重试。 |
-| 历史报关协同与国内出仓 | `modules/customs/`、`modules/outbound-dispatch/` | `modules/customs/` 是历史报关案件/清单/代理提交与回执入口；装柜完成后的整柜退税/买单资料从货柜详情进入，不在旧模块复制；Backend `firstleg/outbound/dispatch/`、`firstleg/customs/`、`file/` |
-| 主数据、下载、退避任务重试、审计 | `modules/master-data/`、`modules/downloads/pages/DownloadCenterView.vue`、`modules/audit/` | File 导出任务返回 `attemptCount/maxAttempts/nextRetryAt`；仅失败或已进入自动退避的等待任务显示重试，等待任务重试用于立即执行当前投递，不创建新任务；联查 `warehouse/`、`file/`、`audit-service/` |
-| 海外接柜、入库、库存与库内服务 | `modules/overseas-warehouse/` | `gateway/`、`lastleg-service/`、`warehouse-overseas-service/`；与排车、出库、派送、异常退回和一件代发共同组成海外仓全流程 |
-| 海外采购、卡车、散板 | `modules/overseas-business/` | `gateway/`、`lastleg-service/` |
-| 海外仓业务合作仓与通用资料 | 合作仓 `modules/warehouses/`；报价/汇率/车辆 `modules/overseas-master-data/` | 国内 `warehouse/`、海外实际资源与服务 |
-| 海外仓业务国内出仓后船节点 | `modules/port-schedules/`、`modules/ocean-bookings/`、货柜详情 | `firstleg/portschedule/`、`integration-service/`；预计节点只展示不推进实际进度，手工实际节点必须严格向后追加并防重复，十节点标准见 `../../docs/海外仓业务/船节点标准化契约.md` |
-| 海外排车、出库与派送 | `modules/overseas-warehouse/AGENTS.md` | 按模块表定位排车、出库、派送页面及 API；履约边界在模块内维护 |
-| 海外异常退回与客户回访 | `modules/overseas-warehouse/AGENTS.md` | 派送异常退回区别于退货库存；页面、API 与原子推进约束见模块指引 |
+路径从应用根起算，`modules/`、`core/` 从 `src/` 起算；接口片段与符号沿同一行代码定位。
 
-全量验收按业务从 `../../docs/订单与客户/`、`入库测量与计费/`、`国内货柜履约/`、`财务管理/` 选择最小契约；海外跨模块流程或入口不明时读 `../../docs/海外仓业务/README.md`，已定位局部任务直接沿模块入口。进度、排期或验收状态问题再读取对应进度表和报告。
-
-散货托盘码打印：`modules/loading-lists/components/PalletLabelPrintDialog.vue`、`modules/loading-lists/api/platformLoadingLists.ts`，由货柜详情与装柜清单详情进入；先调用 `/pallet-labels/prepare` 获取服务端按 FBA 仓分组的冻结清单，再通过 `/pallet-labels/print` 下载 PDF。托盘码使用“真实柜号-FBA 地址内部编号-三位序号”，页面同时展示 FBA 仓码和内部编号；支持全部打印或按仓指定张数补打，一件代发托盘不在该清单，前端不生成或重新编号托盘码。
+| 业务 | 首个入口 |
+|---|---|
+| 登录、会话与统一 Token | `modules/auth/`、`core/auth/` |
+| 启动与懒加载资源恢复 | `src/main.ts`、`core/routing/navigationRecovery.ts` |
+| 工作台与指标 | `modules/dashboard/` |
+| 自营销量、库存与数据采集 | `modules/self-operated/AGENTS.md` |
+| 船期日历 | `modules/sailing-calendar/` |
+| 预约管理、预约列表、跨客户同仓预约 | `modules/appointment-calendar/`、`modules/overseas-warehouse/` |
+| FBA 无匹配价格、人工定价 | `modules/inbounds/fee/api.ts`、`createManualInboundQuote` |
+| PDA版本、APK下载、WGT热更新发布与停发 | `modules/pda-releases/pages/PdaReleasesView.vue`、`modules/pda-releases/api/pdaReleases.ts` |
+| 客户、企业审核、客户统计 | `modules/customers/` |
+| 供应商、国内整柜 | `modules/suppliers/`、`modules/domestic-containers/` |
+| 平台仓库与仓储资源 | `modules/warehouses/`、`modules/warehouse-resources/` |
+| 平台用户、RBAC、导航 | `modules/iam/`、`core/access/` |
+| 国内/海外 PDA 独立人员与海外仓绑定 | `modules/iam/pages/InternalUsersView.vue`、`modules/iam/api/platformIam.ts` |
+| 消息中心 | `modules/notifications/` |
+| 订单列表、批量审核预览、详情、商品图片与入库费用 | `modules/unified-orders/`、`modules/first-leg-orders/` |
+| 客户原始申报资料编辑与渠道变更 | `modules/unified-orders/components/OrderDeclarationEditorDialog.vue`、`modules/unified-orders/api/unifiedOrders.ts` |
+| 入库扣货、解除与凭证历史 | `modules/unified-orders/pages/UnifiedOrdersView.vue`、`modules/inbounds/core/api.ts` |
+| 入库、测量、称重库位状态、客户箱规策略与计价主数据 | `modules/inbounds/measurement/InboundMeasurementDialog.vue`、`modules/inbounds/measurement/InboundMeasurementPanel.vue` |
+| 一件代发托盘打印 | `modules/unified-orders/pages/UnifiedOrdersView.vue`、`modules/inbounds/core/DropshipPalletPrintPanel.vue` |
+| 入库单扣货、解除、凭证与历史 | `modules/inbounds/pages/InboundOrdersView.vue`、`modules/inbounds/core/api.ts` |
+| 客户专属价格簿、柜级阶梯运费与受控调价 | `modules/fba-pricing/carrier-rates/pages/CarrierRatesView.vue`、`modules/fba-pricing/carrier-rates/pages/CarrierRateDetailView.vue` |
+| 财务、客户资金账户与柜级公共费用分摊 | `modules/finance/AGENTS.md` |
+| 货柜双工作台、排柜、预装/装柜清单、真实柜号后补与整柜报关 | `modules/container-loading/pages/DomesticContainersView.vue`、`modules/container-loading/pages/OverseasContainersView.vue` |
+| 合柜报关 / 同柜不可拆组 | `modules/unified-orders/api/coLoadGroups.ts`、`modules/unified-orders/pages/UnifiedOrdersView.vue` |
+| 全局智能装柜工作台、入仓码候选与箱数分配 | `modules/container-loading/components/SmartLoadingDialog.vue`、`modules/container-loading/pages/GlobalSmartLoadingView.vue` |
+| 国内货柜履约订舱资料、打印、关联候选与出仓前船期 | `modules/ocean-bookings/`、`modules/ocean-bookings/components/OceanBookingDocumentsPanel.vue` |
+| 订舱级拖车预约 | `modules/trucking/api/platformTrucking.ts`、`/candidates` |
+| 目的港码头拖车与还空预警 | `modules/container-loading/pages/OverseasContainersView.vue`、`modules/container-loading/pages/OverseasContainerDetailView.vue` |
+| 历史报关协同与国内出仓 | `modules/customs/`、`modules/outbound-dispatch/` |
+| 主数据、下载、退避任务重试、审计 | `modules/master-data/`、`modules/downloads/pages/DownloadCenterView.vue` |
+| 海外接柜、入库、库存与库内服务 | `modules/overseas-warehouse/` |
+| 海外采购、卡车、散板 | `modules/overseas-business/` |
+| 海外仓业务合作仓与通用资料 | `modules/warehouses/`、`modules/overseas-master-data/` |
+| 海外仓业务国内出仓后船节点 | `modules/port-schedules/`、`modules/ocean-bookings/` |
+| 海外排车、出库与派送 | `modules/overseas-warehouse/AGENTS.md` |
+| 海外异常退回与客户回访 | `modules/overseas-warehouse/AGENTS.md` |
 
 ## 海外模块内部快速索引（海外仓全流程）
 
-- 海外仓的尾程订单控制与柜级入仓计划转换、退货库存、排车出库、异常回访：读取 `src/modules/overseas-warehouse/AGENTS.md`，字段与流程仅在该模块维护。
-
-| 关键词 | 页面/路由入口 | API 与联查 |
-|---|---|---|
-| 海外采购 | `modules/overseas-business/pages/PurchaseOrdersView.vue`、详情/编辑页 | `modules/overseas-business/api/platformOverseasBusiness.ts` 的 purchase 方法；Backend `lastleg-service/procurement/` |
-| 美国卡车、本土散板 | `modules/overseas-business/pages/TransportOrdersView.vue`、`TransportOrderFormView.vue` | 同一 API 的 us-truck/looseboard 方法；Backend `lastleg-service/trucking/`、`looseboard/` |
-| 海外报价、月度汇率、车辆 | `modules/overseas-master-data/pages/OverseasQuotesView.vue`、`ExchangeRatesView.vue`、`VehiclesView.vue` | `modules/overseas-master-data/api/overseasMasterData.ts`；Backend `lastleg-service/masterdata/` |
-| 司机档案、驾驶证、到期提醒与资格预览 | `modules/overseas-master-data/pages/DriversView.vue`、`DriverDetailView.vue`；最近指引 `modules/overseas-master-data/AGENTS.md` | `api/drivers.ts`；Backend `lastleg-service/fleet/driver/`、File `FLEET_DRIVER_LICENSE` |
+海外仓作业先读 `src/modules/overseas-warehouse/AGENTS.md`；采购、车队等页面/API 联查按需查 `docs/business-index.md` 同名节。
 
 ## 业务、安全与共享装配
 
@@ -127,7 +118,7 @@ pnpm typecheck
 pnpm build
 ```
 
-- 普通变更至少运行 `pnpm typecheck` 和受影响测试；交付前运行 `pnpm test` 与 `pnpm build`。当前没有 lint 脚本，不声称 lint 通过。
+- 源码、依赖或构建配置变更至少运行 `pnpm typecheck` 和受影响测试，交付前运行 `pnpm test` 与 `pnpm build`；不影响代码、契约或配置的纯文档/索引变更只检查路径、链接及索引合同。当前没有 lint 脚本，不声称 lint 通过。
 - 不手工修改 `dist/`、`node_modules/` 或生成声明；依赖变化同步 `package.json` 与锁文件。
 - 测试环境全量验收入口为 `../../baiyue-firstleg/scripts/admin-test-env-acceptance.mjs`，模块说明见同仓库 `scripts/admin-test-env-modules/README.md`；它会写入或停用测试数据，只有本轮明确授权才能运行。
 - `pnpm test/typecheck` 和本地回归脚本不代表真实服务验收完成；HTTP 验收后仍由人工完成页面和截图确认。

docs/business-index.md

@@ -0,0 +1,65 @@
+# Admin业务详细索引
+
+本文件保存当前页面/API 入口及业务规则，是[应用指引](../AGENTS.md)的按需补充。涉及字段、状态、权限、金额、资源或作业恢复时必须读取受影响条款，不作为普通定位任务的全文首读。
+
+正文代码路径以工作区 `apps/admin-web/` 应用根起算，源码包缩写与裸文件名沿对应条目的目录解释；明确标注“工作区”的路径从工作区根起算。Markdown 相对链接以本文件所在的 `docs/` 为起点。已知文件直接定位；行为变更同时核对最近模块指引及服务端合同。
+
+原条款在本文件维护，主 AGENTS 仅保留短入口和通用边界；不要将新业务细节复制回主指引。
+
+## 模块快速路由
+
+表中 `modules/`、`core/`、`shared/`、`app/` 和 `main.ts` 均相对 `src/`；裸文件名沿用同一单元格最近目录。模块细节只在最近指引维护，应用层保留入口。
+
+| 业务 | Admin 入口 | 联查 |
+|---|---|---|
+| 登录、会话与统一 Token | `modules/auth/`、`core/auth/` | 国内 `auth/`、`iam/`；海外请求客户端再读 `shared/api/AGENTS.md` |
+| 启动与懒加载资源恢复 | `main.ts`、`core/routing/navigationRecovery.ts` | 仅识别动态模块/Chunk 资源过期；30 秒内同目标最多自动恢复一次，存在未保存编辑时必须先确认 |
+| 工作台与指标 | `modules/dashboard/` | 指标所属模块与服务端，不复制领域契约 |
+| 自营销量、库存与数据采集 | `modules/self-operated/AGENTS.md` | 三个入口 `/self-operated/sales`、`/self-operated/inventory`、`/self-operated/collection`；后端 `lastleg-service/selfoperated/analytics/`，正式合同见 `../../docs/自营业务/README.md`。 |
+| 船期日历 | `modules/sailing-calendar/` | 当前日历入口覆盖渠道、周模板、单次船期、收货截止时间和按渠道货量统计；后端按 `firstleg/` 船期接口定位，不读取已归档的货柜开发规划 |
+| 预约管理、预约列表、跨客户同仓预约 | `modules/appointment-calendar/`；入仓单预约沿 `modules/overseas-warehouse/` | 统一规则见 `../../docs/海外仓业务/README.md` 的预约送仓；同仓跨客户共用预约，客户归属在货物明细；到港只读 Firstleg，送仓归 Lastleg |
+| FBA 无匹配价格、人工定价 | `modules/inbounds/fee/api.ts` 的 `createManualInboundQuote`、`types.ts`；页面消费沿 `InboundFeePanel.vue` 核对 | `POST /manual-quote` 提交计费重量、体积、单价、原因和 `Idempotency-Key`；Backend `PlatformFbaPricingController.manualQuote` → `FbaPricingService.manualQuote`，权限 `firstleg:inbound:confirm-send-fee`。仅 FBA、已有实际测量且当前价格未命中时允许，客户已确认费用禁止改价；`MANUAL_QUOTE` 快照允许价格记录与版本为空，不伪造价格簿关联。API 回归 `modules/inbounds/fee/api.test.ts`，不能以 API 存在代替页面接入完成 |
+| PDA版本、APK下载、WGT热更新发布与停发 | `modules/pda-releases/pages/PdaReleasesView.vue`、`modules/pda-releases/api/pdaReleases.ts`、`modules/pda-releases/routes.ts` | 系统菜单 `/system/pda-releases`；列表权限 `platform:pda-release:list`，上传/发布/停发权限 `platform:pda-release:manage`。国内/海外按 `domestic/overseas` 分开查询，上传只创建草稿，发布与停发需确认；管理请求使用国内 HTTP 的 `/platform/v1/files/pda-releases`，后端见 `file/AGENTS.md`，设备安装与重启查对应 PDA 的更新工具 |
+| 客户、企业审核、客户统计 | `modules/customers/` | `iam/`、`auth/`、`file/`、`firstleg/customerstatistics/`；公司联系电话只作企业联系信息，不修改管理员/成员登录手机号且不要求跨企业唯一。审核必填资质仅营业执照与统一社会信用代码；法人身份证选填，可随资质包提交，也可在已有营业执照后单独补传或替换 |
+| 供应商、国内整柜 | `modules/suppliers/`、`modules/domestic-containers/` | Backend `warehouse/` 及对应 OpenAPI |
+| 平台仓库与仓储资源 | 仓库主档 `modules/warehouses/`，国内资源 `modules/warehouse-resources/` | 全部仓库 ID、类型、状态、地址和能力归国内 `warehouse/`；海外 `warehouse-overseas-service/` 只维护引用同一 warehouseId 的库位、托盘和锁 |
+| 平台用户、RBAC、导航 | `modules/iam/`、`core/access/`、`core/navigation/` | `auth/`、`iam/`、平台权限契约 |
+| 国内/海外 PDA 独立人员与海外仓绑定 | `modules/iam/pages/InternalUsersView.vue`、`modules/iam/api/platformIam.ts` | 国内 `CN_FIRSTLEG_PDA_OPERATOR` 与海外 `OVERSEAS_WAREHOUSE_PDA_OPERATOR` 互斥；只有海外角色必须且只能绑定一个 `overseasWarehouseId`，候选来自国内 Warehouse 平台仓库 API 的公共 `OVERSEAS + ACTIVE + RECEIVING` 收货仓 |
+| 消息中心 | `modules/notifications/` | Backend `iam/.../notification/`；仅顶部消息中心，不进入左侧菜单 |
+| 订单列表、批量审核预览、详情、商品图片与入库费用 | `modules/unified-orders/`、`modules/first-leg-orders/`；平台商品图片由 `modules/unified-orders/api/unifiedOrders.ts` 按客户与 fileId 下载 | `order/`、`firstleg/`、Finance；旧系统导入固定归属“IT测试公司”，前端不提交或选择客户，逐行结果展示入仓码与失败原因。图片读取归 `file/` 的 `PlatformProductImageController`。Order 状态为 `SUBMITTED` 时统一列表必须保持 `PENDING_REVIEW/APPROVE_ORDER`，不得被已存在的 Firstleg 准备中入库投影覆盖。批量审核弹框通过 `unifiedOrders.ts` 的 `/orders/first-leg/batch-review-preview` 一次取回全部预览，按服务端 `canApprove/blockReason` 展示，不逐票请求详情或用内部 ID 作标题 |
+| 客户原始申报资料编辑与渠道变更 | `modules/unified-orders/components/OrderDeclarationEditorDialog.vue`、`api/unifiedOrders.ts`、`pages/UnifiedOrdersView.vue` | 使用订单版本和货物 `itemNo` 整体提交，不允许增删货物行；只编辑客户申报快照，不覆盖仓库/PDA 实测、测量审核或计费事实。渠道变化需二次确认并由 Backend `order/` 联查 `firstleg/` 的分柜、同柜、装柜与重新计价门禁；国内收货仓或中转仓变化必须重新下单 |
+| 入库扣货、解除与凭证历史 | `modules/unified-orders/pages/UnifiedOrdersView.vue`、`modules/inbounds/core/api.ts`、`types.ts` | 页面只消费服务端 `holdFlag/currentHoldReason/canHold/canRelease/actionBlockReason/history`；扣货与解除提交当前入库版本、幂等键、必填原因和可选凭证，凭证下载只走 Firstleg 授权入口。Backend `firstleg/` 的 `InboundHoldService`、`InboundHoldGuard`、`InboundHoldEvidenceService`，文件归 `file/` |
+| 入库、测量、称重库位状态、客户箱规策略与计价主数据 | 测量弹框/工作区 `modules/inbounds/measurement/InboundMeasurementDialog.vue`、`InboundMeasurementPanel.vue`，称重 `modules/inbounds/weight/components/WeightOcrPanel.vue`；主数据 `modules/fba-pricing/`、`modules/dimension-config/`、`modules/customers/components/CustomerBillingRulesPanel.vue`、`modules/fee-items/` | 客户固定四档箱规，默认计算方式为 `ADD/MULTIPLY`；测量行可选实际尺寸、箱规尺寸策略或客户默认尺寸系数，保存后以 Backend `firstleg/` 返回的外箱尺寸、体积重和计费基数为准，不在页面独立重算。费用确认的实际箱数、毛重和体积优先汇总当前 `actualMeasurementRows`，不得用可能滞后的工作区顶层合计覆盖明细。称重页在每张图片卡片只展示服务端 `locationCode/slotStatus/sharedOverflow`，不渲染或自行推导整票预留引导；删除图片须提示槽位仍归本票保留，不得按图片数组下标推导托盘或库位 |
+| 一件代发托盘打印 | `modules/unified-orders/pages/UnifiedOrdersView.vue` 的“托盘打印”页签、`modules/inbounds/core/DropshipPalletPrintPanel.vue`、`core/api.ts` | 仅一件代发订单展示；测量审核预生成托盘码后由 Admin 电脑端打印，支持本票全部托盘合并打印和单托补打。PDA 只扫码组托，不承担 PDF 下载或打印机连接 |
+| 入库单扣货、解除、凭证与历史 | `modules/inbounds/pages/InboundOrdersView.vue`、详情工作区、`modules/inbounds/core/api.ts` | 列表展示服务端 `holdFlag/currentHoldReason` 并支持筛选；详情只按 `canHold/canRelease/actionBlockReason` 开放操作。扣货与解除提交当前 `version`、原因和独立幂等键，可选凭证先按明确客户与入库单上传；历史文件只调用专用下载入口，不把上传成功但未提交命令的文件冒充扣货证据 |
+| 客户专属价格簿、柜级阶梯运费与受控调价 | 列表/上传 `modules/fba-pricing/carrier-rates/pages/CarrierRatesView.vue`，版本详情/仓库映射/确认 `modules/fba-pricing/carrier-rates/pages/CarrierRateDetailView.vue`，路由 `modules/fba-pricing/routes.ts`；`modules/inbounds/fee/`、`modules/unified-orders/components/InboundFeeDetailManager.vue` | 列表与上传后按 `versionId` 进入 `fba-carrier-rate-detail` 独立详情页，价格行只读；回归入口 `modules/fba-pricing/carrier-rates/pages/CarrierRatesView.test.ts`。价格簿页面显式选择公共报价或具体客户；列表、上传、确认只作用于该 `customerId`，不得混合版本。计价优先消费客户专属 ACTIVE 版本，无专属版本才回退公共 ACTIVE；柜级阶梯金额和各客户分摊只展示服务端结果。调整计费量只能在服务端返回的上下 10% 范围内并提交当前费用版本、原因与二次确认；私人仓尾程派送费使用稳定 `PRIVATE_LAST_MILE_DELIVERY` 代码且只对 `PRIVATE` 目的地开放；一件代发须在预装确认前完成试算，计价后保持服务端 `WAIT_PALLETIZE` 状态 |
+| 财务、客户资金账户与柜级公共费用分摊 | `modules/finance/`，继续读该目录 `AGENTS.md`；客户账户 `pages/FinanceCustomerAccountsView.vue`，柜费 `modules/loading-lists/components/ContainerFeesPanel.vue`、`api/containerFees.ts` | `finance/`、`firstleg/`、`file/`、`docs/财务管理/`；实际、冻结、可用余额、授信与流水只消费 Finance 权威结果，充值审核和手工充扣携带版本与幂等键。跨客户公共柜费只按服务端柜内客户/订单事实分摊，金额必须守恒，创建与审核、驳回、调整、作废均整组原子处理 |
+| 货柜双工作台、排柜、预装/装柜清单、真实柜号后补与整柜报关 | 国内 `modules/container-loading/pages/DomesticContainersView.vue`、海外 `OverseasContainersView.vue`，共享详情实现 `ContainerDetailView.vue`；预装详情 `modules/loading-lists/pages/PreloadPlanDetailView.vue`，资料/PDA 证据 `components/ContainerOverviewPanel.vue`，报关 `components/ContainerCustomsPanel.vue` | 国内“送柜报关”只消费 `/containers/domestic` 与服务端 `allowedActions`，承载模拟柜、订舱关联、智能装柜；模拟柜创建选择与智能装柜一致的 9 类计划渠道，未关联订舱前实际渠道为空，订舱关联候选按计划渠道组匹配并同时展示订舱号与提单号、装柜清单页签、出口报关和国内出仓；创建柜次时自动生成唯一预装计划，预装详情先调用 `/loading-plans/{planId}/lifecycle`，完成后深链进入国内货柜详情的装柜清单页签，独立装柜清单导航 `/loading-lists` 复用已确认清单 API，查看进入独立详情路由 `/loading-lists/:planId`，保留返回列表和打印；独立清单详情与货柜清单页签共同使用 `useLoadingListDetail.ts` 加载、校验和处理错误，`LoadingListDetailDrawer.vue` 统一密度、摘要、明细、历史及打印入口，打印实现归 `printLoadingList.ts`，外层只保留返回目标与货柜专属 PDA/报关区域；货柜列表经 `ContainerWorkbenchView.vue` 在国内装柜与海外清关提柜之间按权限切换。订舱关联允许真实集装箱号为空，但确认预装和创建 PDA 任务前必须补齐；历史已建但缺号的任务仍可在预装详情首次补录，保存后恢复 PDA 可进入状态；全买单柜继续使用 `complete-all-buy`。海外“清关提柜”只消费 `/containers/overseas`，承载船节点、目的港清关、DO/PU、码头车队和还空；原预约/实际提柜展示位改为整柜预计/实际到仓，预计到仓在列表内人工快捷维护并经海外接口同步整柜尾程订单，实际到仓只读海外 PDA 首次开始收货时间。还空截止事实由服务端基于卸柜完成时间加 72 小时计算，前端不重算。两端统一使用 `containerBookingId`，列表范围由服务端 `scope=ACTIVE/HISTORY` 分页，禁止浏览器筛选或本地推导写资格。后端为 `LoadingListService`、`firstleg/customs/container/`、`firstleg/terminaldrayage/` 和 `lastleg-service/`，文件归 `file/` |
+| 合柜报关 / 同柜不可拆组 | `modules/unified-orders/api/coLoadGroups.ts`、`pages/UnifiedOrdersView.vue`；装柜消费 `modules/container-loading/pages/SmartLoadingWorkbenchView.vue` | 前端只提交订单 ID；Backend `firstleg/loading/coload/` 展开并冻结每票全部可用入仓片段。成员数是入仓片段数，不等于订单票数；只要求同国内仓、同渠道，允许跨客户及不同目的仓港；分配、移除、取消均整组处理 |
+| 全局智能装柜工作台、入仓码候选与箱数分配 | `modules/container-loading/components/SmartLoadingDialog.vue` 内嵌 `pages/GlobalSmartLoadingView.vue`，柜次页 `SmartLoadingWorkbenchView.vue`，以及 `smartLoadingChannelGroups.ts`、`smartLoadingItems.ts`、`api/platformContainerLoading.ts`；全局页当前不注册独立路由 | Backend `firstleg/` 的 `/inbound-candidates`、`/containers`、`/inbound-assignments`、`/plans/{planId}/pending-review-assignments`、`/group-assignments`、`/unpicked-items`。`orderStatuses` 最多四项且未传表示全部未完成状态；候选状态多选覆盖待审核、待测量、待分柜、装柜中，状态只用于筛选展示，按钮资格以服务端 `canAssign` 为准；待审核/待测量可提前占位但不得提前确认预装或启动 PDA。计划箱数编辑上限、已用和未用展示只消费服务端 `totalPackageCount/remainingPackageCount`，不得从候选页或本地规格重新拼算。人工加入允许跨渠道，智能推荐仍按柜次渠道。柜次容量和限重取服务端字段；同柜组作为单卡整组分页、分配和移除，任一成员已拣时整组保留 |
+| 国内货柜履约订舱资料、打印、关联候选与出仓前船期 | `modules/ocean-bookings/` 的 `components/OceanBookingDocumentsPanel.vue`、`OceanBookingPrintDialog.vue`，以及 `modules/container-loading/`、`modules/port-schedules/` | 订舱草稿按当前版本维护资料，放舱后资料与表单只读；打印对草稿与已放舱订舱均开放，按当前已保存资料生成，未填写字段显示“—”。`platformOceanBookings.ts` 的 `/link-candidates` 只消费服务端分页，`containerCount` 是柜型需求 `quantity` 总和；Backend `firstleg/oceanbooking/`、`file/`、`print/`、`firstleg/portschedule/` |
+| 订舱级拖车预约 | `modules/trucking/api/platformTrucking.ts` 的 `/candidates`、`components/TruckAppointmentForm.vue`、`pages/TruckAppointmentCreateView.vue`、`TruckAppointmentsView.vue` | 表单只选择服务端返回的 `RELEASED` 订舱与 `TRUCKING + truckingScope=DOMESTIC` 国内拖车供应商，不选择或提交客户、柜次、装柜计划或真实集装箱号；清关提柜固定选择 `OVERSEAS` 海外车队，类型在供应商主档单选维护；提单号和仓库由订舱冻结事实带入。一个订舱最多一张非终态拖车单，重复创建转入现有单继续编辑；PDA 完成不自动推进拖车。附件为平台作用域且不重复提单文件；Backend `TruckAppointmentService`、`truck-appointments-v1.yaml` |
+| 目的港码头拖车与还空预警 | 海外清关提柜工作台/详情 `modules/container-loading/pages/OverseasContainersView.vue`、`OverseasContainerDetailView.vue`，API `modules/container-loading/api/terminalDrayages.ts`、`containerArrivalTimes.ts` | 与订舱级拖车预约是不同生命周期；按 `containerBookingId` 读取服务端状态、`allowedActions` 和历史，不能复用订舱级拖车表单或自行推进状态。列表“预计到仓”列直接提供人工日期时间选择器，保存时通过 Lastleg 柜级版本和幂等键原子更新该柜全部尾程订单，已有入库计划后禁止修改；“实际到仓”只读 `ll_receiving_container_session.receiving_at`，即海外 PDA 首次开始收货时间。还空截止、超时天/小时只展示服务端基于权威卸柜完成时间加 72 小时计算的结果；Backend `firstleg/terminaldrayage/`、`lastleg-service/`，邮件记录通过 `terminalDrayages.ts` 查询与重试。 |
+| 历史报关协同与国内出仓 | `modules/customs/`、`modules/outbound-dispatch/` | `modules/customs/` 是历史报关案件/清单/代理提交与回执入口；装柜完成后的整柜退税/买单资料从货柜详情进入，不在旧模块复制；Backend `firstleg/outbound/dispatch/`、`firstleg/customs/`、`file/` |
+| 主数据、下载、退避任务重试、审计 | `modules/master-data/`、`modules/downloads/pages/DownloadCenterView.vue`、`modules/audit/` | File 导出任务返回 `attemptCount/maxAttempts/nextRetryAt`；仅失败或已进入自动退避的等待任务显示重试，等待任务重试用于立即执行当前投递，不创建新任务；联查 `warehouse/`、`file/`、`audit-service/` |
+| 海外接柜、入库、库存与库内服务 | `modules/overseas-warehouse/` | `gateway/`、`lastleg-service/`、`warehouse-overseas-service/`；与排车、出库、派送、异常退回和一件代发共同组成海外仓全流程 |
+| 海外采购、卡车、散板 | `modules/overseas-business/` | `gateway/`、`lastleg-service/` |
+| 海外仓业务合作仓与通用资料 | 合作仓 `modules/warehouses/`；报价/汇率/车辆 `modules/overseas-master-data/` | 国内 `warehouse/`、海外实际资源与服务 |
+| 海外仓业务国内出仓后船节点 | `modules/port-schedules/`、`modules/ocean-bookings/`、货柜详情 | `firstleg/portschedule/`、`integration-service/`；预计节点只展示不推进实际进度，手工实际节点必须严格向后追加并防重复，十节点标准见 `../../docs/海外仓业务/船节点标准化契约.md` |
+| 海外排车、出库与派送 | `modules/overseas-warehouse/AGENTS.md` | 按模块表定位排车、出库、派送页面及 API；履约边界在模块内维护 |
+| 海外异常退回与客户回访 | `modules/overseas-warehouse/AGENTS.md` | 派送异常退回区别于退货库存；页面、API 与原子推进约束见模块指引 |
+
+全量验收按业务从 `../../docs/订单与客户/`、`入库测量与计费/`、`国内货柜履约/`、`财务管理/` 选择最小契约；海外跨模块流程或入口不明时读 `../../docs/海外仓业务/README.md`，已定位局部任务直接沿模块入口。进度、排期或验收状态问题再读取对应进度表和报告。
+
+散货托盘码打印：`modules/loading-lists/components/PalletLabelPrintDialog.vue`、`modules/loading-lists/api/platformLoadingLists.ts`，由货柜详情与装柜清单详情进入；先调用 `/pallet-labels/prepare` 获取服务端按 FBA 仓分组的冻结清单，再通过 `/pallet-labels/print` 下载 PDF。托盘码使用“真实柜号-FBA 地址内部编号-三位序号”，页面同时展示 FBA 仓码和内部编号；支持全部打印或按仓指定张数补打，一件代发托盘不在该清单，前端不生成或重新编号托盘码。
+
+## 海外模块内部快速索引（海外仓全流程）
+
+- 海外仓的尾程订单控制与柜级入仓计划转换、退货库存、排车出库、异常回访：读取 `src/modules/overseas-warehouse/AGENTS.md`，字段与流程仅在该模块维护。
+
+| 关键词 | 页面/路由入口 | API 与联查 |
+|---|---|---|
+| 海外采购 | `modules/overseas-business/pages/PurchaseOrdersView.vue`、详情/编辑页 | `modules/overseas-business/api/platformOverseasBusiness.ts` 的 purchase 方法；Backend `lastleg-service/procurement/` |
+| 美国卡车、本土散板 | `modules/overseas-business/pages/TransportOrdersView.vue`、`TransportOrderFormView.vue` | 同一 API 的 us-truck/looseboard 方法；Backend `lastleg-service/trucking/`、`looseboard/` |
+| 海外报价、月度汇率、车辆 | `modules/overseas-master-data/pages/OverseasQuotesView.vue`、`ExchangeRatesView.vue`、`VehiclesView.vue` | `modules/overseas-master-data/api/overseasMasterData.ts`；Backend `lastleg-service/masterdata/` |
+| 司机档案、驾驶证、到期提醒与资格预览 | `modules/overseas-master-data/pages/DriversView.vue`、`DriverDetailView.vue`；最近指引 `modules/overseas-master-data/AGENTS.md` | `api/drivers.ts`；Backend `lastleg-service/fleet/driver/`、File `FLEET_DRIVER_LICENSE` |

src/core/navigation/adminNavigation.test.ts

@@ -31,12 +31,12 @@ describe('adminNavigation', () => {
       { title: '货柜管理', children: ['订舱列表', '拖车列表', '货柜列表', '装柜清单', '预装清单'] },
        { title: '海外尾程', children: ['尾程订单', '入库单', '废弃单', '出库单', '换标单', '派送单', '托盘管理', '库位管理', '库存管理', '退货库存管理', '退货箱号管理'] },
       { title: '预约管理', children: ['预约列表'] },
-      { title: '车辆管理', children: ['排车列表', '车辆列表', '司机管理', '车次管理', '拼车接货', '出车记录'] },
-      { title: '海外业务', children: ['采购订单', '本土卡车', '本土散板'] },
+      { title: '车辆管理', children: ['排车列表', '车辆列表', '司机管理', '出车记录'] },
+      { title: '海外业务', children: ['采购订单', '本土卡车', '本土散板', '散板需求'] },
       { title: '客户服务', children: ['异常订单'] },
       { title: '财务管理', children: ['客户账户', '客户应收应付', '应收款统计表', '客户对账单', '结算单应收', '结算单应付'] },
       { title: '海外仓', children: ['经营总览', '销量分析', '库存分析', '数据采集'] },
-      { title: '通用', children: ['费用项目', '汇率管理', '仓库管理', '海外仓报价', '车队报价', '船期价格表', '下载中心'] },
+      { title: '通用', children: ['费用项目', '汇率管理', '仓库管理', '海外仓报价', '车队报价', '船期价格表', '下载中心', '供应商列表'] },
       { title: '系统管理', children: ['用户管理', '角色权限', '菜单权限'] },
     ])
     expect(visible).toHaveLength(13)
@@ -196,13 +196,15 @@ describe('adminNavigation', () => {
     expect(getNavigationLeaves(filtered).map((item) => item.path)).toEqual(['/dashboard', '/master-data/fee-items'])
   })
 
-  it('retains the supplier route permission while omitting its entry from the latest sidebar', () => {
+  it('shows the restored supplier entry under general only with its list permission', () => {
     const visible = filterAdminNavigation(adminNavigation, new Set(['platform:supplier:list']))
     const missing = filterAdminNavigation(adminNavigation, new Set())
 
     expect(getNavigationLeaves(adminNavigation).find(item => item.path === '/suppliers')?.permission).toBe('platform:supplier:list')
-    expect(getNavigationLeaves(visible).map((item) => item.path)).toEqual(['/dashboard'])
+    expect(getNavigationLeaves(visible).map((item) => item.path)).toEqual(['/dashboard', '/suppliers'])
+    expect(visible.find(item => item.title === '通用')?.children?.map(item => item.path)).toEqual(['/suppliers'])
     expect(getNavigationLeaves(missing).map((item) => item.path)).toEqual(['/dashboard'])
+    expect(getNavigationLeaves(filterAdminNavigation(adminNavigation, new Set(['platform:supplier:create', 'platform:supplier:edit']))).map(item => item.path)).toEqual(['/dashboard'])
   })
 
   it('shows split container workbenches without a standalone smart-loading menu', () => {

src/core/navigation/adminNavigation.ts

@@ -134,8 +134,7 @@ export const adminNavigation: AdminNavigationNode[] = [
       { key: 'fba-dispatch', title: '排车列表', icon: Truck, path: '/overseas-warehouse/dispatches', permission: 'platform:overseas-warehouse:dispatch:list' },
       { key: 'vehicle-list', title: '车辆列表', icon: Truck, path: '/overseas-master-data/vehicles', permission: 'platform:overseas-master-data:vehicle:list' },
       { key: 'driver-management', title: '司机管理', icon: ContactRound, path: '/overseas-master-data/drivers', permission: 'platform:overseas-master-data:driver:list' },
-      { key: 'fleet-trips', title: '车次管理', icon: Truck, path: '/overseas-master-data/trips', permission: 'platform:fleet:trip:list' },
-      { key: 'fleet-capacity-offers', title: '拼车接货', icon: Truck, path: '/overseas-master-data/capacity-offers', permission: 'platform:fleet:capacity-offer:list', permissionAnyOf: ['platform:fleet:capacity-offer:manage'] },
+      { key: 'fleet-trips', title: '车次管理', icon: Truck, path: '/overseas-master-data/trips', permission: 'platform:fleet:trip:list', hidden: true },
       { key: 'fleet-operations', title: '出车记录', icon: Truck, path: '/overseas-master-data/trip-operations', permission: 'platform:fleet:operations:list' },
     ],
   },
@@ -147,6 +146,7 @@ export const adminNavigation: AdminNavigationNode[] = [
       { key: 'overseas-purchase', title: '采购订单', icon: ClipboardList, path: '/overseas-business/purchases', permission: 'platform:overseas-business:purchase:list' },
       { key: 'overseas-truck', title: '本土卡车', icon: Truck, path: '/overseas-business/trucks', permission: 'platform:overseas-business:truck:list' },
       { key: 'overseas-looseboard', title: '本土散板', icon: ClipboardList, path: '/overseas-business/looseboards', permission: 'platform:overseas-business:looseboard:list' },
+      { key: 'fleet-capacity-offers', title: '散板需求', icon: Truck, path: '/overseas-master-data/capacity-offers', permission: 'platform:fleet:capacity-offer:list', permissionAnyOf: ['platform:fleet:capacity-offer:manage'] },
     ],
   },
   {
@@ -204,7 +204,7 @@ export const adminNavigation: AdminNavigationNode[] = [
       { key: 'fleet-quotes', title: '车队报价', icon: Truck, path: '/overseas-master-data/fleet-quotes', permission: 'platform:fleet:quote:list' },
       { key: 'fba-carrier-rates', title: '船期价格表', icon: CircleDollarSign, path: '/first-leg-pricing/carrier-rates', permission: 'firstleg:fba-pricing:rate:view' },
       { key: 'download-center', title: '下载中心', icon: Download, path: '/downloads', permission: 'platform:download:list' },
-      { key: 'supplier-list', title: '供应商列表', icon: ContactRound, path: '/suppliers', permission: 'platform:supplier:list', hidden: true },
+      { key: 'supplier-list', title: '供应商列表', icon: ContactRound, path: '/suppliers', permission: 'platform:supplier:list' },
       { key: 'express-companies', title: '快递公司', icon: Truck, path: '/master-data/express-companies', permission: 'platform:express:list', hidden: true },
       { key: 'counterparties', title: '往来单位', icon: ContactRound, path: '/master-data/counterparties', permission: 'platform:counterparty:list', hidden: true },
       { key: 'mojia-sku-sync', title: '称重机器', icon: Database, path: '/general/mojia-sku-sync', permission: 'platform:mojia-sku-sync:list', hidden: true },

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

@@ -13,7 +13,9 @@ describe('four-type appointment calendar', () => {
     expect(wrapper.get('[aria-label="安排类型"]').text()).toBe('到港排车还柜计划到仓')
     expect(wrapper.findAll('.detail-event')).toHaveLength(4)
     expect(wrapper.get('[aria-label="当天安排"] header').text()).toContain('4 项安排')
-    expect(wrapper.findAll('.calendar-day')).toHaveLength(42)
+    expect(wrapper.findAll('.calendar-day')).toHaveLength(35)
+    expect(wrapper.find('[data-date="2026-11-01"]').exists()).toBe(true)
+    expect(wrapper.find('[data-date="2026-11-02"]').exists()).toBe(false)
     expect(wrapper.text()).not.toMatch(/新增预约|全局待办|需复核|中转|直送/)
   })
   it('filters locally without requesting another range', async () => {
@@ -24,6 +26,15 @@ describe('four-type appointment calendar', () => {
     expect(wrapper.text()).toContain('当天暂无安排')
     expect(wrapper.emitted('range')).toBeUndefined()
   })
+  it('offers creation in the header only when authorized', async () => {
+    const wrapper = render()
+    expect(wrapper.findAll('button').some(button => button.text() === '新增预约')).toBe(false)
+    await wrapper.setProps({ canCreate: true })
+    await wrapper.findAll('.calendar-controls button').find(button => button.text() === '新增预约')!.trigger('click')
+    expect(wrapper.emitted('create')).toEqual([[]])
+    expect(wrapper.emitted('range')).toBeUndefined()
+    wrapper.unmount()
+  })
   it('changes the selected date locally and requests one range per mode or period change', async () => {
     const wrapper = render()
     await wrapper.get('[data-date="2026-10-20"]').trigger('click')

src/modules/appointment-calendar/AppointmentCalendarPanel.vue

@@ -1,12 +1,13 @@
 <script setup lang="ts">
 import '@/styles/adminDensity.css'
 import { computed, ref } from 'vue'
+import { Plus } from '@lucide/vue'
 import { calendarDates, calendarRange, dateKey, moveCalendar, type CalendarMode } from './calendar'
 import { scheduleLabels, scheduleTypes, type ScheduleEvent, type ScheduleType } from './schedule'
 
-const props = withDefaults(defineProps<{ events: ScheduleEvent[]; loading?: boolean; incomplete?: boolean; initialDate?: string; initialMode?: CalendarMode }>(),
-  { loading: false, incomplete: false, initialDate: '', initialMode: 'month' })
-const emit = defineEmits<{ range: [range: { from: string; to: string }]; select: [date: string, mode: CalendarMode]; open: [event: ScheduleEvent]; edit: [event: ScheduleEvent] }>()
+const props = withDefaults(defineProps<{ events: ScheduleEvent[]; loading?: boolean; incomplete?: boolean; initialDate?: string; initialMode?: CalendarMode; canCreate?: boolean }>(),
+  { loading: false, incomplete: false, initialDate: '', initialMode: 'month', canCreate: false })
+const emit = defineEmits<{ range: [range: { from: string; to: string }]; select: [date: string, mode: CalendarMode]; open: [event: ScheduleEvent]; edit: [event: ScheduleEvent]; create: [] }>()
 const selectedDate = ref(props.initialDate || dateKey(new Date())), mode = ref<CalendarMode>(props.initialMode)
 const types = ref<ScheduleType[]>([...scheduleTypes]), keyword = ref(''), undated = ref(false)
 const dates = computed(() => calendarDates(selectedDate.value, mode.value))
@@ -44,6 +45,7 @@ function changeMode(next: CalendarMode) {
           <strong>预约日历</strong>
         </div>
         <div class="calendar-controls">
+          <el-button v-if="canCreate" type="primary" @click="emit('create')"><Plus :size="16" aria-hidden="true" />新增预约</el-button>
           <div class="view-toggle" role="group" aria-label="预约视图"><button type="button" :aria-pressed="mode === 'month'" @click="changeMode('month')">月</button><button type="button" :aria-pressed="mode === 'week'" @click="changeMode('week')">周</button></div>
           <button class="nav-button" type="button" :aria-label="mode === 'month' ? '上个月' : '上一周'" @click="select(moveCalendar(selectedDate, mode, -1))">‹</button>
           <strong class="calendar-period">{{ heading }}</strong>

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

@@ -18,9 +18,10 @@ const row: ScheduleEvent = { key: 'warehouse-1', type: 'warehouse', date: '2026-
 export function renderSchedule() {
   return mount(AppointmentCalendarView, { global: { stubs: {
     AdminPage: { template: '<main><slot /></main>' },
-    AppointmentCalendarPanel: { name: 'AppointmentCalendarPanel', props: ['events', 'loading', 'incomplete', 'initialDate', 'initialMode'], template: '<section data-calendar />' },
+    AppointmentCalendarPanel: { name: 'AppointmentCalendarPanel', props: ['events', 'loading', 'incomplete', 'initialDate', 'initialMode', 'canCreate'], template: '<section data-calendar />' },
     AppDialog: { name: 'AppDialog', props: ['modelValue', 'beforeClose', 'confirmDisabled', 'confirmLoading'], emits: ['confirm'], template: '<section v-if="modelValue" data-dialog><slot /><button data-save :disabled="confirmDisabled" @click="$emit(\'confirm\')">保存</button><button data-close @click="beforeClose(() => {})">关闭</button></section>' },
     WorkDetailPanel: true, SourceAppointmentPanel: true, ApiErrorMeta: true,
+    AppointmentCreatePanel: { name: 'AppointmentCreatePanel', props: ['canWrite', 'canLeave'], emits: ['created'], template: '<section data-create-panel />' },
     LoadErrorState: { props: ['title', 'message'], emits: ['retry'], template: '<section role="alert">{{ title }} {{ message }}<slot name="details" /><button data-retry @click="$emit(\'retry\')">重试</button></section>' },
   } } })
 }
@@ -32,6 +33,30 @@ beforeEach(() => {
   vi.mocked(saveWarehouseArrival).mockResolvedValue({})
 })
 describe('simplified appointment entry', () => {
+  it('opens creation lazily with the original read and write permissions and refreshes after creation', async () => {
+    const wrapper = renderSchedule(); await flushPromises()
+    expect(wrapper.find('[data-create-panel]').exists()).toBe(false)
+    const calendar = wrapper.getComponent({ name: 'AppointmentCalendarPanel' })
+    expect(calendar.props('canCreate')).toBe(true)
+    calendar.vm.$emit('create'); await flushPromises()
+    const panel = wrapper.getComponent({ name: 'AppointmentCreatePanel' })
+    expect(panel.props('canWrite')).toBe(true)
+    vi.mocked(getCalendarSources).mockClear()
+    panel.vm.$emit('created'); await flushPromises()
+    expect(getCalendarSources).toHaveBeenCalledTimes(1)
+    await wrapper.get('[data-close]').trigger('click'); await flushPromises()
+    expect(wrapper.find('[data-create-panel]').exists()).toBe(false)
+    wrapper.unmount()
+  })
+  it.each(['platform:overseas-warehouse:inbound-order:fba-appointment', 'platform:overseas-warehouse:last-mile-order:list'])('does not open creation without %s', async permission => {
+    routing.denied.add(permission)
+    const wrapper = renderSchedule(); await flushPromises()
+    const calendar = wrapper.getComponent({ name: 'AppointmentCalendarPanel' })
+    expect(calendar.props('canCreate')).toBe(false)
+    calendar.vm.$emit('create'); await flushPromises()
+    expect(wrapper.find('[data-create-panel]').exists()).toBe(false)
+    wrapper.unmount()
+  })
   it('keeps unsaved input when the operator declines to leave', async () => {
     vi.mocked(ElMessageBox.confirm).mockRejectedValueOnce('cancel')
     const wrapper = renderSchedule(); await flushPromises()
@@ -45,7 +70,7 @@ describe('simplified appointment entry', () => {
   })
   it('loads original sources and real trips without loading work summaries or generated work items', async () => {
     const wrapper = renderSchedule(); await flushPromises()
-    expect(getWarehouseArrivals).toHaveBeenCalledWith({ from: '2026-09-28', to: '2026-11-09' }, ['1'], expect.any(AbortSignal))
+    expect(getWarehouseArrivals).toHaveBeenCalledWith({ from: '2026-09-28', to: '2026-11-02' }, ['1'], expect.any(AbortSignal))
     const panel = wrapper.getComponent({ name: 'AppointmentCalendarPanel' })
     expect(panel.props('events').map((event: ScheduleEvent) => [event.type, event.date])).toEqual([['arrival', '2026-10-19'], ['warehouse', '2026-10-21']])
     expect(wrapper.text()).not.toMatch(/全局待办|跟进|复核/)

src/modules/appointment-calendar/AppointmentCalendarView.vue

@@ -23,7 +23,10 @@ import { appointmentExternalTarget } from './workNavigation'
 // 原业务页面仍能直接进入其预约表单；日历不再提供工作清单或流程编排入口。
 const WorkDetailPanel = defineAsyncComponent(() => import('./WorkDetailPanel.vue'))
 const SourceAppointmentPanel = defineAsyncComponent(() => import('./SourceAppointmentPanel.vue'))
+const AppointmentCreatePanel = defineAsyncComponent(() => import('./AppointmentCreatePanel.vue'))
 const route = useRoute(), router = useRouter(), access = useAccessPreviewStore()
+const creating = ref(false)
+const canCreate = computed(() => access.can('platform:overseas-warehouse:inbound-order:fba-appointment') && access.can('platform:overseas-warehouse:last-mile-order:list'))
 function initialDate() {
   const value = typeof route.query.date === 'string' ? route.query.date : ''
   try { calendarRange(value, 'month'); return value } catch { return dateKey(new Date()) }
@@ -130,6 +133,8 @@ async function canLeave() {
   return true
 }
 async function closeEditor(done: () => void) { if (await canLeave()) { done(); editor.value = null } }
+async function openCreate() { if (canCreate.value && await canLeave()) creating.value = true }
+async function closeCreate(done: () => void) { if (await canLeave()) { done(); creating.value = false } }
 onBeforeRouteLeave(canLeave)
 onBeforeRouteUpdate(canLeave)
 
@@ -166,7 +171,10 @@ onBeforeUnmount(() => { ++generation; controller?.abort() })
   <AdminPage class="admin-density appointment-schedule" spacing="compact">
     <LoadErrorState v-for="error in errors" :key="error.title" :title="error.title" :message="error.details.message" :loading="loading" @retry="load()"><template #details><ApiErrorMeta :details="error.details" /></template></LoadErrorState>
     <p v-for="notice in notices" :key="notice" role="status" class="data-notice">{{ notice }}</p>
-    <AppointmentCalendarPanel :events="events" :loading="loading" :incomplete="incomplete" :initial-date="selectedDate" :initial-mode="mode" @range="load" @select="select" @open="openSource" @edit="edit" />
+    <AppointmentCalendarPanel :events="events" :loading="loading" :incomplete="incomplete" :initial-date="selectedDate" :initial-mode="mode" :can-create="canCreate" @create="openCreate" @range="load" @select="select" @open="openSource" @edit="edit" />
+    <AppDialog v-if="active && creating" :model-value="true" title="新增FBA送仓预约" class="admin-density-dialog admin-density business-dialog" width="1080px" :show-footer="false" :before-close="closeCreate" :close-on-click-modal="true" append-to-body fullscreenable>
+      <AppointmentCreatePanel :can-write="canCreate" :can-leave="canLeave" @created="load()" />
+    </AppDialog>
     <AppDialog v-if="active" :model-value="!!editor" title="调整计划到仓" class="admin-density-dialog" width="520px" :confirm-loading="saving" :confirm-disabled="!plannedAt || conflict" :before-close="closeEditor" :confirm-text="unknownResult ? '重试确认保存结果' : '保存'" @confirm="save">
       <template v-if="editor">
         <p>{{ editor.title }}</p>

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

@@ -0,0 +1,131 @@
+import { flushPromises, mount } from '@vue/test-utils'
+import { beforeEach, expect, it, vi } from 'vitest'
+import AppointmentCreatePanel from './AppointmentCreatePanel.vue'
+import { createSourceAppointment, listPlanningCargo, listPlanningDestinations, previewPlanningBatch, resolvePlanningSource, type PlanningCargo, type PlanningBatchPreview } from './planningApi'
+import type { QueryField } from '@/shared/components/QueryToolbar.vue'
+import { batchContext } from './batch.test-support'
+import type { LeaveGuard } from './useWorkDraft'
+
+vi.mock('./planningApi', async original => ({ ...await original<typeof import('./planningApi')>(), listPlanningCargo: vi.fn(), listPlanningDestinations: vi.fn(), resolvePlanningSource: vi.fn(), previewPlanningBatch: vi.fn(), createSourceAppointment: vi.fn() }))
+vi.mock('@/core/access/accessPreview', () => ({ useAccessPreviewStore: () => ({ can: () => true }) }))
+vi.mock('element-plus', () => ({ ElMessage: { success: vi.fn(), warning: vi.fn() }, ElMessageBox: { confirm: vi.fn() } }))
+const cargo: PlanningCargo = { sourceKey: 'ORDER:9007199254740999', orderId: '9007199254740999', customerId: '9007199254740998', customerName: '测试客户', inboundCode: 'IN-TEST', containerBookingId: 'container-1', containerNo: 'TEST-CONT', originWarehouseId: 'origin-1', originWarehouseCode: 'US-W', originWarehouseName: '美国仓', destinationWarehouseCode: 'ONT8', packages: 20, receivedPackages: 0, shippedPackages: 0, sourcePalletCount: null, volumeCbm: null, estimatedArrivalAt: null, estimatedWarehouseAt: null, orderVersion: 1, standardNode: 'DEPARTED', shippingVersion: null, shippingObservedAt: null, shippingProvider: null, hasInboundPlan: false, hasActiveAppointment: false, detained: false, mixedDestinations: false }
+const source = { sourceKey: cargo.sourceKey, customerId: cargo.customerId, orderId: cargo.orderId, inboundCode: cargo.inboundCode, bookingNo: null, containerNo: cargo.containerNo, originWarehouseId: cargo.originWarehouseId, originWarehouseName: cargo.originWarehouseName, destinationKey: 'FBA:LAX9', destinationWarehouseCode: 'LAX9', packages: 20, sourceVersion: 'v1', canFollowup: true, blockReasons: [] }
+const preview: PlanningBatchPreview = { group: { originWarehouseId: cargo.originWarehouseId, destinationKey: source.destinationKey, packages: 20, sourceCount: 1, customerCount: 1, readinessIncomplete: true, readyFrom: null, readyTo: null, unknownQuantitySources: 0 }, originWarehouseName: '美国仓', destinationWarehouseCode: 'LAX9', destinationTimezone: 'America/Los_Angeles', sources: [source], missingFields: [] }
+const guards = new Set<LeaveGuard>()
+function render(canWrite = true) {
+  return mount(AppointmentCreatePanel, { props: { canWrite, canLeave: async () => { for (const guard of guards) if (!await guard()) return false; return true } }, global: {
+    provide: { 'appointment-work-leave-guard': (guard: LeaveGuard) => { guards.add(guard); return () => guards.delete(guard) } },
+    stubs: {
+      DataTable: { name: 'DataTable', props: ['data', 'total', 'resultsVisible'], emits: ['update:page'], template: '<div><slot name="filters" /><slot name="toolbar-actions" /><slot name="notices" /><div v-for="row in data" :key="row.sourceKey"><span>{{ row.inboundCode }}</span><slot name="select" :row="row" /><slot name="eligibility" :row="row" /></div><button data-page @click="$emit(\'update:page\', 2)">下一页</button></div>' },
+      QueryToolbar: { name: 'QueryToolbar', props: ['modelValue', 'fields'], emits: ['search', 'update:modelValue'], template: '<button data-query @click="$emit(\'search\')">查询</button>' },
+      ElCheckbox: { props: ['modelValue', 'disabled'], emits: ['change'], template: '<input type="checkbox" :checked="modelValue" :disabled="disabled" @change="$emit(\'change\', $event.target.checked)">' },
+      ElButton: { props: ['disabled', 'loading'], template: '<button :disabled="disabled || loading"><slot /></button>' },
+      FbaAppointmentFields: { name: 'FbaAppointmentFields', props: ['model', 'disabled'], template: '<input data-date type="date" v-model="model.plannedDate" :disabled="disabled">' },
+      LoadErrorState: { props: ['message'], emits: ['retry'], template: '<p role="alert">{{ message }}<button data-retry @click="$emit(\'retry\')">重试</button><slot name="details" /></p>' }, ApiErrorMeta: true,
+    },
+  } })
+}
+async function selectAndPrepare(wrapper: ReturnType<typeof render>) {
+  await wrapper.get('input[type="checkbox"]').setValue(true)
+  await wrapper.findAll('button').find(button => button.text().startsWith('下一步'))!.trigger('click')
+  await flushPromises()
+}
+beforeEach(() => {
+  vi.clearAllMocks(); guards.clear()
+  vi.mocked(listPlanningCargo).mockResolvedValue({ records: [cargo], total: 21, page: 1, size: 20, pages: 2 })
+  vi.mocked(resolvePlanningSource).mockResolvedValue({ source, coverage: { status: 'NONE', missingFields: [], changeReviewRequired: false, appointments: [] } })
+  vi.mocked(previewPlanningBatch).mockResolvedValue(preview)
+  vi.mocked(createSourceAppointment).mockResolvedValue(batchContext().appointment)
+  vi.mocked(listPlanningDestinations).mockResolvedValue(['ABE4','ONT8'])
+})
+it('loads searchable destination options lazily and keeps the submitted filter across pages until reset', async () => {
+  const wrapper = render(); await flushPromises()
+  const toolbar = wrapper.getComponent({name:'QueryToolbar'})
+  const destination = () => (toolbar.props('fields') as QueryField[]).find(field=>field.key==='destination')!
+  expect(destination().props?.filterable).toBe(true)
+  expect(listPlanningDestinations).not.toHaveBeenCalled()
+  const open = destination().props!.onVisibleChange as (visible:boolean)=>void
+  open(true); await flushPromises()
+  expect(destination().options).toEqual([{label:'ABE4',value:'ABE4'},{label:'ONT8',value:'ONT8'}])
+  open(true); await flushPromises(); expect(listPlanningDestinations).toHaveBeenCalledTimes(1)
+  toolbar.vm.$emit('update:modelValue',{keyword:'IN-TEST',destination:'ABE4'})
+  await wrapper.get('[data-query]').trigger('click'); await flushPromises()
+  expect(listPlanningCargo).toHaveBeenLastCalledWith({page:1,size:20,keyword:'IN-TEST',destination:'ABE4'},expect.any(AbortSignal))
+  await wrapper.get('[data-page]').trigger('click'); await flushPromises()
+  expect(listPlanningCargo).toHaveBeenLastCalledWith({page:2,size:20,keyword:'IN-TEST',destination:'ABE4'},expect.any(AbortSignal))
+  toolbar.vm.$emit('update:modelValue',{keyword:'',destination:undefined})
+  await wrapper.get('[data-query]').trigger('click'); await flushPromises()
+  expect(listPlanningCargo).toHaveBeenLastCalledWith({page:1,size:20,keyword:undefined},expect.any(AbortSignal))
+  wrapper.unmount()
+})
+it('reports a destination directory failure and allows retry without hiding loaded cargo', async () => {
+  vi.mocked(listPlanningDestinations).mockRejectedValueOnce(new Error('offline'))
+  const wrapper = render(); await flushPromises()
+  const field = (wrapper.getComponent({name:'QueryToolbar'}).props('fields') as QueryField[]).find(field=>field.key==='destination')!
+  ;(field.props!.onVisibleChange as (visible:boolean)=>void)(true); await flushPromises()
+  expect(wrapper.find('[role="alert"]').exists()).toBe(true)
+  expect(wrapper.getComponent({name:'DataTable'}).props('resultsVisible')).toBe(true)
+  await wrapper.get('[data-retry]').trigger('click'); await flushPromises()
+  expect(listPlanningDestinations).toHaveBeenCalledTimes(2)
+  expect(wrapper.find('[role="alert"]').exists()).toBe(false)
+  wrapper.unmount()
+})
+it('does not read or create per-row details until the operator selects cargo and proceeds', async () => {
+  const wrapper = render(); await flushPromises()
+  expect(listPlanningCargo).toHaveBeenCalledWith({ page: 1, size: 20, keyword: undefined }, expect.any(AbortSignal))
+  expect(resolvePlanningSource).not.toHaveBeenCalled(); expect(previewPlanningBatch).not.toHaveBeenCalled(); expect(createSourceAppointment).not.toHaveBeenCalled()
+  await selectAndPrepare(wrapper)
+  expect(resolvePlanningSource).toHaveBeenCalledWith({ sourceKey: cargo.sourceKey, customerId: cargo.customerId })
+  expect(previewPlanningBatch).toHaveBeenCalledWith([{ sourceKey: source.sourceKey, customerId: source.customerId, destinationKey: 'FBA:LAX9' }])
+  expect(wrapper.text()).not.toContain(cargo.orderId)
+  wrapper.unmount(); expect(guards.size).toBe(0)
+})
+it('submits the real form, shows the saved appointment, and prevents another submit of the same completed form', async () => {
+  const wrapper = render(); await flushPromises(); await selectAndPrepare(wrapper)
+  await wrapper.get('[data-date]').setValue('2026-10-25')
+  await wrapper.findAll('button').find(button => button.text() === '保存预约安排')!.trigger('click'); await flushPromises()
+  expect(createSourceAppointment).toHaveBeenCalledWith(expect.objectContaining({ sources: [{ sourceKey: source.sourceKey, customerId: source.customerId, destinationKey: 'FBA:LAX9' }], details: expect.objectContaining({ plannedDate: '2026-10-25', plannedAt: null }), idempotencyKey: expect.any(String) }))
+  expect(wrapper.emitted('created')).toEqual([[batchContext().appointment]])
+  expect(wrapper.get('[role="status"]').text()).toContain(batchContext().appointment.appointmentNo)
+  expect(wrapper.findAll('button').some(button => button.text() === '保存预约安排')).toBe(false)
+  expect(wrapper.get('[data-date]').attributes('disabled')).toBeDefined()
+  wrapper.unmount()
+})
+it('preserves the original request and blocks returning or closing after an unknown creation result', async () => {
+  vi.mocked(createSourceAppointment).mockRejectedValueOnce(new Error('connection lost'))
+  const wrapper = render(); await flushPromises(); await selectAndPrepare(wrapper)
+  await wrapper.findAll('button').find(button => button.text() === '保存预约安排')!.trigger('click'); await flushPromises()
+  await wrapper.findAll('button').find(button => button.text() === '返回选择货物')!.trigger('click'); await flushPromises()
+  expect(wrapper.findComponent({ name: 'DataTable' }).exists()).toBe(false)
+  expect((await Promise.all([...guards].map(guard => guard()))).includes(false)).toBe(true)
+  await wrapper.findAll('button').find(button => button.text() === '重试本次创建')!.trigger('click'); await flushPromises()
+  expect(vi.mocked(createSourceAppointment).mock.calls[1]).toEqual(vi.mocked(createSourceAppointment).mock.calls[0])
+  wrapper.unmount()
+})
+it('disables blocked cargo and keeps selected cargo across pages', async () => {
+  vi.mocked(listPlanningCargo).mockResolvedValueOnce({ records: [cargo, { ...cargo, sourceKey: 'ORDER:blocked', detained: true }], total: 21, page: 1, size: 20, pages: 2 })
+  const wrapper = render(); await flushPromises()
+  expect(wrapper.findAll('input[type="checkbox"]')[1]!.attributes('disabled')).toBeDefined()
+  await wrapper.findAll('input[type="checkbox"]')[0]!.setValue(true)
+  await wrapper.get('[data-page]').trigger('click'); await flushPromises()
+  expect(listPlanningCargo).toHaveBeenLastCalledWith({ page: 2, size: 20, keyword: undefined }, expect.any(AbortSignal))
+  expect(wrapper.findAll('button').some(button => button.text() === '下一步：填写预约（1）')).toBe(true)
+  wrapper.unmount()
+})
+it('reports source failures and does not offer a write path without permission', async () => {
+  const readonly = render(false); await flushPromises()
+  expect(listPlanningCargo).not.toHaveBeenCalled(); expect(createSourceAppointment).not.toHaveBeenCalled(); readonly.unmount()
+  vi.mocked(listPlanningCargo).mockRejectedValueOnce(new Error('unavailable'))
+  const wrapper = render(); await flushPromises()
+  expect(wrapper.findComponent({ name: 'DataTable' }).props('resultsVisible')).toBe(false)
+  expect(wrapper.find('[role="alert"]').exists()).toBe(true)
+  wrapper.unmount()
+})
+it('ignores a source resolution that arrives after the dialog is closed', async () => {
+  let complete!: (value: Awaited<ReturnType<typeof resolvePlanningSource>>) => void
+  vi.mocked(resolvePlanningSource).mockImplementationOnce(() => new Promise(resolve => { complete = resolve }))
+  const wrapper = render(); await flushPromises(); await selectAndPrepare(wrapper)
+  wrapper.unmount(); complete({ source, coverage: { status: 'NONE', missingFields: [], changeReviewRequired: false, appointments: [] } }); await flushPromises()
+  expect(previewPlanningBatch).not.toHaveBeenCalled(); expect(createSourceAppointment).not.toHaveBeenCalled()
+})

src/modules/appointment-calendar/AppointmentCreatePanel.vue

@@ -0,0 +1,145 @@
+<script setup lang="ts">
+import InlineHelp from '@/shared/components/InlineHelp.vue'
+import { computed, onBeforeUnmount, onMounted, ref } from 'vue'
+import DataTable, { type DataTableColumn } from '@/shared/components/DataTable.vue'
+import QueryToolbar, { type QueryField, type QueryModel } from '@/shared/components/QueryToolbar.vue'
+import LoadErrorState from '@/shared/components/LoadErrorState.vue'
+import ApiErrorMeta from '@/shared/components/ApiErrorMeta.vue'
+import { getApiErrorDetails, type ApiErrorDetails } from '@/shared/api/http'
+import { FbaAppointmentFields, createAppointmentForm, type FbaAppointmentDto } from '@/modules/overseas-warehouse'
+import { listPlanningCargo, listPlanningDestinations, resolvePlanningSource, type PlanningCargo } from './planningApi'
+import { useWorkDraft, type LeaveGuard } from './useWorkDraft'
+import type { SourceReference } from './workApi'
+import WorkCreateAppointmentForm from './WorkCreateAppointmentForm.vue'
+
+const props = defineProps<{ canWrite: boolean; canLeave: LeaveGuard }>()
+const emit = defineEmits<{ created: [appointment: FbaAppointmentDto] }>()
+const query = ref<QueryModel>({ keyword: '', destination: '' }), keyword = ref(''), destination = ref(''), page = ref(1), total = ref(0)
+const destinations = ref<string[]>([]), destinationsLoading = ref(false), destinationsLoaded = ref(false), destinationError = ref<ApiErrorDetails | null>(null)
+let destinationsRequest = 0, destinationsController: AbortController | null = null
+const fields = computed<QueryField[]>(() => [
+  { key: 'keyword', type: 'input', label: '货物', placeholder: '入仓码、柜号、客户名称', width: 300 },
+  { key: 'destination', type: 'select', label: '目的FBA仓', placeholder: '搜索或选择目的FBA仓', width: 220,
+    options: destinations.value.map(code => ({ label: code, value: code })),
+    props: { filterable: true, loading: destinationsLoading.value, onVisibleChange: (visible: boolean) => {
+      if (visible && !destinationsLoaded.value) void loadDestinations()
+    } } },
+])
+const rows = ref<PlanningCargo[]>([]), selected = ref<Record<string, PlanningCargo>>({})
+const selectedRows = computed(() => Object.values(selected.value))
+const loading = ref(false), resolving = ref(false), error = ref<ApiErrorDetails | null>(null), selectionError = ref<ApiErrorDetails | null>(null)
+const references = ref<SourceReference[] | null>(null), created = ref<FbaAppointmentDto | null>(null)
+const createdForm = computed(() => createAppointmentForm(created.value || undefined))
+useWorkDraft(computed(() => !references.value && !created.value && selectedRows.value.length > 0), computed(() => false))
+let generation = 0, selectionGeneration = 0, controller: AbortController | null = null
+const columns: DataTableColumn[] = [
+  { key: 'select', label: '选择', width: 60, slotName: 'select' },
+  { prop: 'inboundCode', label: '入仓码', minWidth: 180 },
+  { prop: 'customerName', label: '客户', minWidth: 140 },
+  { prop: 'containerNo', label: '柜号', minWidth: 145 },
+  { prop: 'originWarehouseName', label: '起运仓', minWidth: 140 },
+  { prop: 'destinationWarehouseCode', label: '目的FBA仓', width: 110 },
+  { prop: 'packages', label: '箱数', width: 80 },
+  { key: 'eligibility', label: '预约资格', minWidth: 130, slotName: 'eligibility' },
+]
+function key(row: PlanningCargo) { return JSON.stringify([row.customerId, row.sourceKey]) }
+function reason(row: PlanningCargo) {
+  if (row.detained) return '货物暂扣中'
+  if (row.mixedDestinations) return '多个目的地，需先核对'
+  if (row.hasActiveAppointment) return '已有有效预约'
+  const anchor = selectedRows.value[0]
+  if (anchor && (anchor.originWarehouseId !== row.originWarehouseId || anchor.destinationWarehouseCode !== row.destinationWarehouseCode)) return '请选择同起运仓、同目的仓'
+  if (selectedRows.value.length >= 100 && !selected.value[key(row)]) return '每次最多选择100票'
+  return ''
+}
+function toggle(row: PlanningCargo, checked: boolean | string | number) {
+  if (!props.canWrite || resolving.value) return
+  if (!checked) delete selected.value[key(row)]
+  else if (!reason(row)) selected.value[key(row)] = row
+  selectionError.value = null
+}
+async function load(nextPage = page.value) {
+  if (!props.canWrite) return
+  page.value = nextPage
+  const current = ++generation; controller?.abort(); controller = new AbortController()
+  loading.value = true; error.value = null
+  try {
+    const result = await listPlanningCargo({ page: nextPage, size: 20, keyword: keyword.value || undefined,
+      ...(destination.value ? { destination: destination.value } : {}) }, controller.signal)
+    if (current === generation) { rows.value = result.records; total.value = result.total }
+  } catch (cause) {
+    if (current === generation) { rows.value = []; total.value = 0; error.value = getApiErrorDetails(cause, '可预约货物读取失败') }
+  } finally { if (current === generation) loading.value = false }
+}
+function search() {
+  keyword.value = String(query.value.keyword || '').trim()
+  destination.value = String(query.value.destination || '').trim()
+  void load(1)
+}
+async function loadDestinations() {
+  if (!props.canWrite || destinationsLoading.value) return
+  const current = ++destinationsRequest
+  destinationsController?.abort(); destinationsController = new AbortController()
+  destinationsLoading.value = true; destinationError.value = null
+  try {
+    const result = await listPlanningDestinations(destinationsController.signal)
+    if (current === destinationsRequest) { destinations.value = result; destinationsLoaded.value = true }
+  } catch (cause) {
+    if (current === destinationsRequest) destinationError.value = getApiErrorDetails(cause, '目的FBA仓选项读取失败')
+  } finally { if (current === destinationsRequest) destinationsLoading.value = false }
+}
+async function prepare() {
+  if (!props.canWrite || !selectedRows.value.length || loading.value || resolving.value || error.value) return
+  const current = ++selectionGeneration, snapshot = [...selectedRows.value]
+  resolving.value = true; selectionError.value = null
+  try {
+    const sources: SourceReference[] = []
+    // 仅对明确选中的货物读取最新来源，不按展示行逐票请求，也不猜目的地键。
+    for (const row of snapshot) {
+      if (current !== selectionGeneration) return
+      const { source } = await resolvePlanningSource({ sourceKey: row.sourceKey, customerId: row.customerId })
+      if (current !== selectionGeneration) return
+      if (!source.canFollowup) { selectionError.value = { message: source.blockReasons.join('；') || '所选货物当前不能新增预约，请重新核对。' }; return }
+      sources.push({ sourceKey: source.sourceKey, customerId: source.customerId, destinationKey: source.destinationKey })
+    }
+    if (current === selectionGeneration) references.value = sources
+  } catch (cause) { if (current === selectionGeneration) selectionError.value = getApiErrorDetails(cause, '所选货物核对失败') }
+  finally { if (current === selectionGeneration) resolving.value = false }
+}
+async function back() { if (await props.canLeave()) references.value = null }
+function saved(appointment: FbaAppointmentDto) {
+  created.value = appointment; references.value = null; selected.value = {}
+  emit('created', appointment)
+}
+async function again() {
+  if (!await props.canLeave()) return
+  created.value = null; references.value = null; selected.value = {}; selectionError.value = null
+  await load()
+}
+onMounted(() => { void load() })
+onBeforeUnmount(() => { ++generation; ++selectionGeneration; ++destinationsRequest; controller?.abort(); destinationsController?.abort() })
+</script>
+<template>
+  <section aria-label="新增FBA送仓预约">
+    <template v-if="created">
+      <p role="status">预约已保存：<strong>{{ created.appointmentNo || '预约编号未返回' }}</strong></p>
+      <p>预约保存后仍需在原业务安排车辆，日历中的排车以真实车次为准。</p>
+      <el-button v-if="canWrite" @click="again">继续新增预约</el-button>
+      <FbaAppointmentFields :model="createdForm" :appointment-no="created.appointmentNo" :timezone="created.timezone" :disabled="true" />
+    </template>
+    <template v-else-if="references">
+      <el-button @click="back">返回选择货物</el-button>
+      <WorkCreateAppointmentForm :sources="references" :can-write="canWrite" @saved="saved" />
+    </template>
+    <template v-else>
+      <DataTable :data="rows" :columns="columns" :page="page" :page-size="20" :page-sizes="[20]" :total="total" :loading="loading" :results-visible="!error" :row-key="key" empty-text="暂无可预约货物" @update:page="load($event)">
+        <template #filters><QueryToolbar v-model="query" ariaLabel="新增预约货物查询" :fields="fields" :loading="loading || resolving" @search="search" /></template>
+        <template #toolbar-actions><InlineHelp title="选货说明"><p>选择需要送往FBA的已有货物；同一起运仓、同一目的仓可合并多个客户的货物。跨页选择会保留。</p></InlineHelp><el-button :disabled="!selectedRows.length || resolving" @click="selected = {}; selectionError = null">清空选择</el-button><el-button type="primary" :disabled="!canWrite || !selectedRows.length || loading || !!error" :loading="resolving" @click="prepare">下一步：填写预约（{{ selectedRows.length }}）</el-button></template>
+        <template #pagination-left>已选 {{ selectedRows.length }}/100 票</template>
+        <template #notices><LoadErrorState v-if="destinationError" title="目的FBA仓选项读取失败" :message="destinationError.message" :loading="destinationsLoading" @retry="loadDestinations"><template #details><ApiErrorMeta :details="destinationError" /></template></LoadErrorState><LoadErrorState v-if="error" title="可预约货物读取失败" :message="error.message" :loading="loading" @retry="load()"><template #details><ApiErrorMeta :details="error" /></template></LoadErrorState><LoadErrorState v-if="selectionError" title="所选货物核对失败" :message="selectionError.message" :show-retry="false"><template #details><ApiErrorMeta :details="selectionError" /></template></LoadErrorState></template>
+        <template #select="{ row }"><el-checkbox :model-value="!!selected[key(row as PlanningCargo)]" :aria-label="`选择 ${row.inboundCode || row.containerNo || '未提供业务编号的货物'}`" :disabled="!canWrite || resolving || (!selected[key(row as PlanningCargo)] && !!reason(row as PlanningCargo))" @change="toggle(row as PlanningCargo, $event)" /></template>
+        <template #eligibility="{ row }">{{ reason(row as PlanningCargo) || '可选择' }}</template>
+      </DataTable>
+    </template>
+  </section>
+</template>

src/modules/appointment-calendar/PROTOTYPE_MATRIX.md

@@ -7,22 +7,41 @@
 | 页面 | 操作 | 当前确认承载与布局 | 实现结论 |
 |---|---|---|---|
 | 预约列表 | 月/周、四类选择、当前范围搜索 | 左日历右当天安排；日期格简洁标签，最多三条 | 恢复 `AppointmentCalendarPanel`，不再打开全局工作明细弹框；待人工截图确认 |
+| 预约列表 | 月视图周数 | 用户截图 `codex-clipboard-372a5dc5-0c82-4298-93db-089b6c97c8ca.png`；周一至周日，只覆盖当月所需完整周 | 4/5/6周自适应；2026年10月五周，保留末周11月1日，不追加11月2—8日整周；待人工截图确认 |
 | 预约列表 | 查看当天、未定日期 | 固定右侧区域，完整业务字段与滚动明细 | 类型仅到港、排车、还柜、计划到仓；待人工截图确认 |
-| 预约列表 | 新增、审核、删除 | 本轮明确取消通用入口 | 来源业务生成记录；不在日历另建预约或改状态 |
+| 预约列表 | 新增预约 | 用户本轮要求恢复顶部按钮，随后确认先支持FBA；1080px居中弹框，先选择已有货物，再登记预约时间 | 复用真实来源预览及预约保存流程，原权限/幂等/未保存保护；保存成功显示预约编号和只读内容；普通客户仓不在本次范围；待人工截图确认 |
+| 新增FBA送仓预约 | 按目的仓查询 | 用户截图 `codex-clipboard-44b338fe-af49-45e2-abf2-3bc0bd27224a.png`；在原查询栏增加可搜索、可清空的目的FBA仓下拉框 | 选项使用同货物查询权限的权威美国FBA目录；提交查询后从第一页按目的仓过滤，翻页沿用条件；待人工截图确认 |
+| 预约列表 | 审核、删除 | 不恢复通用入口 | 在原业务处理，不在日历改业务状态 |
 | 计划到仓 | 调整 | 原居中弹框保留，小型时间表单 | 整柜原命令、原权限/版本/幂等与计划冻结门禁；待人工截图确认 |
 | 到港、排车、还柜 | 查看与办理 | 跳原货柜/车次正式详情页 | 保留日期/月周返回上下文，无独立工作流程导航 |
 | 原业务深链 | 精确来源/事项办理 | 仍使用既有居中原业务表单 | 只承接其他模块实际使用的精确入口，不恢复全局工作待办；待人工截图确认 |
 
+2026-10-19 目的FBA仓筛选补修：原查询栏增加可搜索、可清空的下拉框，首次展开读取完整权威美国FBA目录；复用原货物读取权限，不新增仓库管理权限。查询回第一页，翻页沿用目的仓条件，重置清除条件；选项失败独立提示并可重试，不隐藏已加载货物或伪装为空结果。预约模块37文件/276项及生产构建（含类型检查）通过，Gateway路由合同5项通过。后端生产源码编译通过，本次两个测试文件单独javac编译并经Surefire执行13项通过；常规Maven流程仍被派送模块三份测试中的5项编译错误阻挡，不能据定向结果宣称后端完整门禁通过。Admin全量405文件/3388项通过、1项输入提示合同失败，原因是其他在途运输单表单的7个输入框缺少placeholder；单独复查相同失败，未修改其他模块。日志为`.logs/appointment-destination-{test,build,full-test,placeholder-check}.log`，后端为同名前缀的`route`、`backend`、`javac`及`targeted-backend`日志。本补修未提交或部署，人工1920×1080/100%视觉待确认。
+
+2026-10-19 新增FBA预约入口补修：顶部按钮要求原FBA预约写权限及尾程订单列表权限，点击后才读取候选；支持同起运仓、同目的仓的跨客户货物选择，核对最新真实来源后复用原创建表单。未知结果保留原请求并阻止关闭/返回，成功后移除创建表单、显示真实预约编号和只读内容，刷新原日历；不生成虚拟车次或第五类日历。本次已明确普通客户仓暂不加入。
+
+验证：新增入口直接5文件/59项通过；`pnpm build`含类型检查通过，仅既有AnalyticsChart大分块提示。工作区首次全量为405文件/3385项通过、1项排车详情布局合同失败，后续该项单独6项复查通过；再次全量出现9文件/11项失败（以5秒超时为主），在不修改超时阈值和其他业务代码的情况下，以2个工作进程复查整个预约模块、密度及上述全部失败文件，47文件/385项全过。不将这些分次结果记录为单次全量绿灯。证据为`.logs/appointment-create-{focused-final,build,full-test,full-test-final,layout-recheck,bounded-recheck}.log`。额外临时候选核对未作为通过证据；工作区其他业务在途修改保留。本次未提交、发布或新增真实业务记录，人工1920×1080/100%视觉待确认。
+
+2026-10-19 月视图周数补修：按月实际周数生成日期格，并同步查询开区间；覆盖2026年10月五周、跨年五周、完整二月四周与确需六周的八月。Admin全量405文件/3375项、类型检查及生产构建通过，`git diff --check`通过；仅既有AnalyticsChart大分块提示。本补修尚未提交或发布，人工视觉待确认；证据为`.logs/appointment-calendar-month-weeks-{test,build}.log`。
+
 2026-10-19 发布候选检查：Admin全量405文件/3372项通过，定向输入提示、弹框密度及取货组件4文件/35项通过；`pnpm build`（含类型检查）通过，仅既有AnalyticsChart大分块提示。新增日历后端直接测试及受影响SQL、API、权限合同通过，Gateway路由/部署拓扑/回滚合同与Mapper注册合同通过。
 
 发布检查中发现的既有问题已在本候选最小修正：调拨新增箱数和取货输入提示、取货弹框密度、尾程贴标文件页签结构与对应断言；取货测试Bean及API数量断言；国内空库SQL中误放的五张海外取货表归回海外空库基线，并同步现行车次用途字段和基线表数。这些仅修改源码基线，不对运行环境执行SQL。
 
 本次发布单元为Admin、Firstleg、Lastleg；新增两个只读日历接口复用现有Gateway通配路由，日历功能不新增数据库结构。环境发布与真实HTTP结果只维护在`docs/测试环境单机部署与配置契约.md`。人工视觉待用户在1920×1080、100%缩放下截图确认。
 
+2026-10-16 本次 UI 检查：用户重新要求检查后，运行 Admin 全量测试，397 文件 / 3292 项通过；发现并修正 QueryToolbar 必填 `ariaLabel` 属性的模板写法。补充真实 KeepAlive + Teleport 离开/恢复及点击提醒弹层回归后，最新定向检查 3 文件 / 66 项通过，最终 `pnpm typecheck`、`pnpm build` 和 `git diff --check` 通过。构建仍有既有 AnalyticsChart 约 588 kB 分块提示。此记录更新下文历史“未运行验证”的结论；本地自动检查不代表测试环境或人工视觉验收。所属客户显示缺项仍待后端合同补齐，INP 采集报错的脚本来源未确认，本次未部署。日志为 `.logs/appointment-ui-current-{test,focused,typecheck,build}.log`。
+
 本轮依据：`C:/Users/BY-OY/.codex/visualizations/2026/10/14/01a13a8d-e968-7962-906b-1a514792d921/appointment-calendar-guided.html`（V13，SHA-256 `61902e410be755aa9cbf9fcfaa9d393bfa49dd8d592cd8773af5396e78c29836`）及 `docs/海外仓业务/预约工作日历V13变更说明.md`、开发协作契约。保留既有日历和居中弹框优化，不改变原业务实际执行入口。
 
 本次密度调整依据：用户提供的主页面截图 `codex-clipboard-93984795-68cb-4082-96b3-c83189d8a357.png`、展开明细截图 `codex-clipboard-a98edd3b-82af-4f1b-989e-7d0f028e0965.png`，以及用户确认的压缩留白、日期定位、控件统一、零值弱化和统计范围说明。
 
+2026-10-16 操作列样式核对：用户截图 `codex-clipboard-9d54345c-c9c1-4991-82ba-b319948f781b.png` 明确要求与外层表格统一。
+
+| 页面 | 操作 | 截图依据与布局 | 当前实现 | 本轮结论 |
+|---|---|---|---|---|
+| 预约工作明细表格 | 查看详情或服务端提供的下一步操作 | 操作列内蓝色普通文字，无边框、底色或装饰图标 | `RowActions` 默认描边样式 | 使用公共 `text-actions` 模式，保留当前文案、权限、点击承载和长文案换行；待人工截图确认 |
+
 2026-10-16 当前承载调整：用户反馈“点击外面关闭不了，也看不清”。日期/类型/全局明细、事项详情、原侧边编辑表单和到港参考统一改用带遮罩的居中 `AppDialog`，常规宽度 1120px、高度 88dvh，支持全屏；标题与分页固定、仅正文滚动。遮罩、Esc 和关闭按钮统一经过未保存/提交结果待确认保护。此结论优先于下表早期侧边承载描述；原业务独立页面跳转、确认流程和统计口径保持原样。改后待人工截图确认。
 
 V13 日历布局：按已确认定高要求，月日格固定 146px，周日格固定 270px；只展示五类服务端计数和独立到港参考，不追加逐事项卡片、不依明细条数扩高。替代下表早期“随内容自然增高”的结论；不裁掉五类入口，仍需人工核对 1920×1080、100% 下完整内容。
@@ -60,6 +79,7 @@ V13 日历布局：按已确认定高要求，月日格固定 146px，周日格
 
 | V13 场景 | 当前前端与直接检查 | 依赖／剩余验收 |
 |---|---|---|
+| 事项列表统一表格 | 用户截图 `codex-clipboard-1bde1991-b226-4956-8530-6de44074f818.png` 明确要求统一表格或卡片，不能混排 | 所有日期/类型/全局待办列表统一使用 DataTable 与 RowActions，替代早期多行卡片排版。操作固定最左；事项、类型、状态、作业时间、时区、流程、地点、负责人、下次跟进、提醒分列，时间保留实际/确认/目标口径。列表弹框加宽，表头与分页由共享表格承载；保留每页 8 项、筛选和返回上下文。当前调整覆盖旧卡片与独立分页结论；未运行验证或部署，待人工截图确认 |
 | 01 整客户 160 移出续办 | `WorkDetailPanel.test.ts` 保存后读取主要下一步；`WorkExistingDispatchForm.test.ts` 沿用真实排车单继续安排本批车辆 | 单客户移出命令、当前数量/车辆版本、原车 120 保留结果及后续目标；真实发车签收待集成 |
 | 02 100 先送、60 后送 | `AppointmentBatchForm.test.ts` 保留普通分批与来源版本；`WorkDetailPanel.test.ts` 区分未定作业日和跟进日 | 已确认预约/装载关系的部分移出与调整回复语义，不能以普通分批代替 |
 | 03 后送 60 加另一客户 40 共车 | 本批与另一客户按实际托盘各建排车单；结果页“与同仓其他排车单共车”沿业务号核对两单后复用 TripPreparationDialog/Fleet prepare，可加入已有计划车次；WorkDispatchForm、WorkSharedTripForm、TripPreparationDialog、trips API 测试覆盖传递与导航 | 实物须能对应本次数量，不能对应时先走原库存拆托；共车后的路线、容量、审核及发车须真实 HTTP 验收，非任意箱级拆托开发缺口 |
@@ -161,8 +181,12 @@ V13 日历布局：按已确认定高要求，月日格固定 146px，周日格
 
 | 本次操作 | 证据与现状 | 调整结论 |
 |---|---|---|
+| 未定日期范围内搜索 | 用户截图 `codex-clipboard-07b5ab03-e467-4ce1-8410-13d05ac5bc51.png` 反馈大量数据缺少搜索，且测试环境仍显示旧卡片 | 全局待办弹框接入 QueryToolbar，支持柜号、批次号、车次号、地点关键词；沿现有 items API 同时传 view（含 UNDATED）与 keyword，服务端全范围筛选后分页，不过滤当前 8 条。搜索/清空回第 1 页，返回明细保留搜索词和分页，原业务跳转的 return URL 保留 workListKeyword。保留全局统计口径；表格与搜索均为当前工作区改动，本任务未部署，未运行验证 |
+| 所属客户缺失排查 | 用户截图 `codex-clipboard-645f5354-0dfd-4b90-b6f7-05ff9b1f2ffb.png`；`BusinessReference` 只有 kind/key/businessNo/label，客户引用存在 `CUSTOMER + 内部客户键 + null + 所属客户` 的生产路径，详情查询仅合并引用 | 前端按 `businessNo || '—'` 展示，缺少真实客户名称；不能据此认定没有关联客户，也不能回退内部客户键。待工作事项后端按权威客户目录补充名称/业务编号并明确展示合同；遵循开发协作契约，本任务不保留后端改动。未完成接口或环境验收 |
+| 提醒列与跳转遮罩 | 用户截图 `codex-clipboard-54e0b56d-448c-40da-a147-15798c932091.png` 和按钮反馈 | 提醒列固定 105px，仅显示去重后的条数，点击展开完整可滚动提醒，不撑高表格行。预约页被 KeepAlive 停用时卸载挂到 body 的弹框，恢复时保留父级事项/分页上下文。用户 startTime 截图实际是 INP 采集的空 entries 读取，脚本来源尚待确认，不能将该报错认定为已修复；本轮未运行验证或部署 |
+| 事项详情的信息层级 | 用户 2026-10-16 截图 `codex-clipboard-cad4abc6-51d1-42f2-8e7b-7914b264348e.png` 反馈排版不清楚、缺少重点 | 顶部突出事项名称与状态；作业时间、时区、地点、负责人和下次跟进复用共享描述表；原有提醒去重后集中展示，保留完成态与跟进日期语义；当前操作与关联资料/历史分区，保留所有动作资格、原业务跳转、默认历史展开条件和未保存保护。空原业务进度不渲染空标题；已知事件代码使用中文名称，未知代码保留在辅助信息中，时间保留原时区。本轮未运行验证或部署，待人工截图确认 |
 | 列表信息层级与日历视觉细化 | 用户 2026-10-16 截图 `codex-clipboard-6858cde3-eda3-4a02-a043-e1a47143f67c.png`、`codex-clipboard-5a68965d-cdbd-4ce9-b8b3-385d9d76b4f2.png`，并明确要求按建议优化 | 查看详情/历史使用普通描边按钮，办理动作保留主色且仍在左侧；完整标题、状态、作业时间、时区、地点、流程、负责人、跟进日期及异常分层显示。日历类型改浅色底与弱边框，保留语义色、今天/选中态；周末表头与到港参考保持辅助层级，零值弱化、超期数字提示。保留现有覆盖面板、字号、统计和动作链；改后待人工截图确认 |
-| 工作明细左侧长操作按钮 | Admin #621 真实 1920×1080 截图 `baiyue-firstleg/reports/appointment-browser-20261015/admin-621-follow-today-1920.png`；按钮与文本实际行高仅 13px | 保留完整文案和 108px 操作列，统一使用 20px 行高、自然换行和自适应高度；普通/展开面板及主操作/查看详情使用同一规则 |
+| 工作明细左侧长操作按钮 | 用户 2026-10-16 截图 `codex-clipboard-b36b905a-a223-4fa6-98ca-7ece08149a37.png` 反馈按钮过大；原 108px 列宽、全宽实心按钮导致长文案换行撑高 | 操作列调整为 184px，按钮按文案宽度使用共享 `density-action` 描边样式和 28px 最小高度；完整保留服务端动作标签及点击行为，超长文案仍可换行。业务编号使用深色标题，辅助信息使用说明字号，行间距收紧。适用全部工作明细弹框及全屏态，覆盖早期实心主按钮结论；改后待人工截图确认，本轮未运行验证或部署 |
 | 流程与工具栏分组 | 用户后续流程下拉、日期工具栏及上下操作区截图（`115df974`、`d217350b`、`80dd9fa1`） | 流程改为四个直接切换按钮；全局待办、流程、日期与类型筛选收进连续白底工作区，各行靠左，保留全局与区间统计边界 |
 | 日历浏览与日期选择 | 主页面截图；原型 `renderCalendar()`、`.day.selected`、`.todaymark` | 缩小日格空白，今天与选择态分别标识；零项日期只显示日期；显示实际查询起止日期，保留加载失败状态 |
 | 日期/类型/全局明细 | 展开截图中日历被挤窄；原型第 11 行 `.workspace`、`.panel` 为右侧覆盖布局 | 恢复覆盖式侧边工作面板，不压缩日历；增加展开/收起，标题和关闭固定，正文滚动，分页固定；仍保留左侧业务操作 |
@@ -186,10 +210,8 @@ V13 日历布局：按已确认定高要求，月日格固定 146px，周日格
 | 客户仓批次用车 | 原排车与车次安排入口 | 按 DISPATCH 引用读取原排车单，再进入原车次安排 | `WorkExistingDispatchForm.vue`；核对不可变批次键与真实业务号，保留原实物；不调用 FBA 候选，不新建排车单；原派送进度按明确业务引用进入 |
 | 本柜接仓计划与记录 | `executeForm()`、原入库单详情 | 单计划进入对应客户原单，多计划列出本柜实际关联清单；缺计划时先预览整柜分组 | `WorkReceiptPlans.vue`；复用 container-summaries、原整柜预览/生成 API 和原入库单路由，快照与原资源重试键保持一致；实际收货仍由原仓库作业流程登记 |
 | 失败、无权限、未保存 | 真实接口与应用验收规则 | 明确失败和重试；错误不改为0项，保留输入和原上下文 | 各组件直接回归；未知命令不执行，未确认保存结果禁止离开 |
-
 | 保存后工作清单同步等待 | 用户截图 `codex-clipboard-40520e09-5cbf-489f-9941-325bdf22bdea.png`，顶部保存成功、正文续办 A0409 | 保留当前事项弹框和保存结果，不改变承载方式 | `useWorkSyncRead.ts` 仅对当前完整工作清单同步守卫重读 GET；间隔2秒，累计等待最多30秒，超限显示原错误；日历、汇总、明细与批次续办一致，不重复写入 |
 | 查看原排车单、继续安排本批车辆 | 用户截图 `codex-clipboard-4791b73f-7a9f-4be5-910a-38911e135ef4.png`、`codex-clipboard-e5b41c4b-a00c-4b99-ac06-cd23ec910aa9.png` | 原排车单进入正式路由，事项弹框随缓存页停用而移除；继续配车沿目标事项读取资格 | 保留已有 `pageActive/onDeactivated` 修复；跨事项 `nextAction` 仅导航，目标事项重新核对 `allowedActions`，不继承送仓资格或执行旧动作。修复后待人工截图确认 |
-
 | 刷新后沿用已有FBA排车单 | 当前对话指定沿用原DS；`WorkExistingDispatchForm.vue` 的既有原排车列表和 `TripPreparationDialog` | 保留事项弹框，显示本批原排车单；继续用原安排车次弹框，不重复选托盘或创建 | `WorkDispatchForm.vue` 先读当前批次 `receiving.transport`，再按原排车单 `appointmentBatches` 校验批次/客户；已绑定车次直接查看，关系读取失败不显示创建入口；剩余实物仅显式选择后读取。待人工截图确认 |
 
 视觉目标：1920×1080、100%缩放，待人工截图确认。单元测试与类型检查单独报告，不代表真实接口或页面验收通过。原业务跳转缺少的业务号/客户范围在协作交接中列明，不由前端补造；工作 Slot 与原预约编辑均保留完整跨日时间。原业务页面返回入口只接受预约工作页，并保留原事项、前置事项、筛选及页码。

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

@@ -10,7 +10,7 @@ vi.mock('@/core/access/accessPreview', () => ({ useAccessPreviewStore: () => ({
 vi.mock('@/modules/overseas-warehouse', async original => ({ ...await original<typeof import('@/modules/overseas-warehouse')>(), getDispatch: vi.fn(), getFbaAppointment: vi.fn() }))
 vi.mock('./batchApi', async original => ({ ...await original<typeof import('./batchApi')>(), getAppointmentBatch: vi.fn() }))
 vi.mock('./receivingApi', async original => ({ ...await original<typeof import('./receivingApi')>(), getReceivingContext: vi.fn() }))
-const reference = (batchKey = 'FBA_APPOINTMENT:1', batchNo: string | null = 'AP-001'): DispatchBatchReference => ({ batchKey, batchNo, customerId: 'customer-a', sources: [{ sourceKey: 'ORDER:1', destinationKey: 'FBA:ONT8', packageCount: 70 }] })
+const reference = (batchKey = 'FBA_APPOINTMENT:1', batchNo: string | null = 'AP-001'): DispatchBatchReference => ({ batchKey, batchNo, recordVersion: 0, customerId: 'customer-a', sources: [{ sourceKey: 'ORDER:1', destinationKey: 'FBA:ONT8', packageCount: 70 }] })
 function render(overrides: Partial<InstanceType<typeof TripAppointmentPanel>['$props']> = {}) { return mount(TripAppointmentPanel, { props: { dispatches: [{ dispatchNo: 'DS-A', customerId: 'customer-a', packageCount: 70, appointmentBatches: [reference()] }], previousDispatches: [], historyUnavailableReason: null, canWrite: true, ...overrides }, global: { stubs: {
   ElButton: { props: ['disabled'], template: '<button :disabled="disabled"><slot /></button>' },
   AppDialog: { props: ['modelValue'], template: '<div v-if="modelValue"><slot /></div>' },

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

@@ -57,7 +57,7 @@ it('shows the actual cross-month interval and hides empty-day zeros while keepin
 })
 it('renders server type counts instead of individual event cards and opens exact date/type details', async () => {
   const wrapper = render()
-  expect(wrapper.findAll('.work-day')).toHaveLength(42)
+  expect(wrapper.findAll('.work-day')).toHaveLength(35)
   const day = wrapper.get('[data-date="2026-10-15"]')
   expect(day.get('.day-heading').text()).toContain('2 项')
   await day.get('[data-type="DELIVERY"]').trigger('click')

src/modules/appointment-calendar/WorkCreateAppointmentForm.vue

@@ -2,7 +2,7 @@
 import { computed, onMounted, reactive, ref } from 'vue'
 import { ElMessage } from 'element-plus'
 import { useAccessPreviewStore } from '@/core/access/accessPreview'
-import { FbaAppointmentFields, createAppointmentForm, appointmentFormError, appointmentPayload, overseasWarehousePermissions } from '@/modules/overseas-warehouse'
+import { FbaAppointmentFields, createAppointmentForm, appointmentFormError, appointmentPayload, overseasWarehousePermissions, type FbaAppointmentDto } from '@/modules/overseas-warehouse'
 import LoadErrorState from '@/shared/components/LoadErrorState.vue'
 import ApiErrorMeta from '@/shared/components/ApiErrorMeta.vue'
 import { getApiErrorDetails, type ApiErrorDetails } from '@/shared/api/http'
@@ -11,7 +11,7 @@ import type { SourceReference } from './workApi'
 import { rejectedCommand, useWorkDraft } from './useWorkDraft'
 import { workReason } from './workPresentation'
 const props = defineProps<{ sources: SourceReference[]; canWrite: boolean }>()
-const emit = defineEmits<{ saved: [] }>()
+const emit = defineEmits<{ saved: [appointment: FbaAppointmentDto] }>()
 const access = useAccessPreviewStore(), preview = ref<PlanningBatchPreview | null>(null)
 const form = reactive(createAppointmentForm()), baseline = ref(JSON.stringify(form))
 const loading = ref(false), saving = ref(false), error = ref<ApiErrorDetails | null>(null), saveError = ref<ApiErrorDetails | null>(null)
@@ -35,7 +35,7 @@ async function save() {
   try {
     const result = await createSourceAppointment(pending.value)
     pending.value = null; baseline.value = JSON.stringify(form)
-    ElMessage.success(`预约安排 ${result.appointmentNo} 已保存`); emit('saved')
+    ElMessage.success(`预约安排 ${result.appointmentNo} 已保存`); emit('saved', result)
   } catch (cause) {
     saveError.value = getApiErrorDetails(cause, '创建结果待确认，请重试本次请求')
     if (rejectedCommand(cause)) { pending.value = null; await load() }

src/modules/appointment-calendar/WorkDetailPanel.vue

@@ -21,6 +21,14 @@ import { useWorkSyncRead } from './useWorkSyncRead'
 const props = defineProps<{ itemKey: string; initialAction?: WorkAction | null; canLeave: LeaveGuard }>()
 const emit = defineEmits<{ open: [key: string, action?: WorkAction]; external: [path: string]; saved: [result?: WorkCommandResult, command?: WorkCommand['command']]; updated: []; container: [id: string, label: string] }>()
 const detail = ref<WorkDetail | null>(null), loading = ref(false), error = ref<ApiErrorDetails | null>(null), action = ref<WorkAction | null>(null)
+const attentionReasons = computed(() => [...new Set([
+  ...(detail.value?.item.blockReasons || []),
+  ...(detail.value?.item.missingFields || []),
+  ...(detail.value?.item.overdueReasons || []),
+].map(workReason))])
+const needsFollowup = computed(() => !!detail.value && detail.value.item.executionStatus !== 'COMPLETED' && (!detail.value.item.owner || !detail.value.item.followupDate))
+const historyLabels: Record<string, string> = { BASELINE_OBSERVED: '同步原业务状态', GENERATED: '创建工作事项', CONFIRM_ROUTE: '确认路线', SAVE_FOLLOWUP: '记录跟进', RESOLVE_REVIEW: '处理复核', SAVE_REQUIREMENT: '保存预约要求', HANDOFF_RETURN: '交接还空责任', ACCEPT_RETURN: '确认接手还空' }
+function historyTime(value: string) { return value.replace('T', ' ').replace(/\.\d+(?=Z|[+-]\d{2}:\d{2}$)/, '').replace(/Z$/, ' UTC') }
 const receivingOwners = computed(() => [detail.value?.item.owner, ...(detail.value?.relatedItems.map(item => item.owner) || [])].filter((person): person is { id: string; name: string } => !!person?.id))
 const actionNotice = ref('')
 const saveCompleted = ref(false)
@@ -105,17 +113,33 @@ onMounted(async () => {
 onBeforeUnmount(() => { ++request; controller?.abort() })
 </script>
 <template>
-  <div :aria-busy="loading">
+  <div class="work-detail" :aria-busy="loading">
     <LoadErrorState v-if="error" title="工作事项读取失败" :message="error.message" :loading="loading" @retry="load"><template #details><ApiErrorMeta :details="error" /></template></LoadErrorState>
     <p v-if="loading" role="status">{{ syncing ? '预约工作清单同步中，正在自动读取最新事项；已保存内容无需重复提交。' : '正在读取当前事项与操作资格…' }}</p>
     <template v-if="detail">
-      <h3>{{ detail.item.title }}</h3><p>{{ typeLabels[detail.item.type] }} · {{ flowLabels[detail.item.flow] }} · {{ workStatus(detail.item) }}</p>
-      <p>{{ workDate(detail.item) }} · {{ detail.item.timezone || '地点时区待核实' }}</p><p>{{ detail.item.destinationName || detail.item.originName || '地点待核实' }} · {{ detail.item.owner?.name || '待分派' }}</p>
-      <p class="followup-summary">下次跟进：{{ detail.item.followupDate || '尚未安排' }}<span v-if="detail.item.dateBasis === 'NONE'"> · 作业日期未定，跟进日不作为作业日期</span></p>
-      <p v-if="detail.item.executionStatus !== 'COMPLETED' && (!detail.item.owner || !detail.item.followupDate)" class="work-warning">{{ !detail.item.owner ? '负责人待分派。' : '' }}{{ !detail.item.followupDate ? '请补充下一次跟进安排。' : '' }}请记录跟进；若无操作权限，请联系负责人。</p>
-      <div class="container-links"><button v-for="container in detail.item.containers" :key="container.containerBookingId" type="button" @click="emit('container', container.containerBookingId, container.containerNo || container.bookingNo || '本柜')">{{ container.containerNo || container.bookingNo || '—' }} · 本柜待办</button></div>
-      <p v-for="reason in [...detail.item.blockReasons, ...detail.item.missingFields, ...detail.item.overdueReasons]" :key="reason" class="work-warning">{{ workReason(reason) }}</p>
+      <header class="detail-overview">
+        <div class="detail-title"><h3>{{ detail.item.title }}</h3><el-tag :type="detail.item.executionStatus === 'COMPLETED' ? 'success' : detail.item.reviewRequired ? 'warning' : 'info'" size="small">{{ workStatus(detail.item) }}</el-tag></div>
+        <p class="detail-category">{{ typeLabels[detail.item.type] }} · {{ flowLabels[detail.item.flow] }}</p>
+      </header>
+      <dl class="density-fields detail-facts" aria-label="事项关键信息">
+        <div><dt>作业时间</dt><dd>{{ workDate(detail.item) }}</dd></div>
+        <div><dt>作业时区</dt><dd>{{ detail.item.timezone || '地点时区待核实' }}</dd></div>
+        <div><dt>作业地点</dt><dd>{{ detail.item.destinationName || detail.item.originName || '地点待核实' }}</dd></div>
+        <div><dt>负责人</dt><dd>{{ detail.item.owner?.name || '待分派' }}</dd></div>
+        <div class="followup-summary"><dt>下次跟进</dt><dd>{{ detail.item.followupDate || '尚未安排' }}<span v-if="detail.item.dateBasis === 'NONE'" class="field-note">作业日期未定，跟进日不作为作业日期</span></dd></div>
+      </dl>
+      <div v-if="detail.item.containers.length" class="container-links"><span>关联货柜</span><el-button v-for="container in detail.item.containers" :key="container.containerBookingId" class="density-action" data-tone="primary" @click="emit('container', container.containerBookingId, container.containerNo || container.bookingNo || '本柜')">{{ container.containerNo || container.bookingNo || '—' }} · 本柜待办</el-button></div>
+      <aside v-if="needsFollowup || attentionReasons.length" class="attention-panel" aria-label="事项提醒">
+        <h4>事项提醒</h4>
+        <ul>
+          <li v-if="needsFollowup">{{ !detail.item.owner ? '负责人待分派。' : '' }}{{ !detail.item.followupDate ? '请补充下一次跟进安排。' : '' }}请记录跟进；若无操作权限，请联系负责人。</li>
+          <li v-for="reason in attentionReasons" :key="reason">{{ reason }}</li>
+        </ul>
+      </aside>
       <p v-if="detail.returnHandoff">还空责任：{{ detail.returnHandoff.from.name }} → {{ detail.returnHandoff.to.name }} · {{ detail.returnHandoff.status === 'PENDING_ACCEPTANCE' ? '接手方待确认，持续跟进' : '已确认接手' }}</p>
+      <section class="current-work" aria-label="当前处理">
+      <h4>{{ detail.item.executionStatus === 'COMPLETED' ? '事项结果' : '当前处理' }}</h4>
+      <p v-if="detail.item.executionStatus === 'COMPLETED'" class="completion-summary">当前事项已完成，可查看关联工作和历史记录。</p>
       <template v-if="!action && !continuation">
         <p v-if="saveCompleted" role="status" class="save-result">本次保存已完成。{{ loading ? '正在读取当前下一步…' : error ? '下一步读取失败，请重试读取事项，无需重复提交已保存内容。' : detail.item.executionStatus === 'COMPLETED' ? '当前事项已完成，可返回查看其他待办。' : '请按当前下一步继续处理。' }}</p>
         <el-button v-if="detail.item.nextAction" class="primary-next-action" type="primary" :disabled="loading || !!error" @click="choose(detail.item.nextAction)">{{ detail.item.nextAction.label }}</el-button>
@@ -133,15 +157,43 @@ onBeforeUnmount(() => { ++request; controller?.abort() })
       <WorkDispatchForm v-else-if="dispatchBatchKeys?.length" :key="JSON.stringify(dispatchBatchKeys)" :batch-keys="dispatchBatchKeys" :can-write="canAct" @updated="emit('updated')" @external="path => emit('external', path)" @batch="openBatch" />
       <WorkExistingDispatchForm v-else-if="existingDispatches.length" :key="JSON.stringify(existingDispatches)" :dispatches="existingDispatches" :can-write="canAct" @updated="emit('updated')" @external="path => emit('external', path)" />
       <WorkReceiptPlans v-else-if="action?.target.kind === 'WAREHOUSE_RECEIPT'" :key="action.target.containerBookingId" :container-booking-id="action.target.containerBookingId" :can-write="canAct" @updated="emit('updated')" @external="path => emit('external', path)" />
-      <section v-else-if="action?.target.kind === 'READ_ONLY'" aria-label="原业务进度"><h4>原业务进度</h4><p v-for="reference in action.target.references" :key="`${reference.kind}:${reference.key}`"><el-button v-if="referenceRoute(reference)" :disabled="!canAct" @click="emit('external', referenceRoute(reference)!)">{{ reference.label }} · {{ reference.businessNo }}</el-button><span v-else>{{ reference.label }} · {{ reference.businessNo || '—' }}</span></p></section>
+      <section v-else-if="action?.target.kind === 'READ_ONLY' && action.target.references.length" aria-label="原业务进度"><h4>原业务进度</h4><p v-for="reference in action.target.references" :key="`${reference.kind}:${reference.key}`"><el-button v-if="referenceRoute(reference)" :disabled="!canAct" @click="emit('external', referenceRoute(reference)!)">{{ reference.label }} · {{ reference.businessNo }}</el-button><span v-else>{{ reference.label }} · {{ reference.businessNo || '—' }}</span></p></section>
       <details v-if="secondaryActions.length"><summary>更多操作</summary><div class="more-actions"><el-button v-for="candidate in secondaryActions" :key="`${candidate.code}:${candidate.targetWorkItemKey}`" :disabled="loading || !!error" @click="choose(candidate)">{{ candidate.label }}</el-button></div></details>
-      <details><summary>关联工作 · {{ detail.relatedItems.length }} 项</summary><div v-for="related in detail.relatedItems" :key="related.workItemKey" class="related-row"><div>{{ related.title }}<p>{{ workStatus(related) }} · {{ workDate(related) }}</p></div><el-button @click="emit('open', related.workItemKey)">查看</el-button></div></details>
-      <details><summary>原业务记录 · {{ detail.references.length }} 项</summary><p v-for="reference in detail.references" :key="`${reference.kind}:${reference.key}`">{{ reference.label }} · {{ reference.businessNo || '—' }}</p></details>
-      <details :open="action?.code === 'VIEW_HISTORY'"><summary>操作记录</summary><div v-for="(entry, index) in detail.history" :key="index" class="history-entry"><b>{{ entry.action }}</b><p>{{ entry.summary }}</p><small>{{ entry.operatorName || '—' }} · {{ entry.occurredAt }}</small></div><p v-if="!detail.history.length">暂无记录</p></details>
+      </section>
+      <section class="detail-records" aria-label="关联资料与历史">
+      <details><summary>关联工作 · {{ detail.relatedItems.length }} 项</summary><div v-for="related in detail.relatedItems" :key="related.workItemKey" class="related-row"><div>{{ related.title }}<p>{{ workStatus(related) }} · {{ workDate(related) }}</p></div><el-button class="density-action" @click="emit('open', related.workItemKey)">查看</el-button></div><p v-if="!detail.relatedItems.length">暂无关联工作</p></details>
+      <details><summary>原业务记录 · {{ detail.references.length }} 项</summary><p v-for="reference in detail.references" :key="`${reference.kind}:${reference.key}`">{{ reference.label }} · {{ reference.businessNo || '—' }}</p><p v-if="!detail.references.length">暂无原业务记录</p></details>
+      <details :open="action?.code === 'VIEW_HISTORY'"><summary>操作记录 · {{ detail.history.length }} 条</summary><div v-for="(entry, index) in detail.history" :key="index" class="history-entry"><div class="history-heading"><b>{{ historyLabels[entry.action] || '事项记录' }}</b><time :datetime="entry.occurredAt">{{ historyTime(entry.occurredAt) }}</time></div><p>{{ entry.summary }}</p><small>{{ entry.operatorName || '—' }}<span v-if="!historyLabels[entry.action]"> · {{ entry.action }}</span></small></div><p v-if="!detail.history.length">暂无记录</p></details>
+      </section>
     </template>
   </div>
 </template>
 <style scoped>
-.container-links, .more-actions { display: flex; flex-wrap: wrap; gap: var(--admin-space-3); }.container-links button { background: transparent; border: 0; color: var(--el-color-primary); cursor: pointer; font: inherit; }
-.related-row { display: flex; align-items: center; justify-content: space-between; gap: var(--admin-space-3); }.related-row, .history-entry { border-bottom: 1px solid var(--cc-border); padding-block: var(--admin-space-3); }details { margin-top: var(--admin-space-5); }summary { cursor: pointer; padding-block: var(--admin-space-3); }.work-warning { color: var(--el-color-warning-dark-2); }
+.work-detail { font-size: var(--admin-font-body); line-height: 1.6; color: var(--el-text-color-primary); }
+.detail-overview { margin-bottom: var(--admin-space-5); }
+.detail-title { display: flex; align-items: center; flex-wrap: wrap; gap: var(--admin-space-3); }
+.detail-title h3 { margin: 0; font-size: var(--admin-font-title); }
+.detail-category { margin: var(--admin-space-1) 0 0; color: var(--el-text-color-secondary); font-size: var(--admin-font-caption); }
+.work-detail .detail-facts { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+.followup-summary { grid-column: 1 / -1; }
+.field-note { margin-left: var(--admin-space-5); color: var(--el-text-color-secondary); font-size: var(--admin-font-caption); }
+.container-links, .more-actions { display: flex; align-items: center; flex-wrap: wrap; gap: var(--admin-space-3); }
+.container-links { margin-top: var(--admin-space-3); }
+.container-links > span { color: var(--el-text-color-secondary); font-size: var(--admin-font-caption); }
+.attention-panel { margin-top: var(--admin-space-5); padding: var(--admin-space-3) var(--admin-space-5); border-left: 3px solid var(--el-color-warning); background: var(--el-color-warning-light-9); color: var(--el-color-warning-dark-2); }
+.attention-panel h4, .current-work > h4 { margin: 0 0 var(--admin-space-1); font-size: var(--admin-font-section); }
+.attention-panel ul { margin: 0; padding-left: var(--admin-space-6); font-size: var(--admin-font-caption); }
+.current-work { margin-top: var(--admin-space-5); padding-block: var(--admin-space-5); border-top: 1px solid var(--cc-border); }
+.current-work > p { margin: var(--admin-space-2) 0; }
+.completion-summary { color: var(--el-color-success-dark-2); }
+.detail-records { border-top: 1px solid var(--cc-border); }
+.detail-records > details { border-bottom: 1px solid var(--cc-border); }
+summary { cursor: pointer; padding-block: var(--admin-space-3); font-weight: 600; }
+summary:focus-visible { outline: 2px solid var(--el-color-primary); outline-offset: -2px; }
+.detail-records p { margin: var(--admin-space-1) 0; }
+.related-row, .history-heading { display: flex; align-items: baseline; justify-content: space-between; flex-wrap: wrap; gap: var(--admin-space-3); }
+.related-row, .history-entry { border-bottom: 1px solid var(--cc-border); padding-block: var(--admin-space-3); }
+.related-row:last-child, .history-entry:last-child { border-bottom: 0; }
+.related-row p, .history-entry small, .history-heading time { font-size: var(--admin-font-caption); color: var(--el-text-color-secondary); }
+.work-warning { color: var(--el-color-warning-dark-2); }
 </style>

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

@@ -1,146 +1,162 @@
 import { flushPromises, mount } from '@vue/test-utils'
 import { beforeEach, expect, it, vi } from 'vitest'
 import WorkDispatchForm from './WorkDispatchForm.vue'
-import { getDispatch, getBatchDispatchCandidates, createDispatchDraftContainer, listDispatchDrafts, lockDispatchDraftPallet, preArrangeDraftDispatch, releaseDispatchDraft, type BatchDispatchCandidate } from '@/modules/overseas-warehouse'
+import { getDispatch, getBatchDispatchCandidates, listDispatchCandidates, createDispatchDraft, createDispatchDraftContainer, listDispatchDrafts, lockDispatchDraftPallet, convertDispatchDraft, releaseDispatchDraft, type BatchDispatchCandidate, type Candidate, type CommandResult, type DispatchDetail, type DispatchDraft } from '@/modules/overseas-warehouse'
+import { ApiResponseError, http } from '@/shared/api/http'
+import { parseApiJsonResponse } from '@chongchong/shared'
 import { getReceivingContext, type ReceivingContext } from './receivingApi'
 import { batchContext } from './batch.test-support'
 import type { LeaveGuard } from './useWorkDraft'
-const access = vi.hoisted(() => ({ allowed: true }))
-vi.mock('@/core/access/accessPreview', () => ({ useAccessPreviewStore: () => ({ can: () => access.allowed }) }))
+const access = vi.hoisted(() => ({ allowed: true, denied: [] as string[] }))
+const identity = vi.hoisted(() => ({ id: '' }))
+vi.mock('@/core/access/accessPreview', () => ({ useAccessPreviewStore: () => ({ can: (permission: string) => access.allowed && !access.denied.includes(permission) }) }))
+vi.mock('@/core/auth/auth', () => ({ useAuthStore: () => ({ user: identity }) }))
 vi.mock('element-plus', () => ({ ElMessage: { warning: vi.fn(), success: vi.fn() }, ElMessageBox: { confirm: vi.fn() } }))
-vi.mock('@/modules/overseas-warehouse', async original => ({ ...await original<typeof import('@/modules/overseas-warehouse')>(), getDispatch: vi.fn(), getBatchDispatchCandidates: vi.fn(), createDispatchDraftContainer: vi.fn(), listDispatchDrafts: vi.fn(), lockDispatchDraftPallet: vi.fn(), preArrangeDraftDispatch: vi.fn(), releaseDispatchDraft: vi.fn() }))
+vi.mock('@/modules/overseas-warehouse', async original => ({ ...await original<typeof import('@/modules/overseas-warehouse')>(), getDispatch: vi.fn(), getBatchDispatchCandidates: vi.fn(), listDispatchCandidates: vi.fn(), createDispatchDraft: vi.fn(), createDispatchDraftContainer: vi.fn(), listDispatchDrafts: vi.fn(), lockDispatchDraftPallet: vi.fn(), convertDispatchDraft: vi.fn(), releaseDispatchDraft: vi.fn() }))
 vi.mock('./receivingApi', async original => ({ ...await original<typeof import('./receivingApi')>(), getReceivingContext: vi.fn() }))
-function receiving(batchKey: string, vehicles: ReceivingContext['transport']['vehicles'] = []): ReceivingContext { return { batch: batchContext('AP-1', batchKey).appointment, plans: [], agreements: [], pendingChanges: [], transport: { version: 'v1', vehicles, blockReasons: [] }, executionScope: { version: 'e1', members: [] }, allowedActions: [], blockReasons: [] } }
-const candidate: BatchDispatchCandidate = { planPalletId: '9007199254740993', palletNo: 'PL-TEST', planId: 'plan-1', planNo: 'IP-001', customerId: 'customer-a', sourceStage: 'RECEIVED', packageCount: 12, allocations: [{ planPalletId: '9007199254740993', batchKey: 'FBA_APPOINTMENT:1', customerId: 'customer-a', sourceKey: 'BOOKING:9', destinationKey: 'FBA:ONT8', packageCount: 12 }], blockReasons: [] }
-let guard: LeaveGuard
-function render() { return mount(WorkDispatchForm, { props: { batchKeys: ['FBA_APPOINTMENT:1'], canWrite: true }, global: { provide: { 'appointment-work-leave-guard': (value: LeaveGuard) => { guard = value; return () => undefined } }, stubs: { WorkSharedTripForm: { name: 'WorkSharedTripForm', props: ['dispatchNo', 'canWrite'], template: '<div />' }, ElButton: { props: ['disabled'], template: '<button :disabled="disabled"><slot /></button>' }, LoadErrorState: { props: ['message'], template: '<p>{{ message }}</p>' }, ApiErrorMeta: true, TripPreparationDialog: { name: 'TripPreparationDialog', props: ['warehouseId', 'dispatchNos'], template: '<div />' } } } }) }
-function button(wrapper: ReturnType<typeof render>, text: string) { return wrapper.findAll('button').find(button => button.text() === text)! }
+const clone = <T,>(value: T): T => JSON.parse(JSON.stringify(value)) as T
+const batch = 'FBA_APPOINTMENT:1'
+function receiving(key = batch, vehicles: ReceivingContext['transport']['vehicles'] = []): ReceivingContext { return { batch: batchContext('AP-1', key).appointment, plans: [], agreements: [], pendingChanges: [], transport: { version: 'transport', vehicles, blockReasons: [] }, executionScope: { version: 'execution', members: [] }, allowedActions: [], blockReasons: [] } }
+function row(id = '9007199254740993', customerId = 'customer-a', key = batch): BatchDispatchCandidate { return { planPalletId: id, palletNo: `PALLET-${id.slice(-2)}`, planId: `plan-${id}`, planNo: 'IP-001', customerId, sourceStage: 'RECEIVED', packageCount: 12, allocations: [{ planPalletId: id, batchKey: key, customerId, sourceKey: customerId === 'customer-a' ? 'ORDER:1' : 'BOOKING:2', destinationKey: 'FBA:ONT8', packageCount: 12, recordVersion: 4 }], blockReasons: [] } }
+function candidate(value = row()): Candidate { return { selection: { sourceType: 'INBOUND_PLAN', planPalletId: value.planPalletId, returnReceiptId: null, relabelNo: null, warehousePalletId: `pallet-${value.planPalletId}`, sourceVersion: `source-${value.planPalletId}` }, sourceKey: `cargo-${value.planPalletId}`, sourceVersion: `source-${value.planPalletId}`, customerId: value.customerId, customerName: value.customerId === 'customer-a' ? '客户甲' : '客户乙', warehouseId: 'origin-1', warehouseCode: 'LAX', warehouseName: '真实起运仓', orderNo: 'LM-1', inboundCode: 'IN-A', planNo: value.planNo, palletNo: value.palletNo, containerNo: null, destination: { key: 'CODE:ONT8', type: 'FBA', warehouseId: null, warehouseCode: 'ONT8', warehouseName: 'ONT8', address: null, postalCode: null, contactName: null, contactPhone: null }, availablePackages: 12, suggestedWeightKg: null, suggestedVolumeCbm: null, measurementSource: null, appointmentBatches: [], blockReasons: [] } }
+function detail(no = 'DS/001', version = 1): DispatchDetail {
+  const review = { status: 'NOT_SUBMITTED' as const, reason: null, reviewerId: null, reviewedAt: null, reviewRound: 0, basisHash: null, invalidatedReason: null }
+  return { dispatchNo: no, status: 'ACTIVE', stage: 'BEFORE_LOADING', recordVersion: version, reviewState: 'DRAFT', reviews: { dispatchReview: review, loadingReview: review }, counts: { itemCount: 1, palletCount: 1, packageCount: 12, pickedPackageCount: 0, shippedPackageCount: 0 }, pickingReconciled: false, actions: { EDIT: { allowed: true, blockCode: null, blockReason: null }, ADD_CARGO: { allowed: true, blockCode: null, blockReason: null } }, vehicleInfo: { vehicle: null, driver: null }, dispatchInfo: { route: null, plannedDepartureAt: null, departedAt: null, estimatedArrivalAt: null, fbaAppointments: [], vehicleAppointment: null, appointmentBatches: [{ batchKey: batch, batchNo: 'AP-1', recordVersion: 4, customerId: 'customer-a', sources: [{ sourceKey: 'ORDER:1', destinationKey: 'FBA:ONT8', packageCount: 12 }] }] }, documents: { dispatchNo: no, outbounds: [], deliveries: [], createdAt: '', updatedAt: '', remark: null }, orderDetails: [] }
+}
+function proof(key: string): CommandResult { return { dispatchNo: 'DS/001', action: 'CREATE', idempotencyKey: key, recordVersion: 1, status: 'ACTIVE', stage: 'BEFORE_LOADING', occurredAt: '2026-10-19T00:00:00Z', effect: 'APPLIED', counts: detail().counts, result: { dispatchNo: 'DS/001', changedItemIds: [] }, replayed: false, alreadyArranged: false } }
+let guard: LeaveGuard, natives: Candidate[], draft: DispatchDraft
+function render(props: { batchKeys?: string[]; canWrite?: boolean } = {}) { return mount(WorkDispatchForm, { props: { batchKeys: [batch], canWrite: true, ...props }, global: { provide: { 'appointment-work-leave-guard': (value: LeaveGuard) => { guard = value; return () => undefined } }, stubs: { WorkSharedTripForm: { name: 'WorkSharedTripForm', props: ['dispatchNo', 'canWrite'], template: '<div data-same-dispatch />' }, ElButton: { props: ['disabled'], template: '<button :disabled="disabled"><slot /></button>' }, LoadErrorState: { props: ['message'], template: '<p role="alert">{{ message }}</p>' }, ApiErrorMeta: true } } }) }
+const button = (wrapper: ReturnType<typeof render>, label: string) => wrapper.findAll('button').find(value => value.text() === label)!
+it.each([0, '0', '9007199254740993'])('preserves authoritative allocation version %s from the existing batch provider', async recordVersion => {
+  const value = row(); value.allocations[0]!.recordVersion = recordVersion
+  vi.mocked(getBatchDispatchCandidates).mockResolvedValue({ batchKey: batch, version: 4, candidates: [value], blockReasons: [] })
+  const wrapper = render()
+  try {
+    await flushPromises(); await button(wrapper, '创建整车排车单').trigger('click'); await flushPromises()
+    expect(vi.mocked(convertDispatchDraft).mock.calls[0]![0].groups[0]!.dispatch.batchAllocations[0]!.recordVersion).toBe(recordVersion)
+  } finally { wrapper.unmount() }
+})
+it.each([undefined, null, 'bad', 9007199254740992])('blocks an existing-batch candidate lacking a valid authoritative version: %s', async recordVersion => {
+  const value = row(); value.allocations[0]!.recordVersion = recordVersion as unknown as number
+  vi.mocked(getBatchDispatchCandidates).mockResolvedValue({ batchKey: batch, version: 0, candidates: [value], blockReasons: [] })
+  const wrapper = render()
+  try { await flushPromises(); expect(wrapper.text()).toContain('预约批次版本缺失或无效，请重新读取候选'); expect(createDispatchDraft).not.toHaveBeenCalled() }
+  finally { wrapper.unmount() }
+})
 beforeEach(() => {
-  vi.clearAllMocks(); access.allowed = true
-  vi.mocked(getReceivingContext).mockImplementation(async batchKey => receiving(batchKey))
-  vi.mocked(getBatchDispatchCandidates).mockResolvedValue({ batchKey: 'FBA_APPOINTMENT:1', version: 4, candidates: [structuredClone(candidate)], blockReasons: [] })
-  vi.mocked(listDispatchDrafts).mockResolvedValue([])
-  vi.mocked(createDispatchDraftContainer).mockResolvedValue({ id: 'container-1', capacity: 30, palletIds: [] })
-  vi.mocked(lockDispatchDraftPallet).mockResolvedValue(null)
-  vi.mocked(preArrangeDraftDispatch).mockResolvedValue([{ draftContainerId: 'container-1', dispatch: { id: 'internal-dispatch', dispatchNo: 'DS-001', appointmentBatches: [], overseasWarehouseId: 'origin-1', overseasWarehouseName: '测试起运仓' } }])
+  vi.resetAllMocks(); sessionStorage.clear(); identity.id = crypto.randomUUID(); access.allowed = true; access.denied = []
+  natives = [candidate()]; draft = { draftToken: 'server-owned-token', recordVersion: 0, status: 'ACTIVE', warehouseId: 'origin-1', containers: [], sources: [], expiresAt: '2026-10-20T00:00:00Z' }
+  vi.mocked(getReceivingContext).mockImplementation(async key => receiving(key))
+  vi.mocked(getBatchDispatchCandidates).mockImplementation(async key => ({ batchKey: key, version: 4, candidates: [row('9007199254740993', 'customer-a', key)], blockReasons: [] }))
+  vi.mocked(listDispatchCandidates).mockImplementation(async () => ({ candidates: clone(natives), complete: true, snapshotAt: '2026-10-19T00:00:00Z' }))
+  vi.mocked(createDispatchDraft).mockImplementation(async () => clone(draft))
+  vi.mocked(createDispatchDraftContainer).mockImplementation(async body => { draft.recordVersion = 1; draft.containers = [{ draftContainerId: 'container-1', sequenceNo: 1, capacity: body.capacity, sourceKeys: [] }]; return clone(draft) })
+  vi.mocked(lockDispatchDraftPallet).mockImplementation(async body => { const source = natives.find(value => value.selection.planPalletId === body.source.planPalletId)!; draft.recordVersion = Number(draft.recordVersion) + 1; draft.sources.push(clone(source)); draft.containers[0]!.sourceKeys.push(source.sourceKey); return clone(draft) })
+  vi.mocked(convertDispatchDraft).mockImplementation(async body => ({ draftToken: body.draftToken, replayed: false, vehicles: [{ draftContainerId: 'container-1', dispatch: proof(body.groups[0]!.dispatch.idempotencyKey) }] }))
+  vi.mocked(getDispatch).mockImplementation(async no => detail(no)); vi.mocked(listDispatchDrafts).mockImplementation(async () => [clone(draft)])
+  vi.mocked(releaseDispatchDraft).mockImplementation(async () => ({ ...clone(draft), status: 'RELEASED', containers: [], sources: [] }))
 })
-it('restores the original FBA dispatch after remount and opens trip preparation without any draft or creation', async () => {
-  vi.mocked(getReceivingContext).mockResolvedValue(receiving('FBA_APPOINTMENT:1', [{ dispatchNo: 'DS-EXISTING', batchKey: 'FBA_APPOINTMENT:1', customerId: 'customer-a', tripNo: null, version: null, status: 'PENDING_DEPARTURE', packageCount: 4 }]))
-  vi.mocked(getDispatch).mockResolvedValue({ id: 'dispatch-1', dispatchNo: 'DS-EXISTING', status: 'PENDING_DEPARTURE', overseasWarehouseId: 'origin-1', packageCount: 4, appointmentBatches: [{ batchKey: 'FBA_APPOINTMENT:1', batchNo: 'AP-1', customerId: 'customer-a', sources: [] }] })
-  for (let mountNumber = 0; mountNumber < 2; mountNumber++) {
-    const wrapper = render(); await flushPromises()
-    expect(wrapper.text()).toContain('DS-EXISTING')
-    expect(wrapper.text()).not.toContain('创建本客户排车单')
-    await button(wrapper, '继续安排本批车辆').trigger('click'); await flushPromises()
-    expect(wrapper.getComponent({ name: 'TripPreparationDialog' }).props()).toMatchObject({ warehouseId: 'origin-1', dispatchNos: ['DS-EXISTING'] })
-    await button(wrapper, '查看原排车单').trigger('click')
-    expect(wrapper.emitted('external')).toEqual([['/overseas-warehouse/dispatches?dispatchNo=DS-EXISTING']])
-    wrapper.unmount()
+it('creates the whole dispatch when native Long candidate quantities arrive as strings and batch quantities are Integers', async () => {
+  const actual = await vi.importActual<typeof import('../overseas-warehouse/api/dispatches')>('../overseas-warehouse/api/dispatches')
+  const get = vi.spyOn(http, 'get').mockResolvedValue(parseApiJsonResponse(JSON.stringify({ code: '200', data: { candidates: [{ ...candidate(), availablePackages: '12' }], complete: true, snapshotAt: '' } })))
+  vi.mocked(listDispatchCandidates).mockImplementation(actual.listDispatchCandidates)
+  const wrapper = render()
+  try {
+    await flushPromises(); expect(wrapper.get('input').attributes('disabled')).toBeUndefined()
+    await button(wrapper, '创建整车排车单').trigger('click'); await flushPromises()
+    expect(convertDispatchDraft).toHaveBeenCalledOnce(); expect(vi.mocked(convertDispatchDraft).mock.calls[0]![0].groups[0]!.dispatch.batchAllocations).toEqual(row().allocations)
+    expect(vi.mocked(lockDispatchDraftPallet).mock.calls[0]![0].source.planPalletId).toBe('9007199254740993'); expect(wrapper.emitted('updated')).toHaveLength(1)
+  } finally { wrapper.unmount(); get.mockRestore() }
+})
+it('restores existing batch dispatches after remount and navigates to the same whole dispatch without any creation', async () => {
+  vi.mocked(getReceivingContext).mockImplementation(async key => receiving(key, [{ dispatchNo: 'DS/EXISTING', batchKey: key, customerId: 'customer-a', tripNo: null, version: null, status: 'ACTIVE', packageCount: 12 }]))
+  for (let index = 0; index < 2; index++) {
+    const wrapper = render(); await flushPromises(); expect(wrapper.text()).toContain('DS/EXISTING')
+    await button(wrapper, '继续维护本车').trigger('click'); expect(wrapper.emitted('external')).toEqual([['/overseas-warehouse/dispatches/DS%2FEXISTING']]); expect(wrapper.text()).not.toContain('创建整车排车单'); wrapper.unmount()
   }
-  expect(getBatchDispatchCandidates).not.toHaveBeenCalled()
-  expect(createDispatchDraftContainer).not.toHaveBeenCalled()
-  expect(lockDispatchDraftPallet).not.toHaveBeenCalled()
-  expect(preArrangeDraftDispatch).not.toHaveBeenCalled()
+  expect(getBatchDispatchCandidates).not.toHaveBeenCalled(); expect(createDispatchDraft).not.toHaveBeenCalled(); expect(convertDispatchDraft).not.toHaveBeenCalled()
 })
-it('fails closed when transport relations cannot be read', async () => {
-  vi.mocked(getReceivingContext).mockRejectedValue(new Error('unavailable'))
-  const wrapper = render(); await flushPromises()
-  expect(wrapper.text()).not.toContain('创建本客户排车单')
-  expect(getBatchDispatchCandidates).not.toHaveBeenCalled()
-  expect(preArrangeDraftDispatch).not.toHaveBeenCalled()
-  wrapper.unmount()
+it('does not fall back to new creation when transport relations fail or their nested batch ownership differs', async () => {
+  vi.mocked(getReceivingContext).mockRejectedValueOnce(new Error('unavailable')); const failed = render(); await flushPromises(); expect(failed.text()).toContain('批次可排实物读取失败'); expect(getBatchDispatchCandidates).not.toHaveBeenCalled(); failed.unmount()
+  vi.mocked(getReceivingContext).mockResolvedValueOnce(receiving(batch, [{ dispatchNo: 'DS-OLD', batchKey: batch, customerId: 'customer-b', tripNo: null, version: null, status: 'ACTIVE', packageCount: 12 }]))
+  const mismatch = render(); await flushPromises(); expect(mismatch.text()).toContain('排车单与工作批次关联不一致'); expect(mismatch.text()).not.toContain('核对本批剩余可排实物'); expect(createDispatchDraft).not.toHaveBeenCalled(); mismatch.unmount()
 })
-it('does not offer remaining-cargo creation when the original dispatch no longer owns this batch', async () => {
-  vi.mocked(getReceivingContext).mockResolvedValue(receiving('FBA_APPOINTMENT:1', [{ dispatchNo: 'DS-EXISTING', batchKey: 'FBA_APPOINTMENT:1', customerId: 'customer-a', tripNo: null, version: null, status: 'PENDING_DEPARTURE', packageCount: 4 }]))
-  vi.mocked(getDispatch).mockResolvedValue({ id: 'dispatch-1', dispatchNo: 'DS-EXISTING', status: 'PENDING_DEPARTURE', appointmentBatches: [] })
-  const wrapper = render(); await flushPromises()
-  expect(wrapper.text()).toContain('排车单与工作批次关联不一致')
-  expect(wrapper.text()).not.toContain('创建本客户排车单')
-  expect(wrapper.text()).not.toContain('核对本批剩余可排实物')
-  expect(getBatchDispatchCandidates).not.toHaveBeenCalled()
-  wrapper.unmount()
+it('reads remaining physical cargo only after an explicit choice while retaining the original dispatch', async () => {
+  vi.mocked(getReceivingContext).mockImplementation(async key => receiving(key, [{ dispatchNo: 'DS-OLD', batchKey: key, customerId: 'customer-a', tripNo: null, version: null, status: 'ACTIVE', packageCount: 12 }]))
+  const wrapper = render(); await flushPromises(); expect(getBatchDispatchCandidates).not.toHaveBeenCalled()
+  await button(wrapper, '核对本批剩余可排实物').trigger('click'); await flushPromises(); expect(getBatchDispatchCandidates).toHaveBeenCalledExactlyOnceWith(batch); expect(wrapper.text()).toContain('DS-OLD'); expect(convertDispatchDraft).not.toHaveBeenCalled(); wrapper.unmount()
 })
-it('loads remaining eligible cargo only after an explicit choice while retaining the existing dispatch', async () => {
-  vi.mocked(getReceivingContext).mockResolvedValue(receiving('FBA_APPOINTMENT:1', [{ dispatchNo: 'DS-EXISTING', batchKey: 'FBA_APPOINTMENT:1', customerId: 'customer-a', tripNo: null, version: null, status: 'PENDING_DEPARTURE', packageCount: 4 }]))
-  vi.mocked(getDispatch).mockResolvedValue({ id: 'dispatch-1', dispatchNo: 'DS-EXISTING', status: 'PENDING_DEPARTURE', appointmentBatches: [{ batchKey: 'FBA_APPOINTMENT:1', batchNo: 'AP-1', customerId: 'customer-a', sources: [] }] })
-  const wrapper = render(); await flushPromises()
-  expect(getBatchDispatchCandidates).not.toHaveBeenCalled()
-  await button(wrapper, '核对本批剩余可排实物').trigger('click'); await flushPromises()
-  expect(getBatchDispatchCandidates).toHaveBeenCalledExactlyOnceWith('FBA_APPOINTMENT:1')
-  expect(wrapper.text()).toContain('DS-EXISTING')
-  expect(preArrangeDraftDispatch).not.toHaveBeenCalled()
-  wrapper.unmount()
+it('uses a server-owned draft, explicit zero versions, native source hashes and exact allocations for one whole dispatch', async () => {
+  const wrapper = render(); await flushPromises(); await button(wrapper, '创建整车排车单').trigger('click'); await flushPromises()
+  expect(createDispatchDraft).toHaveBeenCalledWith({ warehouseId: 'origin-1', idempotencyKey: expect.any(String) })
+  expect(createDispatchDraftContainer).toHaveBeenCalledWith({ draftToken: 'server-owned-token', recordVersion: 0, idempotencyKey: expect.any(String), capacity: 30 })
+  expect(lockDispatchDraftPallet).toHaveBeenCalledWith({ draftToken: 'server-owned-token', draftContainerId: 'container-1', recordVersion: 1, idempotencyKey: expect.any(String), source: natives[0]!.selection })
+  const request = vi.mocked(convertDispatchDraft).mock.calls[0]![0]
+  expect(request).toMatchObject({ draftToken: 'server-owned-token', recordVersion: 2, groups: [{ draftContainerId: 'container-1', dispatch: { warehouseId: 'origin-1', cargo: [natives[0]!.selection], batchAllocations: row().allocations, vehicle: null, driver: null } }] })
+  expect(wrapper.text()).toContain('DS/001'); expect(wrapper.emitted('updated')).toHaveLength(1); expect(await guard()).toBe(true)
+  await button(wrapper, '继续维护本车').trigger('click'); expect(wrapper.emitted('external')).toEqual([['/overseas-warehouse/dispatches/DS%2F001']]); wrapper.unmount()
 })
-it('copies exact server allocations into a real draft group and continues into original trip preparation', async () => {
-  const wrapper = render(); await flushPromises(); await wrapper.get('input[type=checkbox]').setValue(true)
-  await button(wrapper, '创建本客户排车单').trigger('click'); await flushPromises()
-  expect(preArrangeDraftDispatch).toHaveBeenCalledWith({ draftToken: expect.any(String), groups: [{ draftContainerId: 'container-1', planPalletIds: [candidate.planPalletId], returnReceiptIds: [], batchAllocations: candidate.allocations }] })
-  expect(wrapper.text()).toContain('DS-001'); expect(wrapper.text()).not.toContain('internal-dispatch')
-  const prepare = wrapper.getComponent({ name: 'TripPreparationDialog' })
-  expect(prepare.props()).toMatchObject({ warehouseId: 'origin-1', dispatchNos: ['DS-001'] })
-  prepare.vm.$emit('saved', { trip: { tripNo: 'TR-001' } }); expect(wrapper.emitted('external')).toEqual([['/overseas-master-data/trips/TR-001']])
-  wrapper.unmount()
+it('combines same-warehouse real customers in one container and keeps each batch source owner', async () => {
+  const second = row('9007199254740994', 'customer-b'); natives.push(candidate(second)); vi.mocked(getBatchDispatchCandidates).mockResolvedValue({ batchKey: batch, version: 4, candidates: [row(), second], blockReasons: [] })
+  const wrapper = render(); await flushPromises(); expect(wrapper.findAll('input').map(input => (input.element as HTMLInputElement).checked)).toEqual([true, true])
+  await button(wrapper, '创建整车排车单').trigger('click'); await flushPromises(); const groups = vi.mocked(convertDispatchDraft).mock.calls[0]![0].groups
+  expect(groups).toHaveLength(1); expect(groups[0]!.dispatch.cargo).toEqual(natives.map(value => value.selection)); expect(groups[0]!.dispatch.batchAllocations.map(value => value.customerId)).toEqual(['customer-a', 'customer-b']); expect(wrapper.text()).not.toContain('共车'); wrapper.unmount()
 })
-it('opens quantity splitting for only the current batch without locking physical cargo or creating a new full-source appointment', async () => {
-  const wrapper = render(); await flushPromises()
-  await button(wrapper, '按当前批次箱数分批').trigger('click')
-  expect(wrapper.emitted('batch')).toEqual([['FBA_APPOINTMENT:1']])
-  expect(lockDispatchDraftPallet).not.toHaveBeenCalled(); expect(preArrangeDraftDispatch).not.toHaveBeenCalled(); wrapper.unmount()
+it('preserves exact distinct batch allocations while combining selected same-warehouse batches', async () => {
+  const otherKey = 'FBA_APPOINTMENT:2', second = row('9007199254740994', 'customer-b', otherKey); natives.push(candidate(second))
+  vi.mocked(getBatchDispatchCandidates).mockImplementation(async key => ({ batchKey: key, version: 4, candidates: [key === batch ? row() : second], blockReasons: [] }))
+  const wrapper = render({ batchKeys: [batch, otherKey] }); await flushPromises(); for (const input of wrapper.findAll('input[type="checkbox"]')) await input.setValue(true)
+  await button(wrapper, '创建整车排车单').trigger('click'); await flushPromises(); expect(vi.mocked(convertDispatchDraft).mock.calls[0]![0].groups[0]!.dispatch.batchAllocations).toEqual([...row().allocations, ...second.allocations]); wrapper.unmount()
 })
-it('preselects only eligible physical cargo of the entered batch, never unrelated allocations or unknown quantity', async () => {
-  vi.mocked(getBatchDispatchCandidates).mockResolvedValue({ batchKey: 'FBA_APPOINTMENT:1', version: 4, blockReasons: [], candidates: [candidate, { ...candidate, planPalletId: 'other-batch', allocations: [{ ...candidate.allocations[0]!, batchKey: 'FBA_APPOINTMENT:999' }] }, { ...candidate, planPalletId: 'unknown', packageCount: null }] })
-  const wrapper = render(); await flushPromises()
-  const inputs = wrapper.findAll('input[type=checkbox]')
-  expect(inputs.map(input => (input.element as HTMLInputElement).checked)).toEqual([true, false, false])
-  expect(inputs[1]!.attributes('disabled')).toBeDefined()
-  await button(wrapper, '创建本客户排车单').trigger('click'); await flushPromises()
-  expect(vi.mocked(preArrangeDraftDispatch).mock.calls[0]![0].groups[0]!.planPalletIds).toEqual([candidate.planPalletId])
-  expect(vi.mocked(preArrangeDraftDispatch).mock.calls[0]![0].groups[0]!.batchAllocations).toEqual(candidate.allocations)
-  wrapper.unmount()
+it('keeps blocked, mismatched-customer, wrong-source and unknown-quantity cargo out of the payload', async () => {
+  const blocked = { ...row('2'), blockReasons: ['本托已被其他排车占用'] }, wrong = row('3'), unknown = { ...row('4'), packageCount: null }, wrongSource = row('5')
+  wrong.allocations[0]!.customerId = 'customer-b'; wrongSource.allocations[0]!.sourceKey = 'ORDER:unrelated'; natives.push(...[blocked, wrong, unknown, wrongSource].map(value => candidate(value)))
+  vi.mocked(getBatchDispatchCandidates).mockResolvedValue({ batchKey: batch, version: 4, candidates: [row(), blocked, wrong, unknown, wrongSource], blockReasons: [] })
+  const wrapper = render(); await flushPromises(); expect(wrapper.findAll('input').map(input => (input.element as HTMLInputElement).checked)).toEqual([true, false, false, false, false])
+  expect(wrapper.text()).toContain('本托已被其他排车占用'); await button(wrapper, '创建整车排车单').trigger('click'); await flushPromises(); expect(vi.mocked(convertDispatchDraft).mock.calls[0]![0].groups[0]!.dispatch.batchAllocations).toEqual(row().allocations); wrapper.unmount()
 })
-it('replays a submitted draft without re-locking already dispatched pallets after an unknown response', async () => {
-  vi.mocked(preArrangeDraftDispatch).mockRejectedValueOnce(new Error('lost response'))
-  const wrapper = render(); await flushPromises(); await wrapper.get('input[type=checkbox]').setValue(true)
-  await button(wrapper, '创建本客户排车单').trigger('click'); await flushPromises()
-  const first = vi.mocked(preArrangeDraftDispatch).mock.calls[0]![0]
-  expect(await guard()).toBe(false)
-  await button(wrapper, '重试本次预排').trigger('click'); await flushPromises()
-  expect(preArrangeDraftDispatch).toHaveBeenNthCalledWith(2, first); expect(lockDispatchDraftPallet).toHaveBeenCalledTimes(1); expect(createDispatchDraftContainer).toHaveBeenCalledTimes(1)
-  wrapper.unmount()
+it('fails closed on incomplete native candidates, missing versions, and cross-warehouse batches', async () => {
+  vi.mocked(listDispatchCandidates).mockResolvedValueOnce({ candidates: natives, complete: false, snapshotAt: '' }); const incomplete = render(); await flushPromises(); expect(incomplete.text()).toContain('未完整返回'); expect(createDispatchDraft).not.toHaveBeenCalled(); incomplete.unmount()
+  natives[0]!.selection.sourceVersion = ''; const missing = render(); await flushPromises(); expect(missing.get('input').attributes('disabled')).toBeDefined(); missing.unmount()
+  vi.mocked(getReceivingContext).mockImplementation(async key => { const value = receiving(key); if (key !== batch) value.batch.originWarehouseId = 'another-warehouse'; return value })
+  const cross = render({ batchKeys: [batch, 'FBA_APPOINTMENT:2'] }); await flushPromises(); expect(cross.text()).toContain('相同的起运仓'); expect(convertDispatchDraft).not.toHaveBeenCalled(); cross.unmount()
 })
-it('recovers a draft container from the same token when its creation response was lost', async () => {
-  vi.mocked(createDispatchDraftContainer).mockRejectedValueOnce(new Error('lost create response'))
-  const wrapper = render(); await flushPromises(); await wrapper.get('input[type=checkbox]').setValue(true)
-  await button(wrapper, '创建本客户排车单').trigger('click'); await flushPromises()
-  const token = vi.mocked(createDispatchDraftContainer).mock.calls[0]![0]
-  vi.mocked(listDispatchDrafts).mockResolvedValue([{ draftToken: token, containers: [{ id: 'container-1', capacity: 30, palletIds: [] }] }])
-  await button(wrapper, '重试本次预排').trigger('click'); await flushPromises()
-  expect(createDispatchDraftContainer).toHaveBeenCalledTimes(1); expect(preArrangeDraftDispatch).toHaveBeenCalledTimes(1); wrapper.unmount()
+it('retains the entire original conversion and skips all prior locks after an unknown response, even after remount with the work closed', async () => {
+  vi.mocked(convertDispatchDraft).mockRejectedValueOnce(new Error('lost response'))
+  const wrapper = render(); await flushPromises(); await button(wrapper, '创建整车排车单').trigger('click'); await flushPromises(); const original = clone(vi.mocked(convertDispatchDraft).mock.calls[0]![0])
+  expect(await guard()).toBe(false); wrapper.unmount()
+  const restored = render({ canWrite: false }); await flushPromises(); expect(restored.text()).toContain('原请求已保留'); await button(restored, '核对并重试原请求').trigger('click'); await flushPromises()
+  expect(convertDispatchDraft).toHaveBeenNthCalledWith(2, original); expect(lockDispatchDraftPallet).toHaveBeenCalledTimes(1); expect(createDispatchDraftContainer).toHaveBeenCalledTimes(1); expect(restored.emitted('updated')).toHaveLength(1); restored.unmount()
 })
-it('shows server blockers and prevents mixing customers or selecting blocked physical cargo', async () => {
-  vi.mocked(getBatchDispatchCandidates).mockResolvedValue({ batchKey: 'FBA_APPOINTMENT:1', version: 4, blockReasons: [], candidates: [candidate, { ...candidate, planPalletId: '2', customerId: 'customer-b', allocations: [{ ...candidate.allocations[0]!, customerId: 'customer-b', planPalletId: '2' }] }, { ...candidate, planPalletId: '3', blockReasons: ['本托货量超过本批剩余可排量'] }] })
-  const wrapper = render(); await flushPromises(); const inputs = wrapper.findAll('input[type=checkbox]')
-  expect(inputs[2]!.attributes('disabled')).toBeDefined(); expect(wrapper.text()).toContain('本托货量超过本批剩余可排量')
-  await inputs[0]!.setValue(true); await inputs[1]!.setValue(true)
-  expect((inputs[1]!.element as HTMLInputElement).checked).toBe(false)
-  await button(wrapper, '创建本客户排车单').trigger('click'); await flushPromises()
-  expect(vi.mocked(preArrangeDraftDispatch).mock.calls[0]![0].groups[0]!.planPalletIds).toEqual([candidate.planPalletId]); wrapper.unmount()
+it('retries the exact container command after a lost response instead of generating another container key', async () => {
+  vi.mocked(createDispatchDraftContainer).mockRejectedValueOnce(new Error('unknown container'))
+  const wrapper = render(); await flushPromises(); await button(wrapper, '创建整车排车单').trigger('click'); await flushPromises(); const original = clone(vi.mocked(createDispatchDraftContainer).mock.calls[0]![0])
+  await button(wrapper, '核对并重试原请求').trigger('click'); await flushPromises(); expect(createDispatchDraftContainer).toHaveBeenNthCalledWith(2, original); expect(createDispatchDraft).toHaveBeenCalledTimes(1); expect(convertDispatchDraft).toHaveBeenCalledTimes(1); wrapper.unmount()
 })
-it('does not read or write scoped cargo without all original permissions', async () => {
-  access.allowed = false; const wrapper = render(); await flushPromises()
-  expect(getBatchDispatchCandidates).not.toHaveBeenCalled(); expect(preArrangeDraftDispatch).not.toHaveBeenCalled(); wrapper.unmount()
+it('keeps a proven CREATE across failed current-detail GET and only repeats the read', async () => {
+  vi.mocked(getDispatch).mockRejectedValueOnce(new Error('GET unavailable'))
+  const wrapper = render(); await flushPromises(); await button(wrapper, '创建整车排车单').trigger('click'); await flushPromises(); expect(convertDispatchDraft).toHaveBeenCalledTimes(1); expect(wrapper.emitted('updated')).toBeUndefined()
+  await button(wrapper, '核对并重试原请求').trigger('click'); await flushPromises(); expect(convertDispatchDraft).toHaveBeenCalledTimes(1); expect(getDispatch).toHaveBeenCalledTimes(2); expect(wrapper.emitted('updated')).toHaveLength(1); wrapper.unmount()
 })
-
-it('continues the actual later 60-box dispatch through the shared-trip entry without re-creating or reallocating cargo', async () => {
-  const sixty = { ...candidate, packageCount: 60, allocations: [{ ...candidate.allocations[0]!, packageCount: 60 }] }
-  vi.mocked(getBatchDispatchCandidates).mockResolvedValue({ batchKey: 'FBA_APPOINTMENT:1', version: 4, candidates: [sixty], blockReasons: [] })
-  vi.mocked(preArrangeDraftDispatch).mockResolvedValue([{ draftContainerId: 'container-1', dispatch: { id: 'internal-later', dispatchNo: 'DS-60', appointmentBatches: [], overseasWarehouseId: 'origin-1', packageCount: 60 } }])
-  const wrapper = render(); await flushPromises(); await button(wrapper, '创建本客户排车单').trigger('click'); await flushPromises()
-  await button(wrapper, '与同仓其他排车单共车').trigger('click'); await flushPromises()
-  const shared = wrapper.getComponent({ name: 'WorkSharedTripForm' })
-  expect(shared.props()).toMatchObject({ dispatchNo: 'DS-60', canWrite: true })
-  expect(preArrangeDraftDispatch).toHaveBeenCalledTimes(1); expect(vi.mocked(preArrangeDraftDispatch).mock.calls[0]![0].groups[0]!.batchAllocations).toEqual(sixty.allocations)
-  shared.vm.$emit('busy', true); await flushPromises(); expect(button(wrapper, '继续安排其他实物').attributes('disabled')).toBeDefined()
-  shared.vm.$emit('external', '/overseas-master-data/trips/TR-100'); expect(wrapper.emitted('external')).toEqual([['/overseas-master-data/trips/TR-100']])
-  wrapper.unmount()
+it('never releases an unknown result for a later rejection, and releases only an explicitly rejected owned draft at its read-back version', async () => {
+  vi.mocked(lockDispatchDraftPallet).mockRejectedValueOnce(new Error('unknown')).mockRejectedValueOnce(new ApiResponseError('conflict', 'A0409', 409))
+  const unknown = render(); await flushPromises(); await button(unknown, '创建整车排车单').trigger('click'); await flushPromises(); await button(unknown, '核对并重试原请求').trigger('click'); await flushPromises(); expect(unknown.text()).not.toContain('按明确拒绝结果释放'); expect(await guard()).toBe(false); unknown.unmount()
+  sessionStorage.clear(); vi.mocked(lockDispatchDraftPallet).mockRejectedValueOnce(new ApiResponseError('conflict', 'A0409', 409)); draft = { ...draft, draftToken: 'another-owned-token', containers: [], recordVersion: 0 }
+  const rejected = render(); await flushPromises(); await button(rejected, '创建整车排车单').trigger('click'); await flushPromises(); draft.recordVersion = 9
+  await button(rejected, '按明确拒绝结果释放本草稿并重新核对').trigger('click'); await flushPromises(); expect(releaseDispatchDraft).toHaveBeenCalledWith({ draftToken: 'another-owned-token', recordVersion: 9, idempotencyKey: expect.any(String) }); rejected.unmount()
+})
+it('preserves quantity-split navigation and uses create permission rather than the removed smart-dispatch permission', async () => {
+  access.denied = ['platform:overseas-warehouse:inbound-order:smart-dispatch']; const wrapper = render(); await flushPromises()
+  await button(wrapper, '按当前批次箱数分批').trigger('click'); expect(wrapper.emitted('batch')).toEqual([[batch]]); expect(lockDispatchDraftPallet).not.toHaveBeenCalled()
+  await button(wrapper, '创建整车排车单').trigger('click'); await flushPromises(); expect(convertDispatchDraft).toHaveBeenCalledTimes(1)
+  await button(wrapper, '为本车添加同仓货物').trigger('click'); expect(wrapper.getComponent({ name: 'WorkSharedTripForm' }).props('dispatchNo')).toBe('DS/001'); wrapper.unmount()
+})
+it('does not read scoped cargo without original permissions or create while only read access remains', async () => {
+  access.allowed = false; const denied = render(); await flushPromises(); expect(getReceivingContext).not.toHaveBeenCalled(); denied.unmount()
+  access.allowed = true; access.denied = ['platform:overseas-warehouse:dispatch:create']; const readonly = render(); await flushPromises(); expect(button(readonly, '创建整车排车单').attributes('disabled')).toBeDefined(); expect(createDispatchDraft).not.toHaveBeenCalled(); readonly.unmount()
+})
+it('shows batch-level blockers even without rows and refuses duplicate physical candidates across batches', async () => {
+  vi.mocked(getBatchDispatchCandidates).mockResolvedValueOnce({ batchKey: batch, version: 4, candidates: [], blockReasons: ['原批次已替代，请进入当前批次'] })
+  const blocked = render(); await flushPromises(); expect(blocked.get('[role="alert"]').text()).toContain('原批次已替代'); expect(createDispatchDraft).not.toHaveBeenCalled(); blocked.unmount()
+  const duplicate = render({ batchKeys: [batch, 'FBA_APPOINTMENT:2'] }); await flushPromises(); expect(duplicate.findAll('input').every(input => input.attributes('disabled') !== undefined)).toBe(true); expect(duplicate.text()).toContain('同一实物'); expect(convertDispatchDraft).not.toHaveBeenCalled(); duplicate.unmount()
 })

src/modules/appointment-calendar/WorkDispatchForm.vue

@@ -1,125 +1,222 @@
 <script setup lang="ts">
-import { computed, onMounted, ref } from 'vue'
+import InlineHelp from '@/shared/components/InlineHelp.vue'
+import { computed, onBeforeUnmount, onMounted, ref } from 'vue'
 import { ElMessage } from 'element-plus'
 import { useAccessPreviewStore } from '@/core/access/accessPreview'
-import { getBatchDispatchCandidates, createDispatchDraftContainer, listDispatchDrafts, lockDispatchDraftPallet, preArrangeDraftDispatch, releaseDispatchDraft, dispatchVehicleSpecs, type BatchDispatchCandidate, type BatchDispatchCandidates, type DispatchSummaryDto } from '@/modules/overseas-warehouse'
-import { TripPreparationDialog } from '@/modules/overseas-master-data'
+import { useAuthStore } from '@/core/auth/auth'
+import { getDispatch, getBatchDispatchCandidates, listDispatchCandidates, createDispatchDraft, createDispatchDraftContainer, listDispatchDrafts, lockDispatchDraftPallet, convertDispatchDraft, releaseDispatchDraft, dispatchVehicleSpecs, DispatchInputError, requireVersion, requireBatchVersions, validateCommandResult, validateCurrentDispatch, isDefiniteDispatchRejection, type BatchDispatchCandidate, type BatchDispatchCandidates, type Candidate, type DispatchDetail, type DispatchDraft, type ConvertDraft, type ConvertedDraft, type DraftSelection, type VersionCommand } from '@/modules/overseas-warehouse'
 import LoadErrorState from '@/shared/components/LoadErrorState.vue'
 import ApiErrorMeta from '@/shared/components/ApiErrorMeta.vue'
-import { ApiResponseError, getApiErrorDetails, type ApiErrorDetails } from '@/shared/api/http'
+import { getApiErrorDetails, type ApiErrorDetails } from '@/shared/api/http'
 import WorkSharedTripForm from './WorkSharedTripForm.vue'
 import WorkExistingDispatchForm from './WorkExistingDispatchForm.vue'
 import { getReceivingContext } from './receivingApi'
-import { rejectedCommand, useWorkDraft } from './useWorkDraft'
+import { useWorkDraft } from './useWorkDraft'
 const props = defineProps<{ batchKeys: string[]; canWrite: boolean }>()
 const emit = defineEmits<{ updated: []; external: [path: string]; batch: [key: string] }>()
-const access = useAccessPreviewStore(), contexts = ref<BatchDispatchCandidates[]>([]), selected = ref<string[]>([])
+type BatchRow = BatchDispatchCandidate & { key: string; batchKey: string; native: Candidate | null; blockReasons: string[] }
+type ReadyRow = BatchRow & { native: Candidate }
+type Step = { action: 'CREATE' | 'CONTAINER' | 'LOCK' | 'CONVERT' | 'RELEASE'; body: Record<string, unknown>; attempted: boolean; rejected: boolean }
+type Preparation = { warehouseId: string; capacity: number; rows: ReadyRow[]; dispatchKey: string; draft: DispatchDraft | null; containerId: string | null; lockedKeys: string[]; step: Step | null; converted: ConvertedDraft | null; releasing: boolean }
+const access = useAccessPreviewStore(), auth = useAuthStore(), owner = auth.user?.id || ''
+const scope = JSON.stringify([...new Set(props.batchKeys)].sort()), storageKey = `appointment-dispatch:${owner}:${scope}`
+const contexts = ref<BatchDispatchCandidates[]>([]), rows = ref<BatchRow[]>([]), selected = ref<string[]>([]), warehouseId = ref('')
 const loading = ref(false), saving = ref(false), error = ref<ApiErrorDetails | null>(null), saveError = ref<ApiErrorDetails | null>(null)
-const capacity = ref(30), result = ref<DispatchSummaryDto | null>(null), prepareOpen = ref(false), rejected = ref(false)
-const sharedTripOpen = ref(false), sharedTripBusy = ref(false)
-const existingDispatches = ref<Array<{ batchKey: string; dispatchNo: string; customerId: string }>>([]), arrangingRemaining = ref(false)
-const existingReady = ref(false)
-const selectionBaseline = ref('[]')
-const pending = ref<{ token: string; capacity: number; rows: BatchDispatchCandidate[]; containerId: string | null; lockedIds: string[]; submitting: boolean } | null>(null)
-const readable = computed(() => ['platform:appointment:list', 'platform:overseas-warehouse:last-mile-order:list', 'platform:overseas-warehouse:inbound-order:list'].every(permission => access.can(permission)))
-const writable = computed(() => props.canWrite && readable.value && (!existingDispatches.value.length || existingReady.value) && access.can('platform:overseas-warehouse:inbound-order:smart-dispatch'))
-const rows = computed(() => contexts.value.flatMap(context => context.candidates.map(row => ({ ...row, blockReasons: [...context.blockReasons, ...row.blockReasons] }))))
-function reasons(row: BatchDispatchCandidate) {
-  const duplicates = rows.value.filter(other => other.planPalletId === row.planPalletId).length > 1
-  return [...row.blockReasons, ...(row.packageCount == null || row.packageCount <= 0 ? ['实物箱数待核实'] : []), ...(!row.allocations.length ? ['缺少逐来源批次分配'] : []), ...(row.allocations.some(allocation => !props.batchKeys.includes(allocation.batchKey) || allocation.customerId !== row.customerId) ? ['候选不属于当前批次和客户范围'] : []), ...(duplicates ? ['同一实物出现在多个批次，请核对分批范围'] : [])]
-}
-const chosen = computed(() => rows.value.filter(row => selected.value.includes(row.planPalletId)))
-useWorkDraft(computed(() => JSON.stringify(selected.value) !== selectionBaseline.value && !result.value), computed(() => saving.value || !!pending.value))
+const capacity = ref(30), result = ref<DispatchDetail | null>(null), pending = ref<Preparation | null>(null), corrupted = ref(false)
+const adding = ref(false), addingBusy = ref(false), arrangingRemaining = ref(false), existingReady = ref(false)
+const existing = ref<Array<{ batchKey: string; dispatchNo: string; customerId: string }>>([]), baseline = ref('[]')
+const readable = computed(() => ['platform:appointment:list', 'platform:overseas-warehouse:last-mile-order:list', 'platform:overseas-warehouse:inbound-order:list', 'platform:overseas-warehouse:dispatch:list'].every(permission => access.can(permission)))
+const canCreate = computed(() => readable.value && access.can('platform:overseas-warehouse:dispatch:create'))
+const writable = computed(() => props.canWrite && canCreate.value && !corrupted.value && (!existing.value.length || existingReady.value))
+const chosen = computed(() => rows.value.filter(row => selected.value.includes(row.key)))
+const unresolved = computed(() => saving.value || Boolean(pending.value) || corrupted.value)
+useWorkDraft(computed(() => JSON.stringify(selected.value) !== baseline.value && !result.value), unresolved)
+const clone = <T,>(value: T): T => JSON.parse(JSON.stringify(value)) as T
+let generation = 0
+function ensureOwner() { if (!owner || auth.user?.id !== owner || JSON.stringify([...new Set(props.batchKeys)].sort()) !== scope) throw new DispatchInputError('排车登录身份或批次范围已变化，请重新进入原事项') }
+function persist() { ensureOwner(); if (pending.value) sessionStorage.setItem(storageKey, JSON.stringify(pending.value)); else sessionStorage.removeItem(storageKey) }
+try { const saved = owner && sessionStorage.getItem(storageKey); if (saved) pending.value = JSON.parse(saved) as Preparation }
+catch { corrupted.value = true; saveError.value = { message: '原排车请求记录损坏，请保留现场核对，不能另建排车单' } }
+function reasons(row: BatchRow) { return row.blockReasons }
+function physicalCount(values: BatchRow[]) { return new Set(values.map(row => row.native?.selection.warehousePalletId || row.native?.sourceKey || row.key)).size }
+function detailPath(no: string) { return `/overseas-warehouse/dispatches/${encodeURIComponent(no)}` }
 async function load() {
-  if (!readable.value || pending.value) return
-  loading.value = true; error.value = null; existingReady.value = false
+  if (!readable.value || pending.value || corrupted.value) return
+  const current = ++generation, batches = [...new Set(props.batchKeys)]
+  loading.value = true; error.value = null; existingReady.value = false; rows.value = []; selected.value = []; baseline.value = '[]'; contexts.value = []
   try {
-    // 从服务端当前运输关系恢复排车单；读取失败时禁止退回创建流程。
-    const batches = [...new Set(props.batchKeys)]
-    const receiving = await Promise.all(batches.map(batch => getReceivingContext(batch)))
-    const references: typeof existingDispatches.value = []
+    if (!batches.length || batches.some(key => !/^FBA_APPOINTMENT:\d+$/.test(key))) throw new DispatchInputError('请从真实预约批次进入排车，不能重组其他业务批次')
+    const receiving = await Promise.all(batches.map(key => getReceivingContext(key)))
+    if (current !== generation) return
+    const references: typeof existing.value = []
     receiving.forEach((context, index) => {
       const batchKey = batches[index]!
-      if (context.batch.batchKey !== batchKey) throw new ApiResponseError('运输关系与当前预约批次不一致，请重新读取', 'WORK_DISPATCH_MISMATCH')
+      if (context.batch.batchKey !== batchKey) throw new DispatchInputError('运输关系与当前预约批次不一致，请重新读取')
       for (const vehicle of context.transport.vehicles.filter(row => row.batchKey === batchKey && row.status !== 'CANCELLED')) {
-        if (!vehicle.dispatchNo) throw new ApiResponseError('本批已有运输安排但缺少排车单号，请核对原车次', 'WORK_DISPATCH_MISMATCH')
+        if (!vehicle.dispatchNo) throw new DispatchInputError('本批已有运输安排但缺少排车单号，请核对原记录')
         references.push({ batchKey, dispatchNo: vehicle.dispatchNo, customerId: vehicle.customerId })
       }
     })
-    existingDispatches.value = references
-    contexts.value = []; selected.value = []; selectionBaseline.value = '[]'
+    existing.value = references
     if (references.length && !arrangingRemaining.value) return
-    contexts.value = await Promise.all(batches.map(batch => getBatchDispatchCandidates(batch)))
-    const eligible = rows.value.filter(row => !reasons(row).length && row.packageCount != null && row.packageCount > 0)
-    selected.value = props.batchKeys.length === 1 && eligible.length <= capacity.value && new Set(eligible.map(row => row.customerId)).size === 1 ? eligible.map(row => row.planPalletId) : []
-    selectionBaseline.value = JSON.stringify(selected.value)
-  }
-  catch (cause) { error.value = getApiErrorDetails(cause, '批次可排实物读取失败') }
-  finally { loading.value = false }
+    const origins = [...new Set(receiving.map(context => context.batch.originWarehouseId).filter(Boolean))]
+    if (origins.length !== 1 || receiving.some(context => !context.batch.originWarehouseId)) throw new DispatchInputError('所选批次须有明确且相同的起运仓，请从同仓批次继续')
+    warehouseId.value = origins[0]!
+    const batchCandidates = await Promise.all(batches.map(key => getBatchDispatchCandidates(key)))
+    if (current !== generation) return
+    if (batchCandidates.some((context, index) => context.batchKey !== batches[index])) throw new DispatchInputError('实物候选与当前预约批次不一致')
+    requireBatchVersions(batchCandidates.flatMap(context => context.candidates.flatMap(row => row.allocations)))
+    contexts.value = batchCandidates
+    const planIds = [...new Set(batchCandidates.flatMap(context => context.candidates.map(row => row.planId)))]
+    const native = planIds.length ? await listDispatchCandidates({ warehouseId: warehouseId.value, planIds }) : { candidates: [], complete: true }
+    if (current !== generation) return
+    requireBatchVersions([...batchCandidates.flatMap(context => context.candidates.flatMap(row => row.allocations)), ...native.candidates.flatMap(row => row.appointmentBatches)])
+    if (native.complete !== true) throw new DispatchInputError('本仓原生候选未完整返回，不能按部分结果建单')
+    rows.value = batchCandidates.flatMap((context, index) => context.candidates.map(row => {
+      const matches = native.candidates.filter(value => value.selection.sourceType === 'INBOUND_PLAN' && value.selection.planPalletId === row.planPalletId && value.customerId === row.customerId)
+      const candidate = matches.length === 1 ? matches[0]! : null
+      const sources = receiving[index]!.batch.items
+      const blocks = [...context.blockReasons, ...row.blockReasons]
+      if (!candidate || candidate.warehouseId !== warehouseId.value || !candidate.sourceVersion || candidate.selection.sourceVersion !== candidate.sourceVersion) blocks.push('原生实物来源、起运仓或版本待核实')
+      if (candidate) blocks.push(...candidate.blockReasons)
+      if (row.packageCount == null || row.packageCount <= 0 || candidate && candidate.availablePackages !== row.packageCount) blocks.push('批次箱数与本托真实可排量不一致，请核对分批或拆托')
+      if (!row.allocations.length || row.allocations.some(allocation => allocation.planPalletId !== row.planPalletId || allocation.customerId !== row.customerId || allocation.batchKey !== context.batchKey || !Number.isInteger(allocation.packageCount) || allocation.packageCount <= 0 || !sources.some(source => source.customerId === allocation.customerId && source.sourceKey === allocation.sourceKey && source.destinationKey === allocation.destinationKey && source.packageCount != null && source.packageCount >= allocation.packageCount))) blocks.push('候选不属于当前批次、客户和真实来源范围')
+      if (row.allocations.reduce((sum, allocation) => sum + allocation.packageCount, 0) !== row.packageCount) blocks.push('逐来源批次分配与实物箱数不一致')
+      return { ...row, key: `${context.batchKey}:${row.customerId}:${row.planPalletId}`, batchKey: context.batchKey, native: candidate, blockReasons: [...new Set(blocks)] }
+    }))
+    for (const row of rows.value) if (row.native && rows.value.filter(other => other.native?.sourceKey === row.native!.sourceKey).length > 1) row.blockReasons.push('同一实物出现在多条批次候选，请先核对分配范围')
+    const eligible = rows.value.filter(row => !reasons(row).length)
+    selected.value = batches.length === 1 && physicalCount(eligible) <= capacity.value ? eligible.map(row => row.key) : []
+    baseline.value = JSON.stringify(selected.value)
+  } catch (cause) { if (current === generation) error.value = getApiErrorDetails(cause, cause instanceof DispatchInputError ? cause.message : '批次可排实物读取失败') }
+  finally { if (current === generation) loading.value = false }
 }
-function select(row: BatchDispatchCandidate, checked: boolean) {
-  if (!writable.value || pending.value || saving.value || loading.value || error.value || reasons(row).length) return
-  if (!checked) { selected.value = selected.value.filter(id => id !== row.planPalletId); return }
-  if (selected.value.includes(row.planPalletId)) return
-  if (chosen.value.some(current => current.customerId !== row.customerId)) { ElMessage.warning('一张排车单只选择同一客户实物；其余客户可继续分别安排'); return }
-  if (selected.value.length >= capacity.value) { ElMessage.warning('已达到所选车型托位上限'); return }
-  selected.value = [...selected.value, row.planPalletId]
-}
-function changeSelection(row: BatchDispatchCandidate, event: Event) {
+function select(row: BatchRow, event: Event) {
   const input = event.target as HTMLInputElement
-  select(row, input.checked); input.checked = selected.value.includes(row.planPalletId)
+  if (!writable.value || unresolved.value || loading.value || error.value || reasons(row).length) { input.checked = selected.value.includes(row.key); return }
+  if (!input.checked) selected.value = selected.value.filter(key => key !== row.key)
+  else if (!selected.value.includes(row.key)) {
+    if (physicalCount([...chosen.value, row]) > capacity.value) ElMessage.warning('已达到本组计划托位上限，请核对实际托盘')
+    else selected.value.push(row.key)
+  }
+  input.checked = selected.value.includes(row.key)
+}
+function step(action: Step['action'], body: object) { pending.value!.step = { action, body: clone(body) as Record<string, unknown>, attempted: false, rejected: false }; persist() }
+function common(draft: DispatchDraft) { return { recordVersion: requireVersion(draft.recordVersion), idempotencyKey: crypto.randomUUID(), draftToken: draft.draftToken } }
+async function executeStep() {
+  const request = pending.value!, command = request.step!, previouslyAttempted = command.attempted
+  command.attempted = true; persist()
+  try {
+    let value: DispatchDraft | ConvertedDraft
+    if (command.action === 'CREATE') value = await createDispatchDraft(command.body as unknown as { idempotencyKey: string; warehouseId: string })
+    else if (command.action === 'CONTAINER') value = await createDispatchDraftContainer(command.body as unknown as VersionCommand & { draftToken: string; capacity: number })
+    else if (command.action === 'LOCK') value = await lockDispatchDraftPallet(command.body as unknown as DraftSelection)
+    else if (command.action === 'RELEASE') value = await releaseDispatchDraft(command.body as unknown as VersionCommand & { draftToken: string })
+    else value = await convertDispatchDraft(command.body as unknown as ConvertDraft)
+    ensureOwner()
+    if (!value.draftToken || command.body.draftToken && value.draftToken !== command.body.draftToken) throw new DispatchInputError('草稿结果与原请求不一致，请保留原请求')
+    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 })
+      request.converted = converted
+    } else {
+      const draft = value as DispatchDraft; requireVersion(draft.recordVersion)
+      if (draft.warehouseId !== request.warehouseId) throw new DispatchInputError('草稿起运仓与原批次不一致')
+      if (command.action === 'CONTAINER') {
+        if (draft.containers.length !== 1) throw new DispatchInputError('本次草稿装车容器不唯一，请保留原请求核对')
+        request.containerId = draft.containers[0]!.draftContainerId
+      }
+      if (command.action === 'LOCK') {
+        const selectedSource = command.body.source as DraftSelection['source']
+        const expected = request.rows.find(row => row.native.selection.planPalletId === selectedSource.planPalletId && row.native.selection.sourceType === selectedSource.sourceType && row.native.sourceVersion === selectedSource.sourceVersion)
+        const source = expected && draft.sources.find(row => row.sourceKey === expected.native.sourceKey && row.customerId === expected.customerId)
+        if (!source || !draft.containers.find(row => row.draftContainerId === request.containerId)?.sourceKeys.includes(source.sourceKey)) throw new DispatchInputError('原来源未确认进入本装车组，请核对原请求')
+        request.lockedKeys.push(source.sourceKey)
+      }
+      request.draft = draft
+    }
+    request.step = null; persist()
+  } catch (cause) {
+    ensureOwner(); if (!previouslyAttempted && isDefiniteDispatchRejection(cause)) command.rejected = true
+    persist(); throw cause
+  }
 }
 async function save() {
-  if (!writable.value || saving.value || loading.value || error.value || result.value) return
-  if (!pending.value) {
-    if (!chosen.value.length || chosen.value.length > capacity.value || chosen.value.some(row => reasons(row).length) || new Set(chosen.value.map(row => row.customerId)).size !== 1) { ElMessage.warning('请核对所选客户、实物资格和托位数量'); return }
-    pending.value = { token: crypto.randomUUID(), capacity: capacity.value, rows: structuredClone(chosen.value.map(row => ({ ...row, allocations: row.allocations.map(allocation => ({ ...allocation })), blockReasons: [...row.blockReasons] }))), containerId: null, lockedIds: [], submitting: false }
-  }
-  saving.value = true; saveError.value = null; rejected.value = false
+  if (saving.value || loading.value || corrupted.value || !canCreate.value) return
+  saveError.value = null
   try {
-    const request = pending.value
-    if (!request.containerId) {
-      const drafts = await listDispatchDrafts(), existing = drafts.find(draft => draft.draftToken === request.token)?.containers || []
-      if (existing.length > 1) throw new Error('本次草稿出现多组装车容器，请核对保存结果')
-      request.containerId = existing[0]?.id || (await createDispatchDraftContainer(request.token, request.capacity)).id
+    ensureOwner()
+    if (!pending.value) {
+      if (!writable.value || error.value || result.value || !chosen.value.length || chosen.value.some(row => reasons(row).length || !row.native) || physicalCount(chosen.value) > capacity.value) throw new DispatchInputError('请核对本仓实物资格、来源批次与计划托位')
+      pending.value = { warehouseId: warehouseId.value, capacity: capacity.value, rows: clone(chosen.value) as ReadyRow[], dispatchKey: crypto.randomUUID(), draft: null, containerId: null, lockedKeys: [], step: null, converted: null, releasing: false }; persist()
     }
-    if (!request.submitting) for (const row of request.rows) if (!request.lockedIds.includes(row.planPalletId)) { await lockDispatchDraftPallet(row.planPalletId, request.token, request.containerId); request.lockedIds.push(row.planPalletId) }
-    request.submitting = true
-    const response = await preArrangeDraftDispatch({ draftToken: request.token, groups: [{ draftContainerId: request.containerId, planPalletIds: request.rows.map(row => row.planPalletId), returnReceiptIds: [], batchAllocations: request.rows.flatMap(row => row.allocations) }] })
-    if (response.length !== 1 || response[0]?.draftContainerId !== request.containerId || !response[0].dispatch.dispatchNo) throw new Error('排车结果与本次分组不一致，请重试核对原请求')
-    result.value = response[0].dispatch; pending.value = null; selected.value = []
-    ElMessage.success(`排车单 ${result.value.dispatchNo} 已创建`); emit('updated')
-  } catch (cause) { saveError.value = getApiErrorDetails(cause, '本次排车结果待确认，请重试原请求'); rejected.value = rejectedCommand(cause) }
+    saving.value = true
+    const request = pending.value
+    while (!request.converted) {
+      if (!request.step) {
+        if (request.releasing) { step('RELEASE', common(request.draft!)) }
+        else if (!request.draft) step('CREATE', { idempotencyKey: crypto.randomUUID(), warehouseId: request.warehouseId })
+        else if (!request.containerId) step('CONTAINER', { ...common(request.draft), capacity: request.capacity })
+        else {
+          const next = request.rows.find(row => !request.lockedKeys.includes(row.native.sourceKey))
+          if (next) step('LOCK', { ...common(request.draft), draftContainerId: request.containerId, source: next.native.selection })
+          else {
+            const cargo = [...new Set(request.rows.map(row => row.native.sourceKey))].map(key => request.draft!.sources.find(source => source.sourceKey === key))
+            if (cargo.some(source => !source || source.warehouseId !== request.warehouseId || !source.sourceVersion || source.selection.sourceVersion !== source.sourceVersion || request.rows.some(row => row.native.sourceKey === source.sourceKey && row.customerId !== source.customerId))) throw new DispatchInputError('草稿真实来源尚未完整恢复，请保留原请求核对')
+            step('CONVERT', { ...common(request.draft), groups: [{ draftContainerId: request.containerId, dispatch: { idempotencyKey: request.dispatchKey, warehouseId: request.warehouseId, vehicle: null, driver: null, plannedDepartureAt: null, estimatedArrivalAt: null, remark: null, cargo: cargo.map(source => source!.selection), batchAllocations: request.rows.flatMap(row => row.allocations) } }] } satisfies ConvertDraft)
+          }
+        }
+      }
+      await executeStep()
+      if (request.releasing) { pending.value = null; persist(); selected.value = []; await load(); return }
+    }
+    // Immutable CREATE proof is persisted before reading current facts; GET failure never reconverts.
+    const proof = request.converted!.vehicles[0]!.dispatch, latest = await getDispatch(proof.dispatchNo)
+    ensureOwner(); validateCurrentDispatch(latest, proof)
+    result.value = latest; pending.value = null; persist(); selected.value = []; baseline.value = '[]'
+    ElMessage.success(`整车排车单 ${latest.dispatchNo} 已创建`); emit('updated')
+  } catch (cause) { saveError.value = getApiErrorDetails(cause, cause instanceof DispatchInputError ? cause.message : '本次整车结果待确认，请核对并重试原请求') }
   finally { saving.value = false }
 }
-async function refreshRejected() {
-  if (!rejected.value || !pending.value || saving.value) return
-  saving.value = true
-  try { await releaseDispatchDraft(pending.value.token); pending.value = null; selected.value = []; rejected.value = false; await load() }
-  catch (cause) { saveError.value = getApiErrorDetails(cause, '本次草稿尚未释放，请重试') }
+async function releaseRejected() {
+  if (saving.value || !pending.value?.step?.rejected || pending.value.converted) return
+  saving.value = true; saveError.value = null
+  try {
+    ensureOwner(); const request = pending.value
+    if (!request.draft) { pending.value = null; persist(); return }
+    const owned = (await listDispatchDrafts()).find(row => row.draftToken === request.draft!.draftToken)
+    ensureOwner()
+    if (!owned || owned.warehouseId !== request.warehouseId) throw new DispatchInputError('原拥有者草稿尚未读回，请保留现场核对')
+    request.draft = owned; request.releasing = true; request.step = null; persist()
+  } catch (cause) { saveError.value = getApiErrorDetails(cause, cause instanceof DispatchInputError ? cause.message : '原草稿版本读取失败') }
   finally { saving.value = false }
+  if (pending.value?.releasing) await save()
+  else if (!pending.value) await load()
 }
-function tripSaved(value: { trip: { tripNo: string } }) { prepareOpen.value = false; emit('updated'); emit('external', `/overseas-master-data/trips/${encodeURIComponent(value.trip.tripNo)}`) }
-async function continueArranging() { if (!pending.value && !saving.value && !sharedTripBusy.value) { sharedTripOpen.value = false; result.value = null; arrangingRemaining.value = true; await load() } }
+async function remaining() { if (!unresolved.value && !addingBusy.value) { result.value = null; adding.value = false; arrangingRemaining.value = true; await load() } }
 onMounted(load)
+onBeforeUnmount(() => { generation++ })
 </script>
 <template>
-  <section class="work-form" aria-label="按预约批次排车">
-    <h3>{{ existingDispatches.length ? '沿用本批已有排车单' : '按批次选择真实托盘' }}</h3><p>已有排车单沿用原实物安排车辆；只有尚未分配的实物才需要创建排车单。</p>
-    <el-button v-if="batchKeys.length === 1 && !result && !existingDispatches.length" :disabled="loading || saving || !!pending" @click="emit('batch', batchKeys[0]!)">按当前批次箱数分批</el-button><p v-if="batchKeys.length === 1 && !result && !existingDispatches.length">只安排部分箱数时，先核对本批逐来源数量并分批；新的当前批次继续使用原排车资格。若箱数无法对应完整实物，请先在原库存作业中完成拆托；不把整票重新选入。</p>
-    <p v-if="!readable">读取批次实物需要预约、尾程订单和入仓单列表权限。</p>
+  <section class="work-form" aria-label="按预约批次创建整车排车">
+    <h3>{{ existing.length ? '沿用本批已有排车单' : '按批次选择同仓真实货物' }} <InlineHelp title="排车说明"><p>同一张排车单可装同仓多个客户与目的仓，客户和预约归属逐来源保留。</p></InlineHelp></h3>
+    <p v-if="!readable">读取批次实物需要预约、尾程订单、入仓单和排车列表权限。</p>
     <LoadErrorState v-if="error" title="批次可排实物读取失败" :message="error.message" :loading="loading" @retry="load"><template #details><ApiErrorMeta :details="error" /></template></LoadErrorState>
-    <p v-if="loading">正在核对批次、客户与实物来源…</p>
-    <template v-if="existingDispatches.length && !loading && !error && !result">
-      <WorkExistingDispatchForm :key="JSON.stringify(existingDispatches)" :dispatches="existingDispatches" :can-write="canWrite" @ready="existingReady = $event" @updated="emit('updated')" @external="path => emit('external', path)" />
-      <el-button v-if="!arrangingRemaining && writable" @click="continueArranging">核对本批剩余可排实物</el-button>
+    <p v-if="loading">正在核对批次、客户、起运仓与实物来源…</p>
+    <template v-if="existing.length && !loading && !error && !result && !pending">
+      <WorkExistingDispatchForm :key="JSON.stringify(existing)" :dispatches="existing" :can-write="canWrite" @ready="existingReady = $event" @updated="emit('updated')" @external="path => emit('external', path)" />
+      <el-button v-if="!arrangingRemaining && writable" @click="remaining">核对本批剩余可排实物</el-button>
     </template>
-    <template v-if="result"><p>已创建排车单：{{ result.dispatchNo }}</p><el-button v-if="result.overseasWarehouseId && access.can('platform:fleet:trip:list') && access.can('platform:fleet:trip:edit')" type="primary" :disabled="sharedTripBusy" @click="prepareOpen = true">继续安排本批车辆</el-button><el-button v-if="access.can('platform:overseas-warehouse:dispatch:list') && access.can('platform:fleet:trip:list') && access.can('platform:fleet:trip:edit')" @click="sharedTripOpen = true">与同仓其他排车单共车</el-button><WorkSharedTripForm v-if="sharedTripOpen" :dispatch-no="result.dispatchNo" :can-write="canWrite" @busy="sharedTripBusy = $event" @updated="emit('updated')" @external="path => emit('external', path)" /><p v-if="!result.overseasWarehouseId">排车结果未提供起运仓，需在原排车单核对。</p><el-button v-if="access.can('platform:overseas-warehouse:dispatch:list')" @click="emit('external', `/overseas-warehouse/dispatches?dispatchNo=${encodeURIComponent(result.dispatchNo)}`)">查看原排车单</el-button><el-button :disabled="sharedTripBusy" @click="continueArranging">继续安排其他实物</el-button></template>
-    <template v-else-if="readable && !loading && !error && (!existingDispatches.length || arrangingRemaining && existingReady)"><p v-for="reason in contexts.flatMap(context => context.blockReasons)" :key="reason">{{ reason }}</p><label>预排车型<select v-model.number="capacity" :disabled="saving || !!pending || !writable"><option v-for="spec in dispatchVehicleSpecs" :key="spec.value" :value="spec.capacity">{{ spec.label }}</option></select></label>
-      <table class="density-table"><thead><tr><th>选择</th><th>托盘码</th><th>入库单号</th><th>来源</th><th>箱数</th><th>不可选择原因</th></tr></thead><tbody><tr v-for="(row, index) in rows" :key="`${row.planPalletId}:${index}`"><td><input type="checkbox" :checked="selected.includes(row.planPalletId)" :disabled="!writable || loading || saving || !!pending || !!error || !!reasons(row).length" @change="changeSelection(row, $event)"></td><td>{{ row.palletNo || '—' }}</td><td>{{ row.planNo || '—' }}</td><td>{{ row.sourceStage === 'RECEIVED' ? '已收货实物' : row.sourceStage === 'PLAN' ? '计划托盘' : '原业务来源' }}</td><td>{{ row.packageCount ?? '待核实' }}</td><td>{{ reasons(row).join('；') || '可选' }}</td></tr></tbody></table>
-      <p v-if="!loading && !error && !rows.length">当前批次尚无可排实物。</p><el-button type="primary" :disabled="!writable || loading || !!error" :loading="saving" @click="save">{{ pending ? '重试本次预排' : '创建本客户排车单' }}</el-button>
+    <template v-if="result"><p>已创建整车排车单：{{ result.dispatchNo }}</p><el-button @click="emit('external', detailPath(result.dispatchNo))">继续维护本车</el-button><el-button v-if="canWrite && access.can('platform:overseas-warehouse:dispatch:edit') && result.actions.ADD_CARGO?.allowed === true" @click="adding = true">为本车添加同仓货物</el-button><WorkSharedTripForm v-if="adding" :dispatch-no="result.dispatchNo" :can-write="canWrite" @busy="addingBusy = $event" @updated="emit('updated')" @external="path => emit('external', path)" /><el-button :disabled="addingBusy" @click="remaining">继续核对剩余实物</el-button></template>
+    <template v-else-if="!pending && !corrupted && readable && !loading && !error && (!existing.length || arrangingRemaining && existingReady)">
+      <p v-for="reason in [...new Set(contexts.flatMap(context => context.blockReasons))]" :key="reason" role="alert">{{ reason }}</p>
+      <el-button v-if="batchKeys.length === 1" :disabled="!writable || unresolved" @click="emit('batch', batchKeys[0]!)">按当前批次箱数分批</el-button><p>部分箱数先按本批逐来源数量分批；不对应完整实物时，先在原库存作业拆托。</p>
+      <label>本组计划托位<select v-model.number="capacity" :disabled="!writable || unresolved"><option v-for="spec in dispatchVehicleSpecs" :key="spec.value" :value="spec.capacity">{{ spec.label }}</option></select></label>
+      <table class="density-table"><thead><tr><th>选择</th><th>客户</th><th>托盘码</th><th>入库单号</th><th>来源</th><th>箱数</th><th>不可选择原因</th></tr></thead><tbody><tr v-for="(row, index) in rows" :key="`${row.key}:${index}`"><td><input type="checkbox" :checked="selected.includes(row.key)" :disabled="!writable || unresolved || reasons(row).length > 0" @change="select(row, $event)"></td><td>{{ row.native?.customerName || '客户待核实' }}</td><td>{{ row.palletNo || '—' }}</td><td>{{ row.planNo || '—' }}</td><td>{{ row.sourceStage === 'RECEIVED' ? '已收货实物' : '计划托盘' }}</td><td>{{ row.packageCount ?? '待核实' }}</td><td>{{ reasons(row).join('；') || '可选' }}</td></tr></tbody></table><p v-if="!rows.length">当前批次尚无可排实物。</p>
+      <el-button type="primary" :disabled="!writable || !chosen.length" :loading="saving" @click="save">创建整车排车单</el-button>
     </template>
-    <LoadErrorState v-if="saveError" title="排车尚未完成" :message="saveError.message" :show-retry="false"><template #details><ApiErrorMeta :details="saveError" /></template></LoadErrorState><el-button v-if="rejected && pending" :loading="saving" @click="refreshRejected">释放本次草稿并重新核对</el-button>
-    <TripPreparationDialog v-if="result?.overseasWarehouseId" v-model="prepareOpen" :warehouse-id="result.overseasWarehouseId" :warehouse-name="result.overseasWarehouseName || '起运仓待核实'" :dispatch-nos="[result.dispatchNo]" @saved="tripSaved" />
+    <p v-if="pending" role="status">本次草稿与原请求已保留，请勿改变来源、版本或另建排车单。<el-button :disabled="!canCreate || saving" :loading="saving" @click="save">核对并重试原请求</el-button></p>
+    <LoadErrorState v-if="saveError" title="排车尚未完成" :message="saveError.message" :show-retry="false"><template #details><ApiErrorMeta :details="saveError" /></template></LoadErrorState><el-button v-if="pending?.step?.rejected && !pending.converted" :loading="saving" @click="releaseRejected">按明确拒绝结果释放本草稿并重新核对</el-button>
   </section>
 </template>

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

@@ -1,43 +1,42 @@
 import { flushPromises, mount } from '@vue/test-utils'
 import { beforeEach, expect, it, vi } from 'vitest'
 import WorkExistingDispatchForm from './WorkExistingDispatchForm.vue'
-import { getDispatch } from '@/modules/overseas-warehouse'
-const state = vi.hoisted(() => ({ allowed: true }))
-vi.mock('@/core/access/accessPreview', () => ({ useAccessPreviewStore: () => ({ can: () => state.allowed }) }))
+import { getDispatch, type DispatchDetail } from '@/modules/overseas-warehouse'
+import { resolveBatchWork } from './workApi'
+import { workDetail, workItem } from './work.test-support'
+const access = vi.hoisted(() => ({ allowed: true }))
+vi.mock('@/core/access/accessPreview', () => ({ useAccessPreviewStore: () => ({ can: () => access.allowed }) }))
 vi.mock('@/modules/overseas-warehouse', async original => ({ ...await original<typeof import('@/modules/overseas-warehouse')>(), getDispatch: vi.fn() }))
-function render(dispatches: Array<{ batchKey: string; dispatchNo: string; customerId?: string }> = [{ batchKey: 'DISPATCH:9007199254740999', dispatchNo: 'DS-ORIGINAL' }]) { return mount(WorkExistingDispatchForm, { props: { dispatches, canWrite: true }, global: { stubs: { ElButton: { props: ['disabled'], template: '<button :disabled="disabled"><slot /></button>' }, LoadErrorState: { props: ['message'], template: '<p>{{ message }}</p>' }, ApiErrorMeta: true, TripPreparationDialog: { name: 'TripPreparationDialog', props: ['warehouseId', 'dispatchNos'], template: '<div />' } } } }) }
-beforeEach(() => { vi.clearAllMocks(); state.allowed = true; vi.mocked(getDispatch).mockResolvedValue({ id: '9007199254740999', dispatchNo: 'DS-ORIGINAL', appointmentBatches: [], overseasWarehouseId: 'origin-1', overseasWarehouseName: '原起运仓', status: 'PENDING_DEPARTURE', packageCount: 12 }) })
-it.each(['customer-b', undefined])('rejects FBA dispatch references outside the exact batch customer: %s', async customerId => {
-  vi.mocked(getDispatch).mockResolvedValue({ id: '1', dispatchNo: 'DS-ORIGINAL', status: 'PENDING_DEPARTURE', appointmentBatches: [{ batchKey: 'FBA_APPOINTMENT:1', batchNo: 'AP-1', customerId: 'customer-a', sources: [] }] })
-  const wrapper = render([{ batchKey: 'FBA_APPOINTMENT:1', dispatchNo: 'DS-ORIGINAL', customerId }]); await flushPromises()
-  expect(wrapper.text()).toContain('排车单与工作批次关联不一致')
-  expect(wrapper.find('table').exists()).toBe(false)
-  wrapper.unmount()
+vi.mock('./workApi', async original => ({ ...await original<typeof import('./workApi')>(), resolveBatchWork: vi.fn() }))
+function detail(no = 'DS/ORIGINAL'): DispatchDetail { return { dispatchNo: no, status: 'ACTIVE', stage: 'BEFORE_LOADING', recordVersion: 0, reviewState: 'DRAFT', reviews: { dispatchReview: { status: 'NOT_SUBMITTED', reason: null, reviewerId: null, reviewedAt: null, reviewRound: 0, basisHash: null, invalidatedReason: null }, loadingReview: { status: 'NOT_SUBMITTED', reason: null, reviewerId: null, reviewedAt: null, reviewRound: 0, basisHash: null, invalidatedReason: null } }, counts: { itemCount: 1, palletCount: 1, packageCount: 12, pickedPackageCount: 0, shippedPackageCount: 0 }, pickingReconciled: false, actions: { EDIT: { allowed: true, blockCode: null, blockReason: null }, ADD_CARGO: { allowed: true, blockCode: null, blockReason: null } }, vehicleInfo: { vehicle: null, driver: null }, dispatchInfo: { route: null, plannedDepartureAt: null, departedAt: null, estimatedArrivalAt: null, fbaAppointments: [], vehicleAppointment: null, appointmentBatches: [] }, documents: { dispatchNo: no, outbounds: [], deliveries: [], createdAt: '', updatedAt: '', remark: null }, orderDetails: [] } }
+function render(dispatches: Array<{ batchKey: string; dispatchNo: string; customerId?: string }> = [{ batchKey: 'DISPATCH:9007199254740999', dispatchNo: 'DS/ORIGINAL' }]) { return mount(WorkExistingDispatchForm, { props: { dispatches, canWrite: true }, global: { stubs: { ElButton: { props: ['disabled'], template: '<button :disabled="disabled"><slot /></button>' }, LoadErrorState: { props: ['message'], template: '<p>{{ message }}</p>' }, ApiErrorMeta: true, WorkSharedTripForm: { name: 'WorkSharedTripForm', props: ['dispatchNo', 'canWrite'], template: '<div data-same-dispatch />' } } } }) }
+const button = (wrapper: ReturnType<typeof render>, label: string) => wrapper.findAll('button').find(row => row.text() === label)!
+beforeEach(() => { vi.clearAllMocks(); access.allowed = true; vi.mocked(getDispatch).mockResolvedValue(detail()); vi.mocked(resolveBatchWork).mockResolvedValue({ batchKey: 'DISPATCH:9007199254740999', customerId: 'customer-a', detail: workDetail({ item: workItem({ batchKey: 'DISPATCH:9007199254740999', batchNo: 'DS/ORIGINAL' }) }), candidates: [] }) })
+it.each(['customer-b', undefined])('rejects a FBA reference outside the exact batch customer: %s', async customerId => {
+  const value = detail(); value.dispatchInfo.appointmentBatches = [{ batchKey: 'FBA_APPOINTMENT:1', batchNo: 'AP-1', customerId: 'customer-a', recordVersion: 0, sources: [] }]; vi.mocked(getDispatch).mockResolvedValue(value)
+  const wrapper = render([{ batchKey: 'FBA_APPOINTMENT:1', dispatchNo: value.dispatchNo, customerId }]); await flushPromises(); expect(wrapper.text()).toContain('排车单与工作批次关联不一致'); expect(wrapper.find('table').exists()).toBe(false); wrapper.unmount()
 })
-it('reads shared dispatch once and verifies every FBA batch reference', async () => {
-  vi.mocked(getDispatch).mockResolvedValue({ id: '1', dispatchNo: 'DS-ORIGINAL', status: 'PENDING_DEPARTURE', appointmentBatches: ['1', '2'].map(id => ({ batchKey: `FBA_APPOINTMENT:${id}`, batchNo: `AP-${id}`, customerId: 'customer-a', sources: [] })) })
-  const wrapper = render(['1', '2'].map(id => ({ batchKey: `FBA_APPOINTMENT:${id}`, dispatchNo: 'DS-ORIGINAL', customerId: 'customer-a' }))); await flushPromises()
-  expect(getDispatch).toHaveBeenCalledTimes(1)
-  expect(wrapper.findAll('tbody tr')).toHaveLength(1)
-  wrapper.unmount()
+it('reads a shared whole dispatch once and verifies every nested batch and real customer', async () => {
+  const value = detail(); value.dispatchInfo.appointmentBatches = ['a', 'b'].map((customerId, index) => ({ batchKey: `FBA_APPOINTMENT:${index + 1}`, batchNo: `AP-${index + 1}`, customerId, recordVersion: 0, sources: [] })); vi.mocked(getDispatch).mockResolvedValue(value)
+  const wrapper = render(value.dispatchInfo.appointmentBatches.map(row => ({ batchKey: row.batchKey, customerId: row.customerId, dispatchNo: value.dispatchNo }))); await flushPromises()
+  expect(getDispatch).toHaveBeenCalledTimes(1); expect(wrapper.findAll('tbody tr')).toHaveLength(1); expect(wrapper.emitted('ready')?.at(-1)).toEqual([true]); expect(resolveBatchWork).not.toHaveBeenCalled(); wrapper.unmount()
 })
-it('reads the original dispatch and passes its existing cargo and origin to trip preparation', async () => {
-  const wrapper = render(); await flushPromises()
-  expect(getDispatch).toHaveBeenCalledExactlyOnceWith('DS-ORIGINAL')
-  await wrapper.findAll('button').find(button => button.text() === '继续安排本批车辆')!.trigger('click')
-  const dialog = wrapper.getComponent({ name: 'TripPreparationDialog' }); expect(dialog.props()).toMatchObject({ warehouseId: 'origin-1', dispatchNos: ['DS-ORIGINAL'] })
-  dialog.vm.$emit('saved', { trip: { tripNo: 'TR/001' } }); expect(wrapper.emitted('external')).toEqual([['/overseas-master-data/trips/TR%2F001']])
-  expect(wrapper.text()).not.toContain('9007199254740999'); wrapper.unmount()
+it('resolves the opaque dispatch batch in the work domain and opens the original independent detail', async () => {
+  const wrapper = render(); await flushPromises(); expect(resolveBatchWork).toHaveBeenCalledWith('DISPATCH:9007199254740999', undefined)
+  await button(wrapper, '继续维护本车').trigger('click'); expect(wrapper.emitted('external')).toEqual([['/overseas-warehouse/dispatches/DS%2FORIGINAL']])
+  expect(wrapper.text()).not.toContain('9007199254740999'); expect(wrapper.text()).not.toContain('安排车次'); wrapper.unmount()
 })
-it('rejects mismatched dispatch identity instead of arranging unrelated cargo', async () => {
-  vi.mocked(getDispatch).mockResolvedValue({ id: '9007199254740998', dispatchNo: 'DS-ORIGINAL', appointmentBatches: [], status: 'PENDING_DEPARTURE' })
-  const wrapper = render(); await flushPromises(); expect(wrapper.text()).toContain('排车单与工作批次关联不一致'); expect(wrapper.find('table').exists()).toBe(false); wrapper.unmount()
+it('rejects mismatched authority or returned business identity instead of deriving an internal ID', async () => {
+  vi.mocked(resolveBatchWork).mockResolvedValueOnce({ batchKey: 'DISPATCH:9007199254740999', customerId: 'a', detail: workDetail({ item: workItem({ batchKey: 'DISPATCH:9007199254740999', batchNo: 'DS-OTHER' }) }), candidates: [] })
+  const wrapper = render(); await flushPromises(); expect(wrapper.find('table').exists()).toBe(false); expect(wrapper.text()).toContain('关联不一致'); wrapper.unmount()
+  vi.mocked(getDispatch).mockResolvedValueOnce(detail('WRONG')); const wrong = render(); await flushPromises(); expect(wrong.find('table').exists()).toBe(false); wrong.unmount()
 })
-it('opens an already bound real trip instead of preparing another one', async () => {
-  vi.mocked(getDispatch).mockResolvedValue({ id: '9007199254740999', dispatchNo: 'DS-ORIGINAL', appointmentBatches: [], workflow: { tripNo: 'TR-EXISTING', dispatchReview: { status: 'PENDING', reason: null, reviewedAt: null }, loadingReview: { status: 'PENDING', reason: null, reviewedAt: null } } })
-  const wrapper = render(); await flushPromises(); expect(wrapper.text()).not.toContain('继续安排本批车辆')
-  await wrapper.findAll('button').find(button => button.text() === 'TR-EXISTING')!.trigger('click'); expect(wrapper.emitted('external')).toEqual([['/overseas-master-data/trips/TR-EXISTING']]); wrapper.unmount()
+it('opens same-dispatch adding only under the server gate, and keeps already scanned cargo out of the old merge flow', async () => {
+  const wrapper = render(); await flushPromises(); await button(wrapper, '为本车添加同仓货物').trigger('click')
+  expect(wrapper.getComponent({ name: 'WorkSharedTripForm' }).props()).toMatchObject({ dispatchNo: 'DS/ORIGINAL', canWrite: true }); wrapper.unmount()
+  const value = detail(); value.stage = 'LOADING'; value.counts.pickedPackageCount = 1; value.actions.ADD_CARGO!.allowed = false; vi.mocked(getDispatch).mockResolvedValueOnce(value)
+  const scanned = render(); await flushPromises(); expect(scanned.text()).not.toContain('为本车添加同仓货物'); expect(scanned.text()).not.toContain('共车'); scanned.unmount()
 })
-it('does not read the dispatch without its original list permission', async () => {
-  state.allowed = false; const wrapper = render(); await flushPromises(); expect(getDispatch).not.toHaveBeenCalled(); wrapper.unmount()
+it('does not read dispatch or batch authority without the actual list permissions', async () => {
+  access.allowed = false; const wrapper = render(); await flushPromises(); expect(getDispatch).not.toHaveBeenCalled(); expect(resolveBatchWork).not.toHaveBeenCalled(); wrapper.unmount()
 })

src/modules/appointment-calendar/WorkExistingDispatchForm.vue

@@ -1,44 +1,61 @@
 <script setup lang="ts">
-import { computed, onMounted, ref } from 'vue'
+import InlineHelp from '@/shared/components/InlineHelp.vue'
+import { computed, onBeforeUnmount, ref, watch } from 'vue'
 import { useAccessPreviewStore } from '@/core/access/accessPreview'
-import { getDispatch, type DispatchSummaryDto } from '@/modules/overseas-warehouse'
-import { TripPreparationDialog } from '@/modules/overseas-master-data'
+import { getDispatch, stageLabel, type DispatchDetail } from '@/modules/overseas-warehouse'
 import { ApiResponseError, getApiErrorDetails, type ApiErrorDetails } from '@/shared/api/http'
 import LoadErrorState from '@/shared/components/LoadErrorState.vue'
 import ApiErrorMeta from '@/shared/components/ApiErrorMeta.vue'
+import WorkSharedTripForm from './WorkSharedTripForm.vue'
+import { resolveBatchWork } from './workApi'
 const props = defineProps<{ dispatches: Array<{ batchKey: string; dispatchNo: string; customerId?: string }>; canWrite: boolean }>()
 const emit = defineEmits<{ updated: []; external: [path: string]; ready: [valid: boolean] }>()
-const access = useAccessPreviewStore(), rows = ref<DispatchSummaryDto[]>([]), loading = ref(false), error = ref<ApiErrorDetails | null>(null)
-const selected = ref<DispatchSummaryDto | null>(null), prepareOpen = ref(false)
-const readable = computed(() => access.can('platform:overseas-warehouse:dispatch:list'))
-const writable = computed(() => props.canWrite && readable.value && access.can('platform:fleet:trip:list') && access.can('platform:fleet:trip:edit'))
+const access = useAccessPreviewStore(), rows = ref<DispatchDetail[]>([]), loading = ref(false), error = ref<ApiErrorDetails | null>(null)
+const addingNo = ref(''), addingBusy = ref(false)
+const readable = computed(() => access.can('platform:overseas-warehouse:dispatch:list') && (!props.dispatches.some(row => row.batchKey.startsWith('DISPATCH:')) || access.can('platform:appointment:list')))
+function path(no: string) { return `/overseas-warehouse/dispatches/${encodeURIComponent(no)}` }
+function canEdit(row: DispatchDetail) { return props.canWrite && readable.value && access.can('platform:overseas-warehouse:dispatch:edit') && row.status === 'ACTIVE' && row.actions.EDIT?.allowed === true }
+function canAdd(row: DispatchDetail) { return props.canWrite && readable.value && access.can('platform:overseas-warehouse:dispatch:edit') && row.status === 'ACTIVE' && row.stage === 'BEFORE_LOADING' && row.actions.ADD_CARGO?.allowed === true }
+let generation = 0
 async function load() {
+  const current = ++generation; emit('ready', false); rows.value = []; error.value = null
   if (!readable.value) return
-  loading.value = true; error.value = null; emit('ready', false)
+  loading.value = true
   try {
-    rows.value = await Promise.all([...new Set(props.dispatches.map(reference => reference.dispatchNo))].map(async dispatchNo => {
-      const row = await getDispatch(dispatchNo)
-      // 预约批次必须仍由这张原排车单持有同一客户的分配，不能仅凭展示业务号续办。
-      const matches = props.dispatches.filter(reference => reference.dispatchNo === dispatchNo).every(reference =>
-        reference.batchKey.startsWith('FBA_APPOINTMENT:')
-          ? !!reference.customerId && row.status !== 'CANCELLED' && row.appointmentBatches.some(batch => batch.batchKey === reference.batchKey && batch.customerId === reference.customerId)
-          : `DISPATCH:${row.id}` === reference.batchKey)
-      if (!matches || row.dispatchNo !== dispatchNo) throw new ApiResponseError('排车单与工作批次关联不一致，请刷新核对', 'WORK_DISPATCH_MISMATCH')
+    const references = props.dispatches.map(row => ({ ...row }))
+    const details = await Promise.all([...new Set(references.map(row => row.dispatchNo))].map(async no => {
+      const row = await getDispatch(no)
+      if (row.dispatchNo !== no || row.status === 'CANCELLED') throw new ApiResponseError('排车单与工作批次关联不一致，请刷新核对', 'WORK_DISPATCH_MISMATCH')
+      for (const reference of references.filter(value => value.dispatchNo === no)) {
+        let matches = false
+        if (/^FBA_APPOINTMENT:\d+$/.test(reference.batchKey)) {
+          matches = Boolean(reference.customerId && row.dispatchInfo.appointmentBatches.some(batch => batch.batchKey === reference.batchKey && batch.customerId === reference.customerId))
+        } else if (/^DISPATCH:\d+$/.test(reference.batchKey)) {
+          // The work domain resolves its opaque batch identity; Detail has no internal dispatch ID.
+          const resolution = await resolveBatchWork(reference.batchKey, reference.customerId)
+          matches = resolution.batchKey === reference.batchKey && (resolution.detail
+            ? resolution.detail.item.batchKey === reference.batchKey && resolution.detail.item.batchNo === no && (!reference.customerId || resolution.customerId === reference.customerId)
+            : resolution.candidates.length > 0 && resolution.candidates.every(candidate => candidate.batchNo === no) && (!reference.customerId || resolution.candidates.some(candidate => candidate.customerId === reference.customerId)))
+        }
+        if (!matches) throw new ApiResponseError('排车单与工作批次关联不一致，请刷新核对', 'WORK_DISPATCH_MISMATCH')
+      }
       return row
     }))
-    emit('ready', true)
-  } catch (cause) { error.value = getApiErrorDetails(cause, '原排车单读取失败') }
-  finally { loading.value = false }
+    if (current !== generation) return
+    rows.value = details; emit('ready', details.length > 0)
+  } catch (cause) { if (current === generation) error.value = getApiErrorDetails(cause, '原排车单读取失败') }
+  finally { if (current === generation) loading.value = false }
 }
-function prepare(row: DispatchSummaryDto) { if (writable.value && !loading.value && !error.value && row.status === 'PENDING_DEPARTURE' && !row.workflow && row.overseasWarehouseId) { selected.value = row; prepareOpen.value = true } }
-function saved(value: { trip: { tripNo: string } }) { prepareOpen.value = false; emit('updated'); emit('external', `/overseas-master-data/trips/${encodeURIComponent(value.trip.tripNo)}`) }
-onMounted(load)
+function add(row: DispatchDetail) { if (canAdd(row) && !loading.value && !error.value && !addingBusy.value) addingNo.value = row.dispatchNo }
+function updated() { emit('updated'); void load() }
+watch(() => props.dispatches, load, { immediate: true, deep: true })
+onBeforeUnmount(() => { generation++ })
 </script>
 <template>
-  <section aria-label="原排车单安排用车"><h3>原排车单安排用车</h3><p>沿用本批已选实物和原排车单，确认起运仓后安排车次、车辆与司机。</p>
-    <p v-if="!readable">查看原排车单需要排车列表权限。</p><p v-if="loading">正在核对原排车单与批次…</p>
+  <section aria-label="沿用原整车排车"><h3>沿用原整车排车 <InlineHelp title="排车说明"><p>在原排车单维护车辆、司机和货物；一张排车单就是一趟车。</p></InlineHelp></h3>
+    <p v-if="!readable">查看原排车单及批次关联需要相应列表权限。</p><p v-if="loading">正在核对原排车单与批次…</p>
     <LoadErrorState v-if="error" title="原排车单读取失败" :message="error.message" :loading="loading" @retry="load"><template #details><ApiErrorMeta :details="error" /></template></LoadErrorState>
-    <table v-if="!loading && !error && readable" class="density-table"><thead><tr><th>操作</th><th>排车单号</th><th>起运仓</th><th>箱数</th><th>车次</th></tr></thead><tbody><tr v-for="row in rows" :key="row.dispatchNo"><td><el-button v-if="!row.workflow" :disabled="!writable || row.status !== 'PENDING_DEPARTURE' || !row.overseasWarehouseId" @click="prepare(row)">继续安排本批车辆</el-button><el-button @click="emit('external', `/overseas-warehouse/dispatches?dispatchNo=${encodeURIComponent(row.dispatchNo)}`)">查看原排车单</el-button></td><td>{{ row.dispatchNo }}</td><td>{{ row.overseasWarehouseName || '起运仓待核实' }}</td><td>{{ row.packageCount ?? '待核实' }}</td><td><el-button v-if="row.workflow?.tripNo && access.can('platform:fleet:trip:list')" @click="emit('external', `/overseas-master-data/trips/${encodeURIComponent(row.workflow.tripNo)}`)">{{ row.workflow.tripNo }}</el-button><span v-else>尚未关联车次</span></td></tr></tbody></table>
-    <TripPreparationDialog v-if="selected?.overseasWarehouseId" v-model="prepareOpen" :warehouse-id="selected.overseasWarehouseId" :warehouse-name="selected.overseasWarehouseName || '起运仓待核实'" :dispatch-nos="[selected.dispatchNo]" @saved="saved" />
+    <table v-if="!loading && !error && readable" class="density-table"><thead><tr><th>操作</th><th>排车单号</th><th>车牌号</th><th>箱数</th><th>阶段</th></tr></thead><tbody><tr v-for="row in rows" :key="row.dispatchNo"><td><el-button v-if="canEdit(row)" :disabled="addingBusy" @click="emit('external', path(row.dispatchNo))">继续维护本车</el-button><el-button v-if="canAdd(row)" :disabled="addingBusy" @click="add(row)">为本车添加同仓货物</el-button><el-button @click="emit('external', path(row.dispatchNo))">查看原排车单</el-button></td><td>{{ row.dispatchNo }}</td><td>{{ row.vehicleInfo.vehicle?.plate || '—' }}</td><td>{{ row.counts.packageCount }}</td><td>{{ stageLabel(row.stage) }}</td></tr></tbody></table>
+    <WorkSharedTripForm v-if="addingNo" :key="addingNo" :dispatch-no="addingNo" :can-write="canWrite" @busy="addingBusy = $event" @updated="updated" @external="value => emit('external', value)" />
   </section>
 </template>

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

@@ -1,48 +1,37 @@
 import { flushPromises, mount } from '@vue/test-utils'
 import { beforeEach, expect, it, vi } from 'vitest'
 import WorkSharedTripForm from './WorkSharedTripForm.vue'
-import { getDispatch } 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: '' }))
 vi.mock('@/core/access/accessPreview', () => ({ useAccessPreviewStore: () => ({ can: () => access.allowed }) }))
+vi.mock('@/core/auth/auth', () => ({ useAuthStore: () => ({ user: identity }) }))
 vi.mock('@/modules/overseas-warehouse', async original => ({ ...await original<typeof import('@/modules/overseas-warehouse')>(), getDispatch: vi.fn() }))
 vi.mock('element-plus', () => ({ ElMessage: { warning: vi.fn() } }))
 let guard: LeaveGuard
-function render() { return mount(WorkSharedTripForm, { props: { dispatchNo: 'DS-60', canWrite: true }, global: { provide: { 'appointment-work-leave-guard': (value: LeaveGuard) => { guard = value; return () => undefined } }, stubs: {
-  ElButton: { props: ['disabled'], template: '<button :disabled="disabled"><slot /></button>' },
-  TripPreparationDialog: { name: 'TripPreparationDialog', props: ['modelValue', 'warehouseId', 'dispatchNos'], template: '<div />' },
-  LoadErrorState: { props: ['message'], template: '<p role="alert">{{ message }}</p>' }, ApiErrorMeta: true,
-} } }) }
-beforeEach(() => { vi.clearAllMocks(); access.allowed = true; vi.mocked(getDispatch).mockImplementation(async number => ({ id: `internal-${number}`, dispatchNo: number, appointmentBatches: [], customerId: number === 'DS-60' ? 'customer-b' : 'customer-d', overseasWarehouseId: 'warehouse-real', overseasWarehouseName: '实际起运仓', packageCount: number === 'DS-60' ? 60 : 40, status: 'PENDING_DEPARTURE' })) })
-it('checks exact 60 and 40 dispatch business numbers and passes both to the existing Fleet preparation before navigating to its real trip', async () => {
-  const wrapper = render()
-  expect(getDispatch).not.toHaveBeenCalled()
-  await wrapper.get('input').setValue('DS-40'); await wrapper.get('button').trigger('click'); await flushPromises()
-  expect(vi.mocked(getDispatch).mock.calls.map(call => call[0])).toEqual(['DS-60', 'DS-40'])
-  const prepare = wrapper.getComponent({ name: 'TripPreparationDialog' })
-  expect(prepare.props()).toMatchObject({ modelValue: true, warehouseId: 'warehouse-real', dispatchNos: ['DS-60', 'DS-40'] })
-  expect(wrapper.text()).toContain('60 箱'); expect(wrapper.text()).toContain('40 箱'); expect(wrapper.text()).not.toContain('internal-')
-  expect(await guard()).toBe(false)
-  prepare.vm.$emit('saved', { trip: { tripNo: 'TR-SHARED' } }); await flushPromises()
-  expect(wrapper.emitted('external')).toEqual([['/overseas-master-data/trips/TR-SHARED']]); expect(wrapper.emitted('updated')).toHaveLength(1)
-  wrapper.unmount()
+function render() { return mount(WorkSharedTripForm, { props: { dispatchNo: 'DS-60', canWrite: true }, global: { provide: { 'appointment-work-leave-guard': (value: LeaveGuard) => { guard = value; return () => undefined } }, stubs: { ElButton: { props: ['disabled'], template: '<button :disabled="disabled"><slot /></button>' }, DispatchWorkflowDialog: { name: 'DispatchWorkflowDialog', props: ['modelValue', 'dispatchNo', 'action'], template: '<div data-add-cargo />' }, LoadErrorState: { props: ['message'], template: '<p role="alert">{{ message }}<button @click="$emit(\'retry\')">重试</button></p>' }, ApiErrorMeta: true } } }) }
+function detail(no = 'DS-60', allowed = true) { return { dispatchNo: no, status: 'ACTIVE', stage: 'BEFORE_LOADING', recordVersion: 0, counts: { packageCount: 60 }, vehicleInfo: { vehicle: null, driver: null }, actions: { ADD_CARGO: { allowed, blockCode: allowed ? null : 'PICKED', blockReason: allowed ? null : '货物已开始真实拣货' } } } as DispatchDetail }
+const button = (wrapper: ReturnType<typeof render>, label: string) => wrapper.findAll('button').find(row => row.text() === label)!
+beforeEach(() => { vi.clearAllMocks(); sessionStorage.clear(); identity.id = crypto.randomUUID(); access.allowed = true; vi.mocked(getDispatch).mockResolvedValue(detail()) })
+it('opens the native add-cargo workflow for the same dispatch instead of asking for another customer dispatch', async () => {
+  const wrapper = render(); await flushPromises(); expect(getDispatch).toHaveBeenCalledExactlyOnceWith('DS-60'); expect(wrapper.find('input').exists()).toBe(false)
+  expect(wrapper.text()).toContain('60 箱'); await button(wrapper, '选择同仓未安排货物').trigger('click')
+  const dialog = wrapper.getComponent({ name: 'DispatchWorkflowDialog' }); expect(dialog.props()).toMatchObject({ modelValue: true, dispatchNo: 'DS-60', action: 'ADD_CARGO' }); expect(await guard()).toBe(false)
+  dialog.vm.$emit('saved'); await flushPromises(); expect(wrapper.emitted('updated')).toHaveLength(1); expect(await guard()).toBe(true); wrapper.unmount()
 })
-it('rejects duplicate, cross-warehouse, already-bound and mismatched dispatches without opening Fleet preparation', async () => {
-  const wrapper = render(); await wrapper.get('input').setValue('DS-60'); await wrapper.get('button').trigger('click'); await flushPromises()
-  expect(getDispatch).not.toHaveBeenCalled()
-  for (const change of [{ overseasWarehouseId: 'another-warehouse' }, { workflow: { tripNo: 'TR-OTHER', dispatchReview: { status: 'PENDING' as const, reason: null, reviewedAt: null }, loadingReview: { status: 'PENDING' as const, reason: null, reviewedAt: null } } }, { status: 'SHIPPED' }, { dispatchNo: 'WRONG' }]) {
-    vi.mocked(getDispatch).mockResolvedValueOnce({ id: 'a', dispatchNo: 'DS-60', appointmentBatches: [], overseasWarehouseId: 'warehouse-real', status: 'PENDING_DEPARTURE' }).mockResolvedValueOnce({ id: 'b', dispatchNo: 'DS-40', appointmentBatches: [], overseasWarehouseId: 'warehouse-real', status: 'PENDING_DEPARTURE', ...change })
-    await wrapper.get('input').setValue('DS-40'); await wrapper.get('button').trigger('click'); await flushPromises()
-    expect(wrapper.findComponent({ name: 'TripPreparationDialog' }).exists()).toBe(false); expect(wrapper.find('[role="alert"]').exists()).toBe(true)
-  }
-  wrapper.unmount()
+it('honors native stage/gate and permissions and rejects a different returned business number', async () => {
+  vi.mocked(getDispatch).mockResolvedValueOnce({ ...detail('DS-60', false), stage: 'LOADING' }); const scanned = render(); await flushPromises(); expect(button(scanned, '选择同仓未安排货物').attributes('disabled')).toBeDefined(); expect(scanned.text()).toContain('货物已开始真实拣货'); scanned.unmount()
+  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('keeps a failed lookup retry read-only and respects original permissions', async () => {
-  const wrapper = render(); vi.mocked(getDispatch).mockRejectedValueOnce(new Error('读取失败'))
-  await wrapper.get('input').setValue('DS-40'); await wrapper.get('button').trigger('click'); await flushPromises()
-  expect(wrapper.findComponent({ name: 'TripPreparationDialog' }).exists()).toBe(false)
-  await wrapper.get('button').trigger('click'); await flushPromises()
-  expect(getDispatch).toHaveBeenCalledTimes(4); expect(wrapper.getComponent({ name: 'TripPreparationDialog' }).props('dispatchNos')).toEqual(['DS-60', 'DS-40'])
-  wrapper.unmount(); access.allowed = false
-  const readonly = render(); await readonly.get('button').trigger('click'); expect(getDispatch).toHaveBeenCalledTimes(4); readonly.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('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)
+  await button(wrapper, '查看原排车单').trigger('click'); expect(wrapper.emitted('external')).toEqual([['/overseas-warehouse/dispatches/DS-60']]); wrapper.unmount()
 })

src/modules/appointment-calendar/WorkSharedTripForm.vue

@@ -1,50 +1,51 @@
 <script setup lang="ts">
 import { computed, onBeforeUnmount, ref, watch } from 'vue'
 import { useAccessPreviewStore } from '@/core/access/accessPreview'
-import { getDispatch, type DispatchSummaryDto } from '@/modules/overseas-warehouse'
-import { TripPreparationDialog } from '@/modules/overseas-master-data'
+import { useAuthStore } from '@/core/auth/auth'
+import { DispatchWorkflowDialog, DispatchInputError, getDispatch, useDispatchCommandRecovery, type DispatchDetail } from '@/modules/overseas-warehouse'
 import { getApiErrorDetails, type ApiErrorDetails } from '@/shared/api/http'
 import LoadErrorState from '@/shared/components/LoadErrorState.vue'
 import ApiErrorMeta from '@/shared/components/ApiErrorMeta.vue'
 import { useWorkDraft } from './useWorkDraft'
 const props = defineProps<{ dispatchNo: string; canWrite: boolean }>()
 const emit = defineEmits<{ updated: []; busy: [value: boolean]; external: [path: string] }>()
-const access = useAccessPreviewStore(), otherNo = ref(''), rows = ref<DispatchSummaryDto[]>([])
-const loading = ref(false), error = ref<ApiErrorDetails | null>(null), prepareOpen = ref(false)
-const allowed = computed(() => props.canWrite && ['platform:overseas-warehouse:dispatch:list', 'platform:fleet:trip:list', 'platform:fleet:trip:edit'].every(permission => access.can(permission)))
-watch(prepareOpen, value => emit('busy', value))
-useWorkDraft(computed(() => false), prepareOpen)
+const access = useAccessPreviewStore(), auth = useAuthStore(), recovery = useDispatchCommandRecovery(() => auth.user?.id || '')
+const detail = ref<DispatchDetail | null>(null), open = ref(false), loading = ref(false), error = ref<ApiErrorDetails | null>(null)
+const readable = computed(() => access.can('platform:overseas-warehouse:dispatch:list'))
+const allowed = computed(() => props.canWrite && readable.value && access.can('platform:overseas-warehouse:dispatch:edit') && detail.value?.status === 'ACTIVE' && detail.value.stage === 'BEFORE_LOADING' && detail.value.actions.ADD_CARGO?.allowed === true)
+const busy = computed(() => loading.value || open.value || Boolean(recovery.pending.value))
+watch(busy, value => emit('busy', value), { immediate: true })
+useWorkDraft(computed(() => false), busy)
 let generation = 0
-function changed() { ++generation; loading.value = false; rows.value = []; error.value = null }
-async function prepare() {
-  if (!allowed.value || loading.value || prepareOpen.value) return
-  rows.value = []; error.value = null
-  const other = otherNo.value.trim()
-  if (!other || other === props.dispatchNo) { error.value = { message: '请填写另一张已备好的排车单业务号，不能重复选择本单。' }; return }
-  const current = ++generation; loading.value = true
+async function load() {
+  const current = ++generation; detail.value = null; error.value = null
+  if (!readable.value) return
+  loading.value = true
   try {
-    const numbers = [props.dispatchNo, other]
-    const details = await Promise.all(numbers.map(getDispatch))
+    const value = await getDispatch(props.dispatchNo)
     if (current !== generation) return
-    if (details.some((row, index) => row.dispatchNo !== numbers[index])) throw new Error('返回的排车单与所选业务号不一致，请重新核对。')
-    if (details.some(row => row.status !== 'PENDING_DEPARTURE' || row.workflow)) throw new Error('请选择尚未关联车次的待发运排车单；已关联的货物请从原车次继续处理。')
-    if (!details[0]!.overseasWarehouseId || details.some(row => row.overseasWarehouseId !== details[0]!.overseasWarehouseId)) throw new Error('两张排车单必须有明确且相同的起运仓。')
-    rows.value = details; prepareOpen.value = true
-  } catch (cause) { if (current === generation) error.value = getApiErrorDetails(cause, '共车排车单核对失败') }
+    if (value.dispatchNo !== props.dispatchNo) throw new DispatchInputError('读取结果与原排车单不一致，请重新核对')
+    detail.value = value
+  } catch (cause) { if (current === generation) error.value = getApiErrorDetails(cause, cause instanceof DispatchInputError ? cause.message : '本车加货资格读取失败') }
   finally { if (current === generation) loading.value = false }
 }
-function saved(value: { trip: { tripNo: string } }) { prepareOpen.value = false; emit('updated'); emit('external', `/overseas-master-data/trips/${encodeURIComponent(value.trip.tripNo)}`) }
-onBeforeUnmount(() => { ++generation; emit('busy', false) })
+function prepare() { if (allowed.value && !loading.value && !recovery.pending.value) 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; emit('updated'); void load() }
+watch(() => props.dispatchNo, load, { immediate: true })
+onBeforeUnmount(() => { generation++; emit('busy', false) })
 </script>
 <template>
-  <section class="work-form" aria-label="与同仓其他排车单共车">
-    <h4>与同仓其他排车单共车</h4>
-    <p>本批排车单：{{ dispatchNo }}。请先按各客户实际托盘分别备好排车单，再核对同仓两单并安排同一车次。</p>
-    <p>所需箱数无法对应完整实物时，请先在原库存作业中完成拆托，再返回核对；分批计划不会代替实物拆托。</p>
-    <label>另一张排车单号<input v-model="otherNo" aria-label="共车排车单号" maxlength="64" :disabled="loading || prepareOpen || !allowed" @input="changed" @keydown.enter.prevent="prepare"></label>
-    <el-button :disabled="!allowed || prepareOpen" :loading="loading" @click="prepare">核对两单并安排共车</el-button>
-    <LoadErrorState v-if="error" title="共车排车单核对失败" :message="error.message" :show-retry="false"><template #details><ApiErrorMeta :details="error" /></template></LoadErrorState>
-    <p v-for="row in rows" :key="row.dispatchNo">{{ row.dispatchNo }} · {{ row.overseasWarehouseName || '起运仓名称待核实' }} · {{ row.packageCount ?? '箱数待核实' }}<span v-if="row.packageCount != null"> 箱</span></p>
-    <TripPreparationDialog v-if="rows[0]?.overseasWarehouseId" v-model="prepareOpen" :warehouse-id="rows[0].overseasWarehouseId" :warehouse-name="rows[0].overseasWarehouseName || '起运仓名称待核实'" :dispatch-nos="rows.map(row => row.dispatchNo)" @saved="saved" />
+  <section class="work-form" aria-label="为原排车添加同仓货物">
+    <h4>为原排车添加同仓货物</h4><p>本车 {{ dispatchNo }}。只选择尚未安排的真实货物加入本车，不合并另一张排车单或搬迁已扫码货物。</p>
+    <p>箱数无法对应完整实物时，先在原库存作业完成拆托；预约分批不代替实物拆托。</p>
+    <LoadErrorState v-if="error" title="本车加货资格读取失败" :message="error.message" :loading="loading" @retry="load"><template #details><ApiErrorMeta :details="error" /></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">原排车请求尚未核对，不能另发加货命令。<el-button v-if="recovery.pending.value.dispatchNo === dispatchNo && recovery.pending.value.action === 'ADD_CARGO'" @click="recover">核对原加货请求</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" />
   </section>
 </template>

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

@@ -2,12 +2,17 @@ import { describe, expect, it } from 'vitest'
 import { addDays, calendarDates, calendarRange, moveCalendar } from './calendar'
 
 describe('appointment calendar', () => {
-  it('shows six complete Monday-first weeks across year boundaries', () => {
-    const dates = calendarDates('2027-01-15', 'month')
-    expect(dates).toHaveLength(42)
-    expect(dates[0]).toBe('2026-12-28')
-    expect(dates.at(-1)).toBe('2027-02-07')
-    expect(calendarRange('2027-01-15', 'month').to).toBe('2027-02-08')
+  it.each([
+    ['2026-10-19', '2026-09-28', '2026-11-02', 35],
+    ['2027-01-15', '2026-12-28', '2027-02-01', 35],
+    ['2027-02-15', '2027-02-01', '2027-03-01', 28],
+    ['2026-08-15', '2026-07-27', '2026-09-07', 42],
+  ] as const)('shows only the complete weeks needed for %s', (anchor, from, to, count) => {
+    const dates = calendarDates(anchor, 'month')
+    expect(dates).toHaveLength(count)
+    expect(dates[0]).toBe(from)
+    expect(dates.at(-1)).toBe(addDays(to, -1))
+    expect(calendarRange(anchor, 'month')).toEqual({ from, to })
   })
 
   it('moves by a week in week mode instead of following the prototype month-navigation bug', () => {

src/modules/appointment-calendar/calendar.ts

@@ -29,16 +29,19 @@ export function addDays(value: string, days: number): string {
 
 export function calendarRange(anchor: string, mode: CalendarMode): { from: string; to: string } {
   const date = parseDate(anchor)
+  const nextMonth = new Date(date.getFullYear(), date.getMonth() + 1, 1, 12)
   if (mode === 'month') date.setDate(1)
   date.setDate(date.getDate() - (date.getDay() + 6) % 7)
   const from = dateKey(date)
-  // A half-open interval also works directly with database timestamps.
-  return { from, to: addDays(from, mode === 'month' ? 42 : 7) }
+  // 月视图只补齐月末所在周，不追加整周的下月日期；结束日期仍为开区间。
+  return { from, to: mode === 'month' ? addDays(dateKey(nextMonth), (8 - nextMonth.getDay()) % 7) : addDays(from, 7) }
 }
 
 export function calendarDates(anchor: string, mode: CalendarMode): string[] {
-  const { from } = calendarRange(anchor, mode)
-  return Array.from({ length: mode === 'month' ? 42 : 7 }, (_, index) => addDays(from, index))
+  const { from, to } = calendarRange(anchor, mode)
+  const dates: string[] = []
+  for (let date = from; date < to; date = addDays(date, 1)) dates.push(date)
+  return dates
 }
 
 export function moveCalendar(anchor: string, mode: CalendarMode, offset: number): string {

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

@@ -1,6 +1,6 @@
 import { expect, it, vi } from 'vitest'
 import { http } from '@/shared/api/http'
-import { listPlanningCargo, listPlanningContainers, resolvePlanningOrder } from './planningApi'
+import { listPlanningCargo, listPlanningDestinations, listPlanningContainers, resolvePlanningOrder } from './planningApi'
 vi.mock('@/shared/api/http', () => ({ http: { get: vi.fn() }, unwrapApiResponse: <T>(value: { data: T }) => value.data }))
 
 it('uses the gateway planning route and preserves stable source IDs and null predictions', async () => {
@@ -20,6 +20,15 @@ it('keeps basic container listing on its own endpoint rather than requiring impa
   expect(http.get).toHaveBeenCalledExactlyOnceWith('/platform/v1/last-leg/appointment-planning/containers', { params: { page: 1, size: 20 }, signal: undefined })
   expect(result.total).toBe(0)
 })
+it('uses authoritative destination options and sends the selected destination to server pagination', async () => {
+  vi.mocked(http.get).mockClear()
+  vi.mocked(http.get).mockResolvedValueOnce({data:['ABE4','ONT8']})
+  expect(await listPlanningDestinations()).toEqual(['ABE4','ONT8'])
+  expect(http.get).toHaveBeenCalledExactlyOnceWith('/platform/v1/last-leg/appointment-planning/cargo/destinations',{signal:undefined})
+  vi.mocked(http.get).mockResolvedValueOnce({data:{records:[],page:2,size:20,total:0,pages:0}})
+  await listPlanningCargo({page:2,size:20,keyword:'IN-A',destination:'ONT8'})
+  expect(http.get).toHaveBeenLastCalledWith('/platform/v1/last-leg/appointment-planning/cargo',{params:{page:2,size:20,keyword:'IN-A',destination:'ONT8'},signal:undefined})
+})
 it('resolves an order through the real canonical-source endpoint without fabricating an ORDER alias', async () => {
   vi.mocked(http.get).mockClear()
   vi.mocked(http.get).mockResolvedValue({data:{source:{sourceKey:'BOOKING:B-1'},coverage:{appointments:[]}}})

src/modules/appointment-calendar/planningApi.ts

@@ -31,7 +31,7 @@ export interface PlanningCargo {
   mixedDestinations: boolean
 }
 export interface PlanningCargoPage { records: PlanningCargo[]; page: number; size: number; total: number; pages: number }
-export async function listPlanningCargo(query: { page: number; size: number; keyword?: string }, signal?: AbortSignal) {
+export async function listPlanningCargo(query: { page: number; size: number; keyword?: string; destination?: string }, signal?: AbortSignal) {
   const response = await http.get<ApiEnvelope<PlanningCargoPage>, ApiEnvelope<PlanningCargoPage>>(
     '/platform/v1/last-leg/appointment-planning/cargo', { params: query, signal },
   )
@@ -39,6 +39,12 @@ export async function listPlanningCargo(query: { page: number; size: number; key
   return { ...page, page: Number(page.page), size: Number(page.size), total: Number(page.total), pages: Number(page.pages) }
 }
 
+export async function listPlanningDestinations(signal?: AbortSignal) {
+  return unwrapApiResponse(await http.get<ApiEnvelope<string[]>, ApiEnvelope<string[]>>(
+    '/platform/v1/last-leg/appointment-planning/cargo/destinations', { signal },
+  ))
+}
+
 export type FollowupStage = 'DRAYAGE_CONTACT' | 'TERMINAL_APPOINTMENT' | 'WAREHOUSE_RECEIVING' | 'FBA_RECEIVING'
 export interface FollowupRecord { stage: FollowupStage; version: number; contactedParty: string | null; result: string; nextAction: string | null; followupDate: string | null; operatorName: string | null; createdAt: string }
 export interface FollowupHistory { history: { records: FollowupRecord[]; page: number; size: number; total: number; pages: number }; versions: Record<FollowupStage, number> }

src/modules/container-loading/pages/SmartLoadingWorkbenchView.test.ts

@@ -75,7 +75,9 @@ describe('SmartLoadingWorkbenchView', () => {
     expect(wrapper.text()).not.toContain('LP-99')
     expect(wrapper.text()).toContain('IN-1')
     expect(wrapper.text()).not.toContain('ORD-1')
-    expect(wrapper.text()).toContain('150% 容量上限')
+    expect(wrapper.text()).not.toContain('150% 容量上限')
+    await wrapper.get('button[aria-label="查看装柜说明"]').trigger('mouseenter')
+    await vi.waitFor(() => expect(document.body.textContent).toContain('150% 容量上限'))
   })
 
   it('shows the full inbound composition for an assigned sealed pallet', async () => {

src/modules/container-loading/pages/SmartLoadingWorkbenchView.vue

@@ -1,4 +1,5 @@
 <script setup lang="ts">
+import InlineHelp from '@/shared/components/InlineHelp.vue'
 import SmartLoadingCandidateInbounds from '../components/SmartLoadingCandidateInbounds.vue'
 import '@/styles/adminDensity.css'
 import { computed, onMounted, reactive, ref } from 'vue'
@@ -386,7 +387,7 @@ onMounted(load)
         <el-alert v-if="plan.status === 'LOADING' && plan.canEdit" type="warning" :closable="false" show-icon title="已下发 PDA，仍可维护未完成的装柜明细" description="新增、增加或移除未拣明细会刷新 PDA 明细与版本；PDA 端需要刷新后继续操作。" />
         <el-alert v-else-if="!plan.canEdit" :type="plan.finalCompletionStatus === 'COMPLETED' ? 'success' : 'info'" :closable="false" show-icon :title="plan.finalCompletionStatus === 'IN_PROGRESS' ? '正在最终确认，装柜方案暂时只读' : plan.finalCompletionStatus === 'COMPLETED' ? '装柜已完成，方案永久只读' : '当前装柜方案只读'" :description="plan.blockedReason || '请刷新计划获取最新作业状态。'" />
         <DataTable :data="displayedPlanItems" :columns="itemColumns" :loading="loading || mutating" stripe preference-key="smart-loading-items" column-settings-mode="hide" empty-text="暂无已分配货物">
-          <template #toolbar-start><div><h2>{{ displayContainerNo(container) }} 装柜方案</h2><p>智能建议必须经人工核对。</p></div></template>
+          <template #toolbar-start><div><h2>{{ displayContainerNo(container) }} 装柜方案 <InlineHelp title="装柜说明"><p>智能建议必须经人工核对。</p><p>系统基于装柜仓库、物流渠道、可用箱数及 150% 容量上限校验。</p></InlineHelp></h2></div></template>
           <template #actions="{ row }"><div class="row-actions density-actions"><el-button data-tone="danger" class="density-action" v-if="canDelete && editable && row.canRemove" size="small" type="danger" plain @click="remove(row)">删除</el-button></div></template>
           <template #order="{ row }"><SmartLoadingCandidateInbounds :members="row.palletMembers" :sealed-pallet="row.unitType === 'SEALED_PALLET'" :fallback-inbound-code="row.inboundCode" /></template>
           <template #customerName="{ row }"><LineClampText :content="row.customerName" /></template>
@@ -396,7 +397,7 @@ onMounted(load)
           <template #volume="{ row }">{{ formatNumber(Number(row.volumeCbm || 0)) }} m³</template><template #weight="{ row }">{{ formatNumber(Number(row.grossWeightKg || 0),1) }} kg</template>
         </DataTable>
         <DataTable :data="displayedCandidates" :columns="candidateColumns" :loading="loading || mutating" stripe preference-key="smart-loading-candidates" column-settings-mode="hide" empty-text="当前仓库暂无可装柜货物">
-          <template #toolbar-start><div><h2>候选货物</h2><p>系统基于装柜仓库、物流渠道、可用箱数及 150% 容量上限校验。</p></div></template>
+          <template #toolbar-start><div><h2>候选货物</h2></div></template>
           <template #actions="{ row }"><el-button data-tone="primary" class="density-action" v-if="canAssign && assignable" size="small" type="primary" plain :disabled="candidateBlocked(row as SmartLoadingCandidateRow)" @click="openAssign(row)">加入</el-button></template>
           <template #candidateInbounds="{ row }"><SmartLoadingCandidateInbounds :candidate="row as SmartLoadingCandidate" /></template>
           <template #customerName="{ row }"><LineClampText :content="row.customerName" /></template>

src/modules/customers/CustomerOverseasStorageFeePanel.vue

@@ -72,7 +72,7 @@ onMounted(load)
 
 <template>
   <section class="overseas-fee-panel admin-density customer-density">
-    <header class="panel-heading"><div><h2>海外仓费用</h2><p>客户专属仓租和退货仓储费阶梯</p></div><el-button v-if="canEdit && config" type="primary" :loading="loading" @click="openEditor">编辑费用</el-button></header>
+    <header class="panel-heading"><div><h2>海外仓费用</h2></div><el-button v-if="canEdit && config" type="primary" :loading="loading" @click="openEditor">编辑费用</el-button></header>
     <div v-if="error" class="fee-error" role="alert"><div><strong>海外仓费用加载失败</strong><p>{{ error.message }}</p><ApiErrorMeta :details="error" /></div><el-button plain type="primary" :loading="loading" @click="load">重新加载</el-button></div>
     <div v-else-if="loading && !config" v-loading="true" class="fee-loading" />
     <template v-else-if="config">
@@ -88,7 +88,7 @@ onMounted(load)
 </template>
 
 <style scoped>
-.overseas-fee-panel { border: 1px solid var(--cc-border); background: var(--admin-surface, #fff); }.panel-heading { display:flex; align-items:center; justify-content:space-between; border-bottom:1px solid var(--cc-border); }.panel-heading h2 { margin:0; color:var(--cc-text); }.fee-groups h3 { margin:0; color:var(--cc-text); }.edit-groups h3 { margin:0; color:var(--cc-text); }.panel-heading p { margin:5px 0 0; color:var(--cc-muted); }.fee-meta { display:flex; flex-wrap:wrap; gap:var(--admin-space-7, 24px); padding:var(--admin-space-5, 12px) 18px; color:var(--cc-muted); font-size:var(--admin-font-caption, 12px); background:var(--admin-label-bg, #f8fafc); }.fee-meta strong { color:var(--cc-text); }.fee-groups { display:grid; grid-template-columns:repeat(2,minmax(0,1fr)); }.edit-groups { display:grid; grid-template-columns:repeat(2,minmax(0,1fr)); }.fee-groups > div { min-width:0; }.edit-groups > div { min-width:0; }.fee-groups table { width:100%; border-collapse:collapse; font-size:var(--admin-font-caption, 12px); }.edit-groups table { width:100%; border-collapse:collapse; font-size:var(--admin-font-caption, 12px); }.edit-groups table { table-layout:fixed; }.fee-groups th { border-bottom:1px solid var(--cc-border); text-align:left; }.fee-groups td { border-bottom:1px solid var(--cc-border); text-align:left; }.edit-groups th { border-bottom:1px solid var(--cc-border); text-align:left; }.edit-groups td { border-bottom:1px solid var(--cc-border); text-align:left; }.fee-groups th { color:var(--cc-muted); font-weight:650; }.edit-groups th { color:var(--cc-muted); font-weight:650; }.edit-groups th:first-child { width:76px; }.edit-groups td:first-child { width:76px; }.edit-groups :deep(.el-input-number) { width:100%; min-width:0; }.fee-error { display:flex; align-items:center; justify-content:space-between; gap:var(--admin-space-6, 16px); padding:20px; background:#fff4f3; }.fee-error p { margin:5px 0; color:#b42318; font-size:var(--admin-font-caption, 12px); }.fee-empty { display:grid; place-items:center; color:var(--cc-muted); }.dialog-actions { display:flex; gap:var(--admin-space-3, 8px); }.dialog-actions :deep(.el-button + .el-button) { margin-left:0; }
+.overseas-fee-panel { border: 1px solid var(--cc-border); background: var(--admin-surface, #fff); }.panel-heading { display:flex; align-items:center; justify-content:space-between; border-bottom:1px solid var(--cc-border); }.panel-heading h2 { margin:0; color:var(--cc-text); }.fee-groups h3 { margin:0; color:var(--cc-text); }.edit-groups h3 { margin:0; color:var(--cc-text); }.fee-meta { display:flex; flex-wrap:wrap; gap:var(--admin-space-7, 24px); padding:var(--admin-space-5, 12px) 18px; color:var(--cc-muted); font-size:var(--admin-font-caption, 12px); background:var(--admin-label-bg, #f8fafc); }.fee-meta strong { color:var(--cc-text); }.fee-groups { display:grid; grid-template-columns:repeat(2,minmax(0,1fr)); }.edit-groups { display:grid; grid-template-columns:repeat(2,minmax(0,1fr)); }.fee-groups > div { min-width:0; }.edit-groups > div { min-width:0; }.fee-groups table { width:100%; border-collapse:collapse; font-size:var(--admin-font-caption, 12px); }.edit-groups table { width:100%; border-collapse:collapse; font-size:var(--admin-font-caption, 12px); }.edit-groups table { table-layout:fixed; }.fee-groups th { border-bottom:1px solid var(--cc-border); text-align:left; }.fee-groups td { border-bottom:1px solid var(--cc-border); text-align:left; }.edit-groups th { border-bottom:1px solid var(--cc-border); text-align:left; }.edit-groups td { border-bottom:1px solid var(--cc-border); text-align:left; }.fee-groups th { color:var(--cc-muted); font-weight:650; }.edit-groups th { color:var(--cc-muted); font-weight:650; }.edit-groups th:first-child { width:76px; }.edit-groups td:first-child { width:76px; }.edit-groups :deep(.el-input-number) { width:100%; min-width:0; }.fee-error { display:flex; align-items:center; justify-content:space-between; gap:var(--admin-space-6, 16px); padding:20px; background:#fff4f3; }.fee-error p { margin:5px 0; color:#b42318; font-size:var(--admin-font-caption, 12px); }.fee-empty { display:grid; place-items:center; color:var(--cc-muted); }.dialog-actions { display:flex; gap:var(--admin-space-3, 8px); }.dialog-actions :deep(.el-button + .el-button) { margin-left:0; }
 .edit-group-heading { display:flex; align-items:center; justify-content:space-between; gap:var(--admin-space-5, 12px); margin-bottom:var(--admin-space-4, 10px); }
 .edit-group-heading h3 { min-width:0; }
 .edit-group-heading :deep(.el-button) { flex:0 0 auto; }

src/modules/customers/pages/CustomersView.vue

@@ -1083,7 +1083,7 @@ onMounted(() => { void loadCustomers() })
 
     <AppDialog v-model="editorOpen" :title="editorTitle" :width="editorDialogWidth" class="admin-density-dialog customer-density-dialog customer-editor-dialog" :loading="editorLoading" :confirm-loading="saving" destroy-on-close>
       <el-form ref="formRef" v-loading="editorLoading" :model="form" :rules="rules" label-position="top" class="drawer-form" :disabled="editorLoading || saving || submitting || uploadingQualifications">
-        <FormSection title="基础资料" description="维护工商登记和企业主体信息。"><div class="form-grid three-cols">
+        <FormSection title="基础资料"><div class="form-grid three-cols">
           <el-form-item label="公司名称" prop="tenantName" required><el-input v-model="form.tenantName" placeholder="请输入工商登记公司名称" maxlength="128" /></el-form-item>
           <el-form-item label="客户昵称" prop="customerNickname"><el-input v-model="form.customerNickname" placeholder="不填默认生成中文拼音大写首字母，如 SZWL" maxlength="32" /><small class="field-hint">创建后仍可在客户资料中修改。</small></el-form-item>
           <el-form-item label="营业执照企业名称" prop="legalName" required><el-input v-model="form.legalName" placeholder="请输入营业执照上的企业名称" maxlength="128" /></el-form-item>
@@ -1093,7 +1093,7 @@ onMounted(() => { void loadCustomers() })
           <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>
         </div><el-form-item label="注册地址" prop="registeredAddress"><el-input v-model="form.registeredAddress" placeholder="请输入省市区、街道及门牌信息" maxlength="500" /></el-form-item></FormSection>
 
-        <FormSection title="联系与商务" description="维护客户联系人、账期和内部跟进信息。"><div class="form-grid three-cols">
+        <FormSection title="联系与商务"><div class="form-grid three-cols">
           <el-form-item label="联系人" prop="contactName" required><el-input v-model="form.contactName" placeholder="请输入主要联系人姓名" maxlength="64" /></el-form-item>
           <el-form-item label="公司联系电话" prop="contactPhone" required><el-input v-model="form.contactPhone" placeholder="请输入公司联系电话" maxlength="32" /><small class="field-hint">仅用于企业业务联系，不会修改企业管理员登录手机号；登录手机号请在成员/账号管理中单独维护，修改会影响登录。</small></el-form-item>
           <el-form-item label="联系邮箱" prop="contactEmail"><el-input v-model="form.contactEmail" placeholder="如：contact@example.com" maxlength="128" /></el-form-item>

src/modules/dashboard/pages/DashboardView.test.ts

@@ -48,7 +48,7 @@ describe('DashboardView', () => {
     const wrapper = mount(DashboardView)
     await flushPromises()
 
-    expect(wrapper.text()).toContain('核心指标来自实时业务数据')
+    expect(wrapper.find('.dashboard-context > p').exists()).toBe(false)
     expect(wrapper.text()).toContain('数据更新时间：2026-09-11 12:00')
     expect(wrapper.findAll('.dashboard-metric')).toHaveLength(4)
     expect(wrapper.findAll('.dashboard-metric p').map(label => label.text())).toEqual(['今日新运单', '在途柜量', '活跃客户', '待清关票数'])
@@ -77,7 +77,7 @@ describe('DashboardView', () => {
     await wrapper.findAll('button').find(button => button.text().trim() === '刷新数据')!.trigger('click')
     await flushPromises()
     expect(getTodayNewOrderCount).toHaveBeenCalledTimes(2)
-    expect(wrapper.text()).toContain('核心指标来自实时业务数据')
+    expect(wrapper.find('.dashboard-context > p').exists()).toBe(false)
     expect(wrapper.text()).toContain('12 票')
   })
 

src/modules/dashboard/pages/DashboardView.vue

@@ -86,8 +86,8 @@ onBeforeUnmount(() => document.removeEventListener('fullscreenchange', syncFulls
 <template>
   <section ref="dashboardRef" class="dashboard-view">
     <AdminPage as="div" spacing="normal">
-      <section class="dashboard-context" aria-label="数据看板说明">
-        <p>{{ !hasMetrics ? '当前账号暂无可查看的首页指标，请从左侧菜单进入已授权业务。' : metricsError ? '部分核心指标加载失败，可刷新重试。' : '核心指标来自实时业务数据。' }}</p>
+      <section class="dashboard-context" aria-label="数据看板操作">
+        <p v-if="!hasMetrics || metricsError">{{ !hasMetrics ? '当前账号暂无可查看的首页指标，请从左侧菜单进入已授权业务。' : '部分核心指标加载失败，可刷新重试。' }}</p>
         <div class="dashboard-head-actions">
           <span v-if="hasMetrics">数据更新时间：{{ metricsUpdatedAt ? dayjs(metricsUpdatedAt).format('YYYY-MM-DD HH:mm') : '加载中' }}</span>
           <button v-if="hasMetrics" type="button" class="dashboard-outline-button" :disabled="metricsLoading" @click="loadMetrics">
@@ -119,7 +119,7 @@ onBeforeUnmount(() => document.removeEventListener('fullscreenchange', syncFulls
 .dashboard-view:fullscreen { overflow: auto; padding: 24px; background: var(--cc-page, #f4f6f8); }
 .dashboard-context { display: flex; min-width: 0; align-items: center; justify-content: space-between; gap: 16px; }
 .dashboard-context p { min-width: 0; margin: 0; color: var(--cc-muted, #667085); font-size: 12px; line-height: 1.55; }
-.dashboard-head-actions { display: flex; align-items: center; gap: 14px; color: var(--cc-muted, #667085); font-size: 12px; white-space: nowrap; }
+.dashboard-head-actions { margin-left: auto; display: flex; align-items: center; gap: 14px; color: var(--cc-muted, #667085); font-size: 12px; white-space: nowrap; }
 .dashboard-outline-button { display: inline-flex; min-height: 36px; align-items: center; justify-content: center; gap: 6px; padding: 0 13px; border: 1px solid var(--cc-border-strong, #d8deea); border-radius: var(--cc-radius-md, 6px); background: var(--cc-surface, #fff); color: var(--cc-text-secondary, #344054); cursor: pointer; transition: border-color .18s ease, background .18s ease, color .18s ease; }
 .dashboard-outline-button:hover:not(:disabled) { border-color: var(--cc-primary); color: var(--cc-primary); }
 .dashboard-outline-button:disabled { cursor: wait; opacity: .65; }

src/modules/domestic-containers/pages/DomesticContainersView.vue

@@ -21,10 +21,10 @@ import './domesticContainersSummary.css'
 
 type TabName = 'inbound' | 'outbound' | 'inventory'
 const router = useRouter(); const access = useAccessPreviewStore(); const activeTab = ref<TabName>('inbound')
-const businessTabs: Array<{ value: TabName; label: string; icon: string }> = [
-  { value: 'inbound', label: '整柜入库单', icon: '📥' },
-  { value: 'outbound', label: '整柜出库单', icon: '📤' },
-  { value: 'inventory', label: '整柜库存', icon: '📦' },
+const businessTabs: Array<{ value: TabName; label: string }> = [
+  { value: 'inbound', label: '整柜入库单' },
+  { value: 'outbound', label: '整柜出库单' },
+  { value: 'inventory', label: '整柜库存' },
 ]
 const loading = ref(false); const loadError = ref<ApiErrorDetails | null>(null); const rows = ref<(ContainerOrder | InventoryRecord)[]>([]); const page = ref(1); const pageSize = ref(20); const total = ref(0)
 const summary = ref<InventorySummary>({ inboundBoxes: 0, outboundBoxes: 0, availableBoxes: 0, inboundVolumeCbm: 0 })
@@ -76,7 +76,7 @@ watch([page, pageSize], load); onMounted(async () => { await Promise.all([loadWa
 <LoadErrorState v-if="warehouseError" compact title="国内仓候选加载失败" :message="warehouseError.message" :loading="warehouseLoading" @retry="loadWarehouses"><template #details><ApiErrorMeta :details="warehouseError" /></template></LoadErrorState>
 <ListPageLayout :aria-label="`${activeTab === 'inbound' ? '整柜入库单' : activeTab === 'outbound' ? '整柜出库单' : '整柜库存'}列表`"><section id="domestic-container-results" ><DataTable appearance="integrated" :stripe="false" column-settings-mode="show" :results-visible="!loadError" v-model:page="page" v-model:page-size="pageSize" :data="rows" :columns="columns" :loading="loading" :total="total" row-key="id" :preference-key="`domestic-containers-${activeTab}-table`" :empty-text="activeTab === 'inbound' ? '暂无整柜入库单' : activeTab === 'outbound' ? '暂无整柜出库单' : '暂无整柜库存'">
         <template #toolbar-start><h1>整柜业务</h1></template>
-        <template #filters><div class="business-query-panel integrated-query-group"><div class="status-tabs density-status-tabs" role="tablist" aria-label="整柜业务类型"><button v-for="(tab, index) in businessTabs" :key="tab.value" type="button" role="tab" :aria-selected="activeTab === tab.value" aria-controls="domestic-container-results" :tabindex="activeTab === tab.value ? 0 : -1" :class="['status-tab', { 'is-active': activeTab === tab.value }]" @click="switchTab(tab.value)" @keydown="handleTabKeydown($event, index)"><span class="density-tab-icon" aria-hidden="true">{{ tab.icon }}</span>{{ tab.label }}</button></div><QueryToolbar v-model="filters" class="business-query-toolbar" ariaLabel="整柜业务筛选" :fields="queryFields" :preference-key="`domestic-containers-${activeTab}-query`" @search="search" /></div></template>
+        <template #filters><div class="business-query-panel integrated-query-group"><div class="status-tabs density-status-tabs" role="tablist" aria-label="整柜业务类型"><button v-for="(tab, index) in businessTabs" :key="tab.value" type="button" role="tab" :aria-selected="activeTab === tab.value" aria-controls="domestic-container-results" :tabindex="activeTab === tab.value ? 0 : -1" :class="['status-tab', { 'is-active': activeTab === tab.value }]" @click="switchTab(tab.value)" @keydown="handleTabKeydown($event, index)">{{ tab.label }}</button></div><QueryToolbar v-model="filters" class="business-query-toolbar" ariaLabel="整柜业务筛选" :fields="queryFields" :preference-key="`domestic-containers-${activeTab}-query`" @search="search" /></div></template>
         <template #notices><template v-if="loadError"><LoadErrorState title="整柜业务加载失败" :message="loadError.message" :loading="loading" @retry="load"><template #details><ApiErrorMeta :details="loadError" /></template></LoadErrorState></template></template>
         <template #before-results><div v-if="activeTab === 'inventory'" class="inventory-summary"><div><span>入库箱数</span><strong>{{ summary.inboundBoxes }}</strong></div><div><span>已出库箱数</span><strong>{{ summary.outboundBoxes }}</strong></div><div><span>当前库存</span><strong>{{ summary.availableBoxes }}</strong></div><div><span>累计入库体积</span><strong>{{ summary.inboundVolumeCbm.toFixed(2) }} m³</strong></div></div></template>
 <template #toolbar-actions><el-button v-if="activeTab === 'inbound' && access.can('platform:domestic-container:inbound:create')" type="primary" @click="openInbound"><Plus :size="16" />新建入库单</el-button><el-button v-if="activeTab === 'outbound' && access.can('platform:domestic-container:outbound:create')" type="primary" @click="openOutbound"><Plus :size="16" />新建出库单</el-button></template><template #actions="{ row }"><div class="row-actions density-actions admin-text-actions"><el-button v-if="canViewInventory(row as ContainerOrder | InventoryRecord)" class="density-action" size="small" @click="viewInventory(row as ContainerOrder | InventoryRecord)">查看</el-button><span v-else>—</span></div></template><template #status="{ row }"><StatusBadge :status="statusLabel(row as ContainerOrder | InventoryRecord)" /></template></DataTable></section></ListPageLayout>

src/modules/fee-items/PROTOTYPE_MATRIX.md

@@ -0,0 +1,12 @@
+# 费用项目默认价格核对
+
+本轮依据：2026-10-19 用户确认“固定价格，使用的地方也能修改，只是带入”。原型入口为 `docs/悦/货代SAAS平台后台/prototype-src/modules/10-general.html:8-12` 的 `page-gen-fee`、`tbody-gen-fee`；原型没有默认价格字段及该页新增/编辑表单定义，新增字段按本轮确认实现。
+
+| 页面 | 操作 | 原型承载/布局 | 当前实现及本轮结论 |
+|---|---|---|---|
+| 费用项目 | 列表 | 页面内表格，原型无价格列 | 沿用列表，增加默认价格列，空值显示“—” |
+| 费用项目 | 新增、编辑 | 原型未定义表单尺寸与承载方式 | 沿用现有 620px 抽屉与表单，增加可空默认价格及说明 |
+| 入库费用 | 新增、编辑、调整时选费 | 本轮仅变更选费带值逻辑 | 沿用现有表单；主动选择时带入单价和金额，支持人工覆盖，回显保留原值 |
+| 柜次费用 | 新增时选费 | 本轮仅变更选费带值逻辑 | 沿用现有表单；主动选择时带入金额，支持人工覆盖，调整回显保留原值 |
+
+详情、审核、文件预览、删除和停用操作无变更。自动检查与视觉验收分开；1920×1080、100% 缩放待人工截图确认。

src/modules/fee-items/api/platformFeeItems.test.ts

@@ -19,6 +19,7 @@ const payload: SavePlatformFeeItemRequest = {
   category: '仓储成本',
   tradeScope: 'INTERNATIONAL',
   feeTypeName: '仓库租赁费',
+  defaultPrice: 60,
   supplierCategory: 'TRUCKING',
   pickupPayable: false,
   pickupReceivable: false,

src/modules/fee-items/api/platformFeeItems.ts

@@ -11,6 +11,7 @@ export interface PlatformFeeItemResource {
   feeCode: string | null
   supplierCategory: SupplierCategory | null
   feeTypeName: string
+  defaultPrice: number | null
   pickupPayable: boolean
   pickupReceivable: boolean
   warehousePayable: boolean
@@ -28,6 +29,7 @@ export interface SavePlatformFeeItemRequest {
   category: string
   tradeScope: FeeItemTradeScope
   feeTypeName: string
+  defaultPrice: number | null
   supplierCategory: SupplierCategory | null
   pickupPayable: boolean
   pickupReceivable: boolean

src/modules/fee-items/pages/FeeItemsView.test.ts

@@ -6,7 +6,7 @@ import { enableAutoUnmount, flushPromises, mount } from '@vue/test-utils'
 import { afterAll, afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { useAccessPreviewStore } from '@/core/access/accessPreview'
 import { useAuthStore } from '@/core/auth/auth'
-import { listPlatformFeeItems } from '@/modules/fee-items/api/platformFeeItems'
+import { createPlatformFeeItem, listPlatformFeeItems, updatePlatformFeeItem } from '@/modules/fee-items/api/platformFeeItems'
 import FeeItemsView from './FeeItemsView.vue'
 
 const source = readFileSync(join(process.cwd(), 'src/modules/fee-items/pages/FeeItemsView.vue'), 'utf8').replace(/\r\n/g, '\n')
@@ -54,6 +54,26 @@ enableAutoUnmount(afterEach)
 afterAll(() => vi.unstubAllGlobals())
 
 describe('FeeItemsView public master data and access', () => {
+  it('saves configured and zero prices and clears the default on edit', async () => {
+    const wrapper = await mountView(['firstleg:fee-item:view', 'firstleg:fee-item:create', 'firstleg:fee-item:edit'])
+    const state = (wrapper.vm.$ as unknown as { setupState: {
+      openCreate(): void; saveFeeItem(): Promise<void>
+      form: { id: string; category: string; feeTypeName: string; defaultPrice: number | null }
+    } }).setupState
+    state.openCreate(); await flushPromises()
+    Object.assign(state.form, { category: '操作费', feeTypeName: '加封费', defaultPrice: 60 })
+    await state.saveFeeItem(); await flushPromises()
+    expect(createPlatformFeeItem).toHaveBeenLastCalledWith(expect.objectContaining({ defaultPrice: 60 }))
+    state.openCreate(); await flushPromises()
+    Object.assign(state.form, { category: '操作费', feeTypeName: '零元费', defaultPrice: 0 })
+    await state.saveFeeItem(); await flushPromises()
+    expect(createPlatformFeeItem).toHaveBeenLastCalledWith(expect.objectContaining({ defaultPrice: 0 }))
+    state.openCreate(); await flushPromises()
+    Object.assign(state.form, { id: '1', category: '操作费', feeTypeName: '加封费', defaultPrice: null })
+    await state.saveFeeItem(); await flushPromises()
+    expect(updatePlatformFeeItem).toHaveBeenCalledWith('1', expect.objectContaining({ defaultPrice: null }))
+  })
+
   beforeEach(() => {
     vi.stubGlobal('ResizeObserver', ResizeObserverStub)
     vi.stubGlobal('localStorage', createMemoryStorage())

src/modules/fee-items/pages/FeeItemsView.vue

@@ -71,6 +71,7 @@ function emptyForm(): FeeItemForm {
     category: '',
     tradeScope: 'DOMESTIC',
     feeTypeName: '',
+    defaultPrice: null,
     supplierCategory: null,
     pickupPayable: false,
     pickupReceivable: false,
@@ -86,6 +87,7 @@ const rules: FormRules<FeeItemForm> = {
   category: [{ required: true, message: '请输入费用分类', trigger: 'blur' }],
   tradeScope: [{ required: true, message: '请选择贸易范围', trigger: 'change' }],
   feeTypeName: [{ required: true, message: '请输入费用名称', trigger: 'blur' }],
+  defaultPrice: [{ type: 'number', min: 0, max: 9999999999.99, message: '默认价格须为非负金额，最多两位小数', trigger: 'change' }],
 }
 const hasPayableDirection = computed(() => form.pickupPayable || form.warehousePayable)
 
@@ -118,6 +120,7 @@ const columns: DataTableColumn[] = [
   { key: 'actions', label: '操作', width: 250, fixed: 'left', slotName: 'actions' },
   { key: 'feeTypeName', label: '费用项目', minWidth: 210, slotName: 'feeItem' },
   { key: 'category', prop: 'category', label: '费用分类', minWidth: 150 },
+  { key: 'defaultPrice', label: '默认价格(CNY)', width: 150, formatter: (row: PlatformFeeItemResource) => row.defaultPrice == null ? '—' : Number(row.defaultPrice).toFixed(2) },
   { key: 'tradeScope', label: '贸易范围', width: 110, slotName: 'tradeScope' },
   { key: 'pickup', label: '提货', minWidth: 160, slotName: 'pickup' },
   { key: 'warehouse', label: '仓库', minWidth: 160, slotName: 'warehouse' },
@@ -203,6 +206,7 @@ function assignForm(item: PlatformFeeItemResource) {
     category: item.category,
     tradeScope: item.tradeScope,
     feeTypeName: item.feeTypeName,
+    defaultPrice: item.defaultPrice,
     supplierCategory: item.supplierCategory,
     pickupPayable: item.pickupPayable,
     pickupReceivable: item.pickupReceivable,
@@ -236,6 +240,7 @@ function buildPayload(): SavePlatformFeeItemRequest {
     category: form.category.trim(),
     tradeScope: form.tradeScope,
     feeTypeName: form.feeTypeName.trim(),
+    defaultPrice: form.defaultPrice ?? null,
     supplierCategory: hasPayableDirection.value ? form.supplierCategory : null,
     pickupPayable: form.pickupPayable,
     pickupReceivable: form.pickupReceivable,
@@ -432,7 +437,7 @@ onMounted(() => {
       :confirm-loading="saving"
     >
       <el-form class="density-form" ref="formRef" :model="form" :rules="rules" label-position="top" :disabled="saving || editorLoading">
-        <FormSection class="density-form-section" title="基本信息" description="费用项目为平台公共主数据，不按客户单独维护。">
+        <FormSection class="density-form-section" title="基本信息">
           <div class="form-grid two-cols">
             <el-form-item label="费用名称" prop="feeTypeName" required><el-input v-model="form.feeTypeName" maxlength="128" placeholder="请输入费用名称" /></el-form-item>
             <el-form-item label="费用分类" prop="category" required><el-input v-model="form.category" maxlength="64" placeholder="例如 仓储成本" /></el-form-item>
@@ -440,6 +445,10 @@ onMounted(() => {
           <el-form-item label="贸易范围" prop="tradeScope" required>
             <el-segmented v-model="form.tradeScope" :options="[{ label: '国内', value: 'DOMESTIC' }, { label: '国际', value: 'INTERNATIONAL' }]" />
           </el-form-item>
+          <el-form-item label="默认价格(CNY)" prop="defaultPrice">
+            <el-input-number v-model="form.defaultPrice" :min="0" :max="9999999999.99" :precision="2" controls-position="right" placeholder="不填则由使用时手工录入" />
+          </el-form-item>
+          <p class="muted-value">选择费用项目时自动带入，使用时仍可修改；清空表示不设置默认价格。</p>
         </FormSection>
         <FormSection class="density-form-section" title="费用方向" description="选择费用在提货和仓库环节的应收、应付属性。">
           <div class="direction-grid">

src/modules/iam/pages/InternalUsersView.vue

@@ -431,7 +431,7 @@ onMounted(loadInitialData)
 
     <AppDialog v-model="editorOpen" :title="editorLabel" width="min(650px, calc(100vw - 28px))" class="internal-user-editor-dialog admin-density-dialog iam-density" destroy-on-close :confirm-loading="saving" :confirm-text="editingUser ? '保存修改' : '确认添加'" @confirm="saveUser">
       <el-form class="density-form" ref="formRef" :model="form" :rules="formRules" label-position="top">
-        <FormSection class="density-form-section" title="用户资料" description="维护登录身份、联系方式与平台角色。">
+        <FormSection class="density-form-section" title="用户资料">
           <div class="form-grid two-cols">
           <el-form-item label="用户名" prop="username" required>
             <el-input v-model="form.username" :disabled="Boolean(editingUser)" placeholder="登录用户名" maxlength="64" />

src/modules/iam/pages/RolesView.vue

@@ -264,7 +264,7 @@ onMounted(loadRoles)
     <AppDialog v-model="editorOpen" :title="form.id ? '配置角色' : '新增角色'" width="min(860px, calc(100vw - 28px))" class="role-editor-dialog admin-density-dialog iam-density" :confirm-loading="saving" confirm-text="保存角色" :show-confirm="form.id ? canEdit || canGrant : canCreate" destroy-on-close @opened="initializePermissionSelection" @confirm="saveRole">
       <el-form ref="formRef" :model="form" :rules="formRules" label-position="top" class="role-editor-form density-form">
         <div class="role-editor-layout">
-          <FormSection title="基本信息" description="维护角色名称、编码和职责说明。" class="role-editor-basic density-form-section">
+          <FormSection title="基本信息" class="role-editor-basic density-form-section">
             <el-form-item label="角色名称" prop="name" required><el-input v-model="form.name" :disabled="Boolean(form.id) && !canEdit" placeholder="如：订单运营专员" maxlength="64" /></el-form-item>
             <el-form-item label="角色编码" prop="code" required><el-input v-model="form.code" :disabled="Boolean(form.id)" placeholder="如：ORDER_OPERATOR" maxlength="64" /></el-form-item>
             <el-form-item label="角色说明"><el-input v-model="form.description" :disabled="Boolean(form.id) && !canEdit" type="textarea" :rows="3" placeholder="说明该角色的工作范围" maxlength="200" show-word-limit /></el-form-item>

src/modules/inbounds/components/InboundWorkflowWorkspace.vue

@@ -107,7 +107,6 @@ onBeforeUnmount(() => {
           <h2>入库码：{{ title }}</h2>
           <StatusBadge v-if="detail" :status="statusLabel" />
         </div>
-        <p>按基本信息、货物测量、审核、费用和托盘库位顺序处理，所有结果以服务端最新状态为准。</p>
       </div>
       <el-button :loading="loading" :disabled="!customerId || !inboundId" @click="refreshWorkspace">
         <RefreshCw :size="16" />刷新
@@ -235,7 +234,6 @@ onBeforeUnmount(() => {
 .workspace-header { display: flex; align-items: flex-start; justify-content: space-between; gap: 20px; padding: 18px 24px 16px; border-bottom: 1px solid var(--cc-border); }
 .workspace-title-row { display: flex; min-width: 0; align-items: center; flex-wrap: wrap; gap: 10px; }
 .workspace-title-row h2 { margin: 0; overflow-wrap: anywhere; color: #172033; font-size: 16px; line-height: 1.35; }
-.workspace-header p { margin: 5px 0 0; color: var(--cc-muted); font-size: 12px; line-height: 1.5; }
 .workspace-state { margin: 24px; }
 .workspace-skeleton { padding: 0; }
 .workflow-tabs { min-width: 0; padding: 0 24px 24px; }

src/modules/inbounds/fee/InboundFeePanel.test.ts

@@ -235,11 +235,13 @@ describe('InboundFeePanel', () => {
 
   it('treats A0404 as a neutral not-yet-generated state', async () => {
     vi.mocked(getLatestInboundFee).mockRejectedValue(new ApiResponseError('费用快照不存在', 'A0404'))
-    mountPanel(['firstleg:fba-pricing:view'])
+    const wrapper = mountPanel(['firstleg:fba-pricing:view'])
     await flushPromises()
 
     expect(document.body.textContent).toContain('尚未生成费用快照')
-    expect(document.body.textContent).toContain('测量审核完成后')
+    expect(document.body.textContent).not.toContain('测量审核完成后')
+    await wrapper.get('button[aria-label="查看计费说明"]').trigger('mouseenter')
+    await vi.waitFor(() => expect(document.body.textContent).toContain('测量审核完成后'))
     expect(document.querySelector('[role="alert"]')).toBeNull()
   })
 

src/modules/inbounds/fee/InboundFeePanel.vue

@@ -1,4 +1,5 @@
 <script setup lang="ts">
+import InlineHelp from '@/shared/components/InlineHelp.vue'
 import { computed, reactive, ref, watch } from 'vue'
 import { ElMessage, ElMessageBox, type FormInstance, type FormRules } from 'element-plus'
 import { Check, CircleDollarSign, PencilLine, RefreshCw, Send } from '@lucide/vue'
@@ -379,12 +380,11 @@ defineExpose({ reload: loadFee })
 <template>
   <section class="inbound-fee-panel" :aria-busy="loading" aria-labelledby="inbound-fee-title">
     <header class="fee-heading" :class="{ 'fee-heading--compact': compact }">
-      <h3 v-if="compact" id="inbound-fee-title" class="fee-heading-title--compact">头程自动初算</h3>
+      <h3 v-if="compact" id="inbound-fee-title" class="fee-heading-title--compact">头程自动初算 <InlineHelp title="计费说明"><p>测量审核完成后，系统会自动生成初算费用；人工确认后才发布。</p><p>实际重量与体积重量取大后计费，金额以服务端快照为准。</p></InlineHelp></h3>
       <div v-else class="fee-heading-copy">
         <span class="fee-heading-icon" aria-hidden="true"><CircleDollarSign :size="20" /></span>
         <div>
-          <h3 id="inbound-fee-title">入库费用快照</h3>
-          <p>测量审核后的头程费用，人工确认后才发布。</p>
+          <h3 id="inbound-fee-title">入库费用快照 <InlineHelp title="计费说明"><p>测量审核完成后，系统会自动生成初算费用；人工确认后才发布。</p><p>实际重量与体积重量取大后计费，金额以服务端快照为准。</p></InlineHelp></h3>
         </div>
       </div>
       <div class="fee-heading-actions">
@@ -470,7 +470,6 @@ defineExpose({ reload: loadFee })
     </el-alert>
 
     <el-empty v-else-if="notFound" :image-size="64" description="尚未生成费用快照">
-      <p class="empty-note">测量审核完成后，系统会自动生成初算费用；人工确认后才发布。</p>
     </el-empty>
 
     <div v-else-if="snapshot" class="fee-content">
@@ -504,7 +503,7 @@ defineExpose({ reload: loadFee })
 
       <section class="calculation-section" aria-labelledby="calculation-title">
         <div class="section-title">
-          <div><h4 id="calculation-title">计费依据</h4><p v-if="!compact">实际重量与体积重量取大后计费，金额以服务端快照为准。</p></div>
+          <div><h4 id="calculation-title">计费依据</h4></div>
           <div class="calculation-tags">
             <el-tag effect="plain">订单报关：{{ taxModeLabel(snapshot.taxMode) }}</el-tag>
             <el-tag effect="plain">报价税制：{{ pricingTaxModeLabel(snapshot.pricingTaxMode) }}</el-tag>

src/modules/inbounds/measurement/InboundMeasurementPanel.vue

@@ -922,7 +922,7 @@ defineExpose({ saveDraft, submitForReview, updateWeightEvidence, submissionBlock
 .measurement-comparison thead th { background: #f8fafc; }
 .measurement-comparison thead th:nth-child(2) { background: #f7f9ff; color: #465fc4; }
 .measurement-comparison thead th:nth-child(3) { background: #f4fbf8; color: #18795d; }
-.measurement-comparison__difference { color: var(--el-color-warning-dark-2); font-weight: 600; }
+.measurement-comparison__difference { color: var(--el-color-danger-dark-2); font-weight: 600; }
 .measurement-extra-facts { display: flex; flex-wrap: wrap; gap: var(--admin-space-3, 8px) var(--admin-space-6, 16px); color: var(--cc-muted); font-size: var(--admin-font-caption, 12px); }
 .measurement-extra-facts strong { color: var(--cc-text); }
 .measurement-panel { overflow: hidden; }
@@ -947,7 +947,7 @@ defineExpose({ saveDraft, submitForReview, updateWeightEvidence, submissionBlock
 .measurement-summary-header { display: flex; align-items: flex-start; justify-content: space-between; gap: 20px; }
 .measurement-summary-context { display: flex; min-width: 0; flex-wrap: wrap; align-items: center; gap: var(--admin-space-3, 8px) 20px; }
 .measurement-summary-header span { color: var(--cc-muted); font-size: var(--admin-font-caption, 11px); }
-.measurement-deviation-alert { margin: 0; width: auto; }
+.measurement-deviation-alert { --el-color-warning: var(--el-color-danger-dark-2); --el-color-warning-dark-2: var(--el-color-danger-dark-2); margin: 0; width: auto; }
 .measurement-deviation-alert p { margin: 3px 0 0; line-height: 1.55; }
 .measurement-summary-context p { display: inline-flex; min-width: 0; align-items: baseline; gap: var(--admin-space-2, 6px); margin: 0; overflow-wrap: anywhere; color: var(--cc-text); font-size: var(--admin-font-caption, 12px); font-weight: 600; }
 .measurement-summary-status { display: flex; flex: 0 0 auto; align-items: center; gap: 9px; }

src/modules/loading-lists/api/containerFees.test.ts

@@ -1,12 +1,22 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { http } from '@/shared/api/http'
-import { adjustContainerFee, approveContainerFee, approveContainerFeeAllocationGroup, createContainerFee, createContainerFeeAllocationGroup, getContainerSettlementDetails, listContainerFeeSupplierOptions, listContainerFees, rejectContainerFee, uploadContainerFeePaymentVoucher, voidContainerFee, voidContainerFeeAllocationGroup } from './containerFees'
+import { adjustContainerFee, approveContainerFee, approveContainerFeeAllocationGroup, createContainerFee, createContainerFeeAllocationGroup, getContainerSettlementDetails, listApplicableFeeItems, listContainerFeeSupplierOptions, listContainerFees, rejectContainerFee, uploadContainerFeePaymentVoucher, voidContainerFee, voidContainerFeeAllocationGroup } from './containerFees'
 import { listSuppliers } from '@/modules/suppliers'
 
 vi.mock('@/modules/suppliers', () => ({ listSuppliers: vi.fn() }))
 
 describe('container fee API', () => {
   beforeEach(() => vi.restoreAllMocks())
+  it('retains configured, zero and empty default prices when loading fee choices', async () => {
+    vi.spyOn(http, 'get').mockResolvedValue({ code: '200', data: { records: [
+      { id: 1, feeTypeName: '操作费', defaultPrice: '60.25' },
+      { id: 2, feeTypeName: '零元费', defaultPrice: 0 },
+      { id: 3, feeTypeName: '手工费', defaultPrice: null },
+    ] } })
+    await expect(listApplicableFeeItems()).resolves.toMatchObject([
+      { id: '1', defaultPrice: 60.25 }, { id: '2', defaultPrice: 0 }, { id: '3', defaultPrice: null },
+    ])
+  })
   it('passes accountId and exact controller DTOs', async () => {
     const get = vi.spyOn(http, 'get').mockResolvedValue({ code: '200', data: [] })
     const post = vi.spyOn(http, 'post').mockResolvedValue({ code: '200', data: { id: 3, loadingPlanId: 9, containerBookingId: 99, feeItemId: 7, feeItemNameSnapshot: '操作费', direction: 'PAYABLE', supplierId: 41, supplierName: '承运商A', supplierCategory: 'TRUCKING', settlementMode: 'DIRECT_PAID', paidAt: '2026-08-12T10:30:00', paymentMethod: 'BANK_TRANSFER', paymentReferenceNo: 'BANK-7', paymentVoucherFileIds: [9001], businessDate: '2026-08-12', amount: 100, currency: 'CNY', reviewStatus: 'PENDING', sourceStatus: 'ACTIVE', sourceVersion: 1 } })

src/modules/loading-lists/api/containerFees.ts

@@ -84,6 +84,7 @@ export interface ContainerFeeAllocationGroupAdjustRequest {
 }
 
 export interface ApplicableFeeItem {
+  defaultPrice: number | null
   id: string
   name: string
   feeCode: string
@@ -224,7 +225,7 @@ export async function voidContainerFee(planId: string, accountId: string, feeId:
 
 export async function listApplicableFeeItems() {
   const response = await http.get<ApiEnvelope<{ records: Record<string, unknown>[] }>, ApiEnvelope<{ records: Record<string, unknown>[] }>>('/platform/v1/fee-items', { params: { status: 'ACTIVE', page: 1, size: 200 } })
-  return (unwrapApiResponse(response).records || []).map((raw) => ({ id: id(raw.id), name: String(raw.feeTypeName || ''), feeCode: String(raw.feeCode || ''), supplierCategory: supplierCategory(raw.supplierCategory), warehouseReceivable: Boolean(raw.warehouseReceivable), warehousePayable: Boolean(raw.warehousePayable), pickupReceivable: Boolean(raw.pickupReceivable), pickupPayable: Boolean(raw.pickupPayable) }))
+  return (unwrapApiResponse(response).records || []).map((raw): ApplicableFeeItem => ({ id: id(raw.id), name: String(raw.feeTypeName || ''), defaultPrice: raw.defaultPrice == null ? null : Number(raw.defaultPrice), feeCode: String(raw.feeCode || ''), supplierCategory: supplierCategory(raw.supplierCategory), warehouseReceivable: Boolean(raw.warehouseReceivable), warehousePayable: Boolean(raw.warehousePayable), pickupReceivable: Boolean(raw.pickupReceivable), pickupPayable: Boolean(raw.pickupPayable) }))
 }
 
 export async function listContainerFeeSupplierOptions(category: SupplierCategory | null): Promise<ContainerFeeSupplierOption[]> {

src/modules/loading-lists/components/ContainerFeesPanel.test.ts

@@ -39,6 +39,90 @@ beforeEach(() => {
 })
 
 describe('ContainerFeesPanel contract', () => {
+  it.each(['success', 'failure'])('ignores a closed editor request that finishes late: %s', async (outcome) => {
+    const item = { id: '7', name: '操作费', feeCode: 'OPERATION', defaultPrice: 60, supplierCategory: null, warehouseReceivable: true, warehousePayable: false, pickupReceivable: false, pickupPayable: false }
+    let resolveOld!: (items: typeof item[]) => void
+    let rejectOld!: (reason: Error) => void
+    vi.mocked(listApplicableFeeItems).mockImplementationOnce(() => new Promise((resolve, reject) => { resolveOld = resolve; rejectOld = reject }))
+    vi.mocked(listApplicableFeeItems).mockResolvedValueOnce([{ ...item, defaultPrice: 80 }])
+    const wrapper = await mountPanel(['firstleg:inbound:fee-detail:view', 'firstleg:inbound:fee-detail:edit', 'firstleg:fee-item:view'])
+    const state = (wrapper.vm.$ as unknown as { setupState: {
+      openCreate(): void
+      editorOpen: boolean
+      form: { amount: number }
+      feeItems: typeof item[]
+      feeItemsLoading: boolean
+      feeItemsError: unknown
+    } }).setupState
+    state.openCreate(); await flushPromises()
+    state.editorOpen = false; await flushPromises()
+    state.openCreate(); await flushPromises()
+    expect(state.feeItems[0]?.defaultPrice).toBe(80)
+    if (outcome === 'success') resolveOld([item])
+    else rejectOld(new Error('旧窗口请求失败'))
+    await flushPromises()
+    expect(state.feeItemsError).toBeNull()
+    expect(state.feeItemsLoading).toBe(false)
+    const select = wrapper.findAllComponents({ name: 'ElFormItem' }).find((field) => field.props('prop') === 'feeItemId')!.findComponent({ name: 'ElSelect' })
+    select.vm.$emit('update:modelValue', '7'); select.vm.$emit('change', '7')
+    await flushPromises()
+    expect(state.form.amount).toBe(80)
+    wrapper.unmount()
+  })
+
+  it('does not let an old completion clear the current loading state or refill a closed editor', async () => {
+    const item = { id: '7', name: '操作费', feeCode: 'OPERATION', defaultPrice: 60, supplierCategory: null, warehouseReceivable: true, warehousePayable: false, pickupReceivable: false, pickupPayable: false }
+    let resolveOld!: (items: typeof item[]) => void
+    let resolveCurrent!: (items: typeof item[]) => void
+    vi.mocked(listApplicableFeeItems)
+      .mockImplementationOnce(() => new Promise((resolve) => { resolveOld = resolve }))
+      .mockImplementationOnce(() => new Promise((resolve) => { resolveCurrent = resolve }))
+    const wrapper = await mountPanel(['firstleg:inbound:fee-detail:view', 'firstleg:inbound:fee-detail:edit', 'firstleg:fee-item:view'])
+    const state = (wrapper.vm.$ as unknown as { setupState: {
+      openCreate(): void; editorOpen: boolean; feeItems: unknown[]; feeItemsLoading: boolean; feeItemsError: unknown
+    } }).setupState
+    state.openCreate(); await flushPromises()
+    state.editorOpen = false
+    state.openCreate(); await flushPromises()
+    resolveOld([item]); await flushPromises()
+    expect(state.feeItems).toEqual([])
+    expect(state.feeItemsLoading).toBe(true)
+    state.editorOpen = false; await flushPromises()
+    resolveCurrent([{ ...item, defaultPrice: 80 }]); await flushPromises()
+    expect(state.feeItems).toEqual([])
+    expect(state.feeItemsLoading).toBe(false)
+    expect(state.feeItemsError).toBeNull()
+    wrapper.unmount()
+  })
+
+  it('prefills the selected default, clears stale prices and retains manual overrides', async () => {
+    const base = { name: '操作费', feeCode: 'OPERATION', supplierCategory: null, warehouseReceivable: true, warehousePayable: false, pickupReceivable: false, pickupPayable: false }
+    vi.mocked(listApplicableFeeItems).mockResolvedValue([
+      { ...base, id: '7', defaultPrice: 60 }, { ...base, id: '8', defaultPrice: null }, { ...base, id: '9', defaultPrice: 0 },
+    ])
+    const wrapper = await mountPanel(['firstleg:inbound:fee-detail:view', 'firstleg:inbound:fee-detail:edit', 'firstleg:fee-item:view'])
+    const state = (wrapper.vm.$ as unknown as { setupState: {
+      openCreate(): void; save(): Promise<void>
+      resetForm(row: Record<string, unknown>): void
+      form: { feeItemId: string; amount: number }
+    } }).setupState
+    state.resetForm({ feeItemId: '7', direction: 'RECEIVABLE', businessDate: '2026-08-12', amount: 100 })
+    await flushPromises()
+    expect(state.form.amount).toBe(100)
+    state.openCreate(); await flushPromises()
+    const select = wrapper.findAllComponents({ name: 'ElFormItem' }).find((item) => item.props('prop') === 'feeItemId')!.findComponent({ name: 'ElSelect' })
+    for (const [id, price] of [['7', 60], ['8', 0], ['9', 0]] as const) {
+      select.vm.$emit('update:modelValue', id); select.vm.$emit('change', id)
+      await flushPromises()
+      expect(state.form.amount).toBe(price)
+    }
+    select.vm.$emit('update:modelValue', '7'); select.vm.$emit('change', '7')
+    await flushPromises()
+    state.form.amount = 75
+    await state.save(); await flushPromises()
+    expect(createContainerFee).toHaveBeenCalledWith('9', '11', expect.objectContaining({ feeItemId: '7', amount: 75 }))
+  })
+
   it('keeps fee controls and table utilities in compact aligned toolbars', () => {
     expect(panel).toContain('class="fees-header__actions"')
     expect(panel).toContain('class="customer-context"')
@@ -179,7 +263,7 @@ describe('ContainerFeesPanel contract', () => {
   })
 
   it('keeps receivable usable when supplier permission is missing', async () => {
-    vi.mocked(listApplicableFeeItems).mockResolvedValue([{ id: '7', name: '操作费', feeCode: 'OPERATION', supplierCategory: 'TRUCKING', warehouseReceivable: true, warehousePayable: true, pickupReceivable: false, pickupPayable: false }])
+    vi.mocked(listApplicableFeeItems).mockResolvedValue([{ id: '7', name: '操作费', feeCode: 'OPERATION', defaultPrice: null, supplierCategory: 'TRUCKING', warehouseReceivable: true, warehousePayable: true, pickupReceivable: false, pickupPayable: false }])
     const wrapper = await mountPanel(['firstleg:inbound:fee-detail:view', 'firstleg:inbound:fee-detail:edit', 'firstleg:fee-item:view'])
     const state = (wrapper.vm.$ as unknown as { setupState: { openCreate(): void; form: { direction: string; supplierId: string | null } } }).setupState
     state.openCreate(); await flushPromises()
@@ -190,7 +274,7 @@ describe('ContainerFeesPanel contract', () => {
   })
 
   it('isolates a supplier load failure and clears supplier fields for receivable', async () => {
-    vi.mocked(listApplicableFeeItems).mockResolvedValue([{ id: '7', name: '操作费', feeCode: 'TRUCKING', supplierCategory: 'TRUCKING', warehouseReceivable: true, warehousePayable: true, pickupReceivable: false, pickupPayable: false }])
+    vi.mocked(listApplicableFeeItems).mockResolvedValue([{ id: '7', name: '操作费', feeCode: 'TRUCKING', defaultPrice: null, supplierCategory: 'TRUCKING', warehouseReceivable: true, warehousePayable: true, pickupReceivable: false, pickupPayable: false }])
     vi.mocked(listContainerFeeSupplierOptions).mockRejectedValue(new Error('suppliers unavailable'))
     const wrapper = await mountPanel(['firstleg:inbound:fee-detail:view', 'firstleg:inbound:fee-detail:edit', 'firstleg:fee-item:view', 'platform:supplier:list'])
     const state = (wrapper.vm.$ as unknown as { setupState: { openCreate(): void; form: { direction: string; feeItemId: string; supplierId: string | null }; feeItems: unknown[] } }).setupState
@@ -203,7 +287,7 @@ describe('ContainerFeesPanel contract', () => {
   })
 
   it('submits only the selected supplier ID for payable fees', async () => {
-    vi.mocked(listApplicableFeeItems).mockResolvedValue([{ id: '7', name: '操作费', feeCode: 'TRUCKING', supplierCategory: 'TRUCKING', warehouseReceivable: true, warehousePayable: true, pickupReceivable: false, pickupPayable: false }])
+    vi.mocked(listApplicableFeeItems).mockResolvedValue([{ id: '7', name: '操作费', feeCode: 'TRUCKING', defaultPrice: null, supplierCategory: 'TRUCKING', warehouseReceivable: true, warehousePayable: true, pickupReceivable: false, pickupPayable: false }])
     vi.mocked(listContainerFeeSupplierOptions).mockResolvedValue([{ id: '41', supplierName: '承运商A', category: 'TRUCKING' }])
     const wrapper = await mountPanel(['firstleg:inbound:fee-detail:view', 'firstleg:inbound:fee-detail:edit', 'firstleg:fee-item:view', 'platform:supplier:list'])
     const state = (wrapper.vm.$ as unknown as { setupState: { openCreate(): void; save(): Promise<void>; form: { direction: string; feeItemId: string; supplierId: string | null; settlementMode: string | null; amount: number } } }).setupState
@@ -215,7 +299,7 @@ describe('ContainerFeesPanel contract', () => {
   })
 
   it('allows any loaded ACTIVE supplier when the payable fee item has no supplier category', async () => {
-    vi.mocked(listApplicableFeeItems).mockResolvedValue([{ id: '7', name: '未映射费用', feeCode: 'UNMAPPED', supplierCategory: null, warehouseReceivable: false, warehousePayable: true, pickupReceivable: false, pickupPayable: false }])
+    vi.mocked(listApplicableFeeItems).mockResolvedValue([{ id: '7', name: '未映射费用', feeCode: 'UNMAPPED', defaultPrice: null, supplierCategory: null, warehouseReceivable: false, warehousePayable: true, pickupReceivable: false, pickupPayable: false }])
     vi.mocked(listContainerFeeSupplierOptions).mockResolvedValue([{ id: '41', supplierName: '报关行', category: 'CUSTOMS' }])
     const wrapper = await mountPanel(['firstleg:inbound:fee-detail:view', 'firstleg:inbound:fee-detail:edit', 'firstleg:fee-item:view', 'platform:supplier:list'])
     const state = (wrapper.vm.$ as unknown as { setupState: { openCreate(): void; save(): Promise<void>; form: { direction: string; feeItemId: string; supplierId: string | null; settlementMode: string | null; amount: number } } }).setupState
@@ -227,7 +311,7 @@ describe('ContainerFeesPanel contract', () => {
   })
 
   it('fails closed when a supplier candidate does not match the fee-item category', async () => {
-    vi.mocked(listApplicableFeeItems).mockResolvedValue([{ id: '7', name: '拖车费', feeCode: 'TRUCKING', supplierCategory: 'TRUCKING', warehouseReceivable: false, warehousePayable: true, pickupReceivable: false, pickupPayable: false }])
+    vi.mocked(listApplicableFeeItems).mockResolvedValue([{ id: '7', name: '拖车费', feeCode: 'TRUCKING', defaultPrice: null, supplierCategory: 'TRUCKING', warehouseReceivable: false, warehousePayable: true, pickupReceivable: false, pickupPayable: false }])
     vi.mocked(listContainerFeeSupplierOptions).mockResolvedValue([{ id: '41', supplierName: '报关行', category: 'CUSTOMS' }])
     const wrapper = await mountPanel(['firstleg:inbound:fee-detail:view', 'firstleg:inbound:fee-detail:edit', 'firstleg:fee-item:view', 'platform:supplier:list'])
     const state = (wrapper.vm.$ as unknown as { setupState: { openCreate(): void; save(): Promise<void>; form: { direction: string; feeItemId: string; supplierId: string | null; amount: number } } }).setupState
@@ -249,7 +333,7 @@ describe('ContainerFeesPanel contract', () => {
 
   it('clears paid inputs for RECEIVABLE and ON_ACCOUNT and shows backend settlement semantics', async () => {
     vi.mocked(listContainerFees).mockResolvedValue([{ id: '2', loadingPlanId: '9', containerBookingId: '99', containerNo: null, feeItemId: '7', feeItemName: '已付拖车费', direction: 'PAYABLE', supplierId: '41', supplierName: '承运商A', supplierCategory: 'TRUCKING', settlementMode: 'DIRECT_PAID', paidAt: '2026-08-12T10:00:00', paymentMethod: 'BANK_TRANSFER', paymentReferenceNo: 'BANK-1', paymentVoucherFileIds: ['9001'], businessDate: '2026-08-12', amount: 100, currency: 'CNY', reviewStatus: 'PENDING', sourceStatus: 'ACTIVE', sourceVersion: 1, remark: null, reviewerName: null, reviewedAt: null, reviewReason: null }])
-    vi.mocked(listApplicableFeeItems).mockResolvedValue([{ id: '7', name: '操作费', feeCode: 'TRUCKING', supplierCategory: 'TRUCKING', warehouseReceivable: true, warehousePayable: true, pickupReceivable: false, pickupPayable: false }])
+    vi.mocked(listApplicableFeeItems).mockResolvedValue([{ id: '7', name: '操作费', feeCode: 'TRUCKING', defaultPrice: null, supplierCategory: 'TRUCKING', warehouseReceivable: true, warehousePayable: true, pickupReceivable: false, pickupPayable: false }])
     const wrapper = await mountPanel(['firstleg:inbound:fee-detail:view', 'firstleg:inbound:fee-detail:edit', 'firstleg:fee-item:view', 'platform:supplier:list'])
     expect(wrapper.text()).toContain('已付成本'); expect(wrapper.text()).toContain('银行转账'); expect(wrapper.text()).toContain('BANK-1')
     const state = (wrapper.vm.$ as unknown as { setupState: { openCreate(): void; form: { direction: string; settlementMode: string | null; paidAt: string | null; paymentMethod: string | null; paymentReferenceNo: string | null; paymentVoucherFileIds: string[] | null } } }).setupState
@@ -259,7 +343,7 @@ describe('ContainerFeesPanel contract', () => {
   })
 
   it('fails closed without DIRECT_PAID evidence and submits a scoped uploaded voucher', async () => {
-    vi.mocked(listApplicableFeeItems).mockResolvedValue([{ id: '7', name: '操作费', feeCode: 'TRUCKING', supplierCategory: 'TRUCKING', warehouseReceivable: false, warehousePayable: true, pickupReceivable: false, pickupPayable: false }])
+    vi.mocked(listApplicableFeeItems).mockResolvedValue([{ id: '7', name: '操作费', feeCode: 'TRUCKING', defaultPrice: null, supplierCategory: 'TRUCKING', warehouseReceivable: false, warehousePayable: true, pickupReceivable: false, pickupPayable: false }])
     vi.mocked(listContainerFeeSupplierOptions).mockResolvedValue([{ id: '41', supplierName: '承运商A', category: 'TRUCKING' }])
     const wrapper = await mountPanel(['firstleg:inbound:fee-detail:view', 'firstleg:inbound:fee-detail:edit', 'firstleg:fee-item:view', 'platform:supplier:list'])
     const state = (wrapper.vm.$ as unknown as { setupState: { openCreate(): void; save(): Promise<void>; selectVoucher(event: Event): Promise<void>; form: { direction: string; feeItemId: string; supplierId: string | null; settlementMode: string | null; paidAt: string | null; paymentMethod: string | null; paymentReferenceNo: string | null; amount: number } } }).setupState

src/modules/loading-lists/components/ContainerFeesPanel.vue

@@ -55,6 +55,7 @@ const voucherUploading = ref(false)
 const voucherError = ref<ApiErrorDetails | null>(null)
 const rejection = ref('')
 let loadSequence = 0
+let feeItemLoadSequence = 0
 let supplierLoadSequence = 0
 
 const canView = computed(() => access.can('firstleg:inbound:fee-detail:view'))
@@ -122,6 +123,11 @@ function clearPaidFields() {
   form.paidAt = null; form.paymentMethod = null; form.paymentReferenceNo = null; form.paymentVoucherFileIds = null
   voucherFiles.value = []; voucherError.value = null
 }
+
+// 仅在用户主动选费时带价，保留已有费用回显金额与人工修改。
+function applyFeeItemDefaultPrice() {
+  form.amount = selectedFeeItem.value?.defaultPrice ?? 0
+}
 function settlementLabel(item: ContainerFeeResource) { return item.direction !== 'PAYABLE' ? '—' : item.settlementMode === 'DIRECT_PAID' ? '已付成本' : item.settlementMode === 'ON_ACCOUNT' ? '账期应付' : '未设置' }
 function paymentMethodLabel(value: string | null | undefined) { return ({ ONLINE: '线上支付', BANK_TRANSFER: '银行转账', CASH: '现金', OTHER: '其他' } as Record<string, string>)[value || ''] || '—' }
 function customerLabel(customerId: string) { return customerOptions.value.find((item) => item.value === customerId)?.label || '客户信息缺失' }
@@ -153,12 +159,17 @@ function removeVoucher(fileId: string) {
 }
 
 async function loadFeeItems() {
+  const sequence = ++feeItemLoadSequence
   feeItems.value = []; feeItemsError.value = null
   if (!canViewFeeItems.value) return
   feeItemsLoading.value = true
-  try { feeItems.value = await listApplicableFeeItems() }
-  catch (cause) { feeItemsError.value = getApiErrorDetails(cause, '费用项目加载失败') }
-  finally { feeItemsLoading.value = false }
+  try {
+    const items = await listApplicableFeeItems()
+    // 只接收当前窗口最新请求，旧响应不得覆盖价格或清除新请求的加载状态。
+    if (sequence === feeItemLoadSequence) feeItems.value = items
+  }
+  catch (cause) { if (sequence === feeItemLoadSequence) feeItemsError.value = getApiErrorDetails(cause, '费用项目加载失败') }
+  finally { if (sequence === feeItemLoadSequence) feeItemsLoading.value = false }
 }
 
 async function loadSuppliers() {
@@ -340,6 +351,12 @@ function clearCustomerContext() {
 }
 watch(customerOptions, initializeCustomer, { immediate: true })
 watch(accountId, () => { clearCustomerContext(); void load() })
+watch(editorOpen, (open) => {
+  if (open) return
+  // 同步失效旧窗口请求，覆盖关闭后立即重开及切换客户的情况。
+  feeItemLoadSequence += 1
+  feeItems.value = []; feeItemsError.value = null; feeItemsLoading.value = false
+}, { flush: 'sync' })
 watch(() => form.direction, (direction) => {
   if (!applicableItems.value.some((item) => item.id === form.feeItemId)) form.feeItemId = ''
   if (direction === 'RECEIVABLE') { supplierLoadSequence += 1; form.supplierId = null; form.settlementMode = null; clearPaidFields(); suppliers.value = []; loadedSupplierCategory.value = undefined; suppliersError.value = null; suppliersLoading.value = false }
@@ -353,7 +370,7 @@ onMounted(() => void load())
 <template>
   <section class="fees-panel admin-density" aria-label="柜次费用维护">
     <header class="fees-header">
-      <div><h2>{{ title }}</h2><p>费用与财务分摊均来自服务端真实记录</p></div>
+      <div><h2>{{ title }}</h2></div>
       <div class="fees-header__actions">
         <label v-if="customerOptions.length > 1" class="customer-context"><span>客户</span><el-select v-model="accountId" placeholder="请选择费用归属客户"><el-option v-for="item in customerOptions" :key="item.value" :label="item.label" :value="item.value" /></el-select></label>
         <el-button v-if="canEdit && canViewFeeItems && accountId" type="primary" @click="openCreate"><Plus :size="16" />新增费用</el-button>
@@ -401,7 +418,7 @@ onMounted(() => void load())
       <el-form ref="formRef" :model="form" :rules="rules" label-position="top" class="fee-form density-form">
         <template v-if="!target">
           <el-form-item label="方向" prop="direction"><el-segmented v-model="form.direction" :options="[{ label: '应收', value: 'RECEIVABLE' }, { label: '应付', value: 'PAYABLE', disabled: !canViewSuppliers }]" /></el-form-item>
-          <el-form-item label="费用项目" prop="feeItemId"><el-select v-model="form.feeItemId" filterable :loading="feeItemsLoading" :disabled="!canViewFeeItems" placeholder="请选择启用且适用的费用项目"><el-option v-for="item in applicableItems" :key="item.id" :label="item.name" :value="item.id" /></el-select></el-form-item>
+          <el-form-item label="费用项目" prop="feeItemId"><el-select v-model="form.feeItemId" filterable :loading="feeItemsLoading" :disabled="!canViewFeeItems" placeholder="请选择启用且适用的费用项目" @change="applyFeeItemDefaultPrice"><el-option v-for="item in applicableItems" :key="item.id" :label="item.name" :value="item.id" /></el-select></el-form-item>
           <el-form-item v-if="form.direction === 'PAYABLE'" label="供应商" required><el-select v-model="form.supplierId" filterable :loading="suppliersLoading" :disabled="!canViewSuppliers || !selectedFeeItem || !!suppliersError" placeholder="请先选择费用项目"><el-option v-for="supplier in suppliers" :key="supplier.id" :label="supplier.supplierName" :value="supplier.id" /></el-select></el-form-item>
           <el-form-item v-if="form.direction === 'PAYABLE'" label="结算方式" required><el-radio-group v-model="settlementModeModel"><el-radio-button value="ON_ACCOUNT">账期应付</el-radio-button><el-radio-button value="DIRECT_PAID">已付成本</el-radio-button></el-radio-group></el-form-item>
           <template v-if="form.direction === 'PAYABLE' && form.settlementMode === 'DIRECT_PAID'">
@@ -436,7 +453,7 @@ onMounted(() => void load())
 <style scoped>
 .fees-panel { min-width: 0; overflow: hidden; padding-top: 0; border-top: 0; }
 .fees-header, .allocation-section > header { display: flex; align-items: center; justify-content: space-between; gap: var(--admin-space-5); padding: 0 0 var(--admin-space-5); }
-.fees-header h2, .allocation-section h3 { margin: 0; font-size: var(--admin-font-section); }.fees-header p, .allocation-section p { margin: var(--admin-space-1) 0 0; color: var(--cc-muted); font-size: var(--admin-font-caption); }
+.fees-header h2, .allocation-section h3 { margin: 0; font-size: var(--admin-font-section); }.allocation-section p { margin: var(--admin-space-1) 0 0; color: var(--cc-muted); font-size: var(--admin-font-caption); }
 .fees-header__actions, .customer-context { display: flex; align-items: center; gap: var(--admin-space-4); }
 .customer-context > span { color: var(--cc-muted); font-size: var(--admin-font-body); white-space: nowrap; }.customer-context :deep(.el-select) { width: 260px; }
 .fees-table-title { display: flex; align-items: baseline; gap: var(--admin-space-3); }.fees-table-title strong { font-size: var(--admin-font-section); }.fees-table-title span { color: var(--cc-muted); font-size: var(--admin-font-caption); }

src/modules/loading-lists/components/LoadingListDetailDrawer.vue

@@ -166,7 +166,6 @@ function formatNumber(value?: number | null, digits = 3) {
         <el-button link type="primary" class="detail-page-header__back" :class="{ 'density-back': mode === 'preload' || dense }" @click="emit('back')"><ArrowLeft :size="16" />{{ backLabel || '返回列表' }}</el-button>
         <div v-if="!embedded" class="detail-page-header__identity">
           <h1>{{ title }}</h1>
-          <p v-if="mode !== 'preload'">查看已完成装柜明细和操作历史</p>
         </div>
         <div v-if="detail && summary" class="detail-page-header__actions">
           <el-button v-if="mode === 'confirmed'" :disabled="loading" @click="printLoadingList"><Printer :size="16" />打印装柜清单</el-button>
@@ -256,7 +255,6 @@ function formatNumber(value?: number | null, digits = 3) {
 .detail-page-header__back { margin-right: 2px; }
 .detail-page-header__identity { min-width: 0; }
 .detail-page-header__identity h1 { margin: 0; color: var(--cc-text); font-size: 18px; line-height: 1.35; }
-.detail-page-header__identity p { margin: 3px 0 0; color: var(--cc-muted); font-size: var(--admin-font-caption, 12px); }
 .detail-page-header__actions { display: flex; align-items: center; justify-content: flex-end; gap: var(--admin-space-3, 8px); }
 .detail-page-header__actions :deep(.el-button + .el-button) { margin-left: 0; }
 .detail-summary { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: var(--admin-space-2, 6px) 28px; padding: var(--admin-space-4, 10px) 0 2px; border-top: 1px solid var(--cc-border); }

src/modules/overseas-master-data/AGENTS.md

@@ -17,7 +17,7 @@
 - 适用应用规则见 `../../../AGENTS.md`；原型与交互矩阵为本目录 `PROTOTYPE_MATRIX.md`，新增司机页面使用其中用户提供的新版原型入口。
 - 报价、汇率、车辆现有 API 在 `api/overseasMasterData.ts`；司机 API 在 `api/drivers.ts`，字段与标签在 `driverTypes.ts`，后端合同为 Lastleg `fleet-drivers-v1.yaml`。
 - 共享车次接口在 `api/trips.ts`，类型在 `tripTypes.ts`，后端合同为 `fleet-trips-v1.yaml`；覆盖计划/分配、客户排车关联、实际装载、货物结案和分别结束车辆/司机任务。接口保留稳定幂等键、版本与货物hash，长ID按字符串透传；数量和容量展示服务端结果，不在浏览器推算整车可发或可结案。新页面承载按 `PROTOTYPE_MATRIX.md` 确定，不因API存在推导页面能力。
-- 用户已于2026-10-02确认首版车次交互：`pages/TripsView.vue`、`pages/TripDetailView.vue` 为独立路由；`TripPlanDialog.vue` 1080px居中计划弹框，`TripAssignmentPanel.vue`、`TripLoadingPanel.vue` 在详情分区。列表一次分页请求，历史/装载/结案检查进入对应页签才读取；候选聚焦或搜索时调用车辆/司机目录，不逐行读取详情。先分配资源、关联排车及匹配卸货站，每张排车单调度审核通过后由PDA拣货、平台确认实测装载、整车理货审核通过后PDA整车发车；平台不提供替代PDA的发车按钮。审核使用独立trip:dispatch-review/trip:loading-review权限，详情展示通过/打回，通过意见选填、打回原因必填，不加审核清单；普通说明选填并提供标准审计说明，仍保留版本、幂等、容量和证照期限约束。
+- 当前日常作业统一从排车列表进入，侧栏`fleet-trips`为hidden；“出车记录”保留实际发车后的运营查询。原`pages/TripsView.vue`、`pages/TripDetailView.vue`及附加能力代码保留，不能作为新排车的前置步骤。旧详情仍按页签按需读取，资源候选聚焦或搜索时查询，不逐行读取。新整车审核、PDA真实拣货、双端装车确认及实际发车规则以`../../../../../docs/海外仓业务/排车列表统一作业改造契约.md`为准；详情只有已确认四页签，不把旧八项附加功能自动迁入或以派送完成自动释放资源。
 - 车辆实际托位/载重kg/容积m³分别由服务端返回，三项同填正数或全空待确认；不按车型名称推算。占用期间主档关键变更由服务端拒绝，下载中心 XLSX 导出使用车牌业务标识并包含容量字段。
 - 车辆运维在 `VehicleDetailView.vue` 的页签内，表格与编辑框为 `components/VehicleCareTable.vue`、`VehicleCareEditor.vue`；`api/vehicleCare.ts` 对接 `fleet-vehicle-records-v1.yaml`。保养/加油680px，维修/故障/救援/异常620px居中弹框，行操作按 `PROTOTYPE_MATRIX.md` 的逐类型入口执行。进入页签才分页查询，保养加油图片点击才鉴权读取并在新标签页预览；卸载释放Blob。车辆list包含记录只读，record-create/edit/upload独立；未知保存结果保留原请求键，照片重试不重复建记录。处理状态与付款状态独立，费用未填和零值区分；无财务关联时只显示服务端UNLINKED，不自动修改车辆公里码、状态或财务。
 - 维修/故障/救援的“更新处理”已获用户确认，复用原620px弹框及record-edit权限；更正说明选填，空值由页面填标准动作说明，不移除服务端不可变历史。

src/modules/overseas-master-data/PROTOTYPE_MATRIX.md

@@ -89,6 +89,21 @@
 
 以上仅为代码接入依据，真实界面验收仍待执行。
 
+## 2026-10-19 出车记录统计与列表优化
+
+依据：当前对话图1（现状）、图2（原型）；用户确认优先在前端优化。沿当前实际发车口径与接口，不恢复原型手填发车事实。
+
+| 页面 | 操作 | 原型承载/布局 | 当前实现 | 本轮结论 |
+|---|---|---|---|---|
+| 出车记录 | 统计与查询 | 图2上方独立四栏饼图，下方记录与筛选 | 图1统计位于列表筛选和表格之间，条形明细内部滚动 | 独立四栏饼图及彩色图例；用户追加确认只改饼图、保留现有日期/目的地统计分组；列表一套日期/关键词/货源/状态查询，同一响应更新统计与记录；币种切换独立展示，顶部均价明确为最近统计日值，不相加或简单平均每日均价；长图例与完整统计按需展开 |
+| 出车记录 | 列表、导出 | 图2列表独立卡片，操作第一列，导出在右上 | integrated列表、字段设置、XLSX下载任务 | 保留公共连续列表，整理默认列；完整字段仍可通过字段设置显示；导出沿原筛选及权限 |
+| 出车记录 | 详情、实测编辑、凭证预览 | 图2仅能确认列表编辑入口；当前操作以既有确认矩阵为准 | 详情独立路由；实测820px居中及按需凭证预览 | 不改变承载、读写权限或请求方式 |
+| 出车记录 | 新增、审核、删除 | 图2有新增记录，未定义审核/删除 | 当前列表无新增/审核/删除 | 不新增业务动作，实际发车事实仍由既有作业链产生 |
+
+用户追加截图确认统计区文字过多，并要求改善图表质感：使用项目已有 ECharts / vue-echarts 替换手写SVG，统一原生饼图、圆点图例和悬停数值；默认仅保留指标标题、主数值、四个饼图及短图例，日期图例使用月日，完整值在统计详情读取；默认不显示各图说明、重复系列标题、整行成本和额外明细入口。页头“统计详情”统一按需展开统计口径、服务端汇总、成本及完整图例明细，原有数据与权限保留。
+
+本轮只调整前端；自动检查与人工视觉验收分别记录，修改后1920×1080、100%截图待用户确认。
+
 ## 新版报价与出车记录接入
 
 | 入口 | 原型依据 | 当前承载 | 核对边界 |

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

@@ -26,7 +26,7 @@ const followupActions = computed(() => {
     { key: 'confirm', label: '核对并确认', visible: manage && (row.actions.canEdit || row.actions.canConfirm) },
     { key: 'incoming', label: '安排来货', visible: manage && row.progress.primaryAction === 'INCOMING' && access.can('platform:fleet:trip:booking-edit') },
     { key: 'receipt', label: '核对实收与运费', visible: manage && row.progress.primaryAction === 'RECEIPT' && access.can('platform:fleet:trip:booking-confirm') },
-    { key: 'bind', label: '确认排入本车', visible: manage && row.progress.primaryAction === 'BIND' && access.can('platform:fleet:trip:booking-edit') && access.can('platform:fleet:trip:edit') && access.can('platform:overseas-warehouse:inbound-order:smart-dispatch') },
+    { key: 'bind', label: '确认排入本车', visible: manage && row.progress.primaryAction === 'BIND' && access.can('platform:fleet:trip:booking-edit') && access.can('platform:fleet:trip:edit') && access.can('platform:overseas-warehouse:dispatch:create') },
     { key: 'fulfillment', label: '查看收货进度', visible: !!row.incomingNo },
     { key: 'dispatch', label: '查看排车详情', visible: !!row.dispatchNo && access.can('platform:overseas-warehouse:dispatch:list') },
     { key: 'trip', label: '前往车次审核', visible: !!row.dispatchNo && access.can('platform:fleet:trip:list') },

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

@@ -13,7 +13,7 @@ function actions(row: CapacityInquiry, busy: boolean): RowActionItem[] {
   const items: RowActionItem[] = [{ key: 'view', label: '查看进度', priority: 10 },
     { key: 'incoming', label: '安排来货', visible: manage && row.progress.primaryAction === 'INCOMING' && access.can('platform:fleet:trip:booking-edit'), disabled: busy },
     { key: 'receipt', label: '查看收货并核量', visible: manage && row.progress.primaryAction === 'RECEIPT' && access.can('platform:fleet:trip:booking-confirm'), disabled: busy },
-    { key: 'bind', label: '确认排入本车', visible: manage && row.progress.primaryAction === 'BIND' && access.can('platform:fleet:trip:booking-edit') && access.can('platform:fleet:trip:edit') && access.can('platform:overseas-warehouse:inbound-order:smart-dispatch'), disabled: busy },
+    { key: 'bind', label: '确认排入本车', visible: manage && row.progress.primaryAction === 'BIND' && access.can('platform:fleet:trip:booking-edit') && access.can('platform:fleet:trip:edit') && access.can('platform:overseas-warehouse:dispatch:create'), disabled: busy },
     { key: 'fulfillment', label: '收货进度', visible: !!row.incomingNo, disabled: busy },
     { key: 'edit', label: '补充资料', visible: row.actions.canEdit && write('edit'), disabled: busy },
     { key: 'confirm', label: '核对并确认', visible: (row.actions.canConfirm || row.actions.canEdit) && manage, disabled: busy },

src/modules/overseas-master-data/components/TripOperationsCharts.test.ts

@@ -0,0 +1,101 @@
+import { afterEach, expect, it, vi } from 'vitest'
+import { mount, type VueWrapper } from '@vue/test-utils'
+import type { EChartsOption, LegendComponentOption, PieSeriesOption } from 'echarts'
+import TripOperationsCharts from './TripOperationsCharts.vue'
+import type { TripOperationsCharts as Charts, TripOperationsSummary } from '../api/tripOperations'
+
+vi.mock('vue-echarts', () => ({ default: { name: 'VChart', props: ['option', 'initOptions', 'updateOptions', 'autoresize'], template: '<div class="echarts-pie-stub"/>' } }))
+const wrappers: VueWrapper[] = []
+const emptyCharts = (): Charts => ({ physicalPallets: [], destinationTrips: [], externalAgreedAmounts: [], externalPalletRates: [] })
+const summary = (): TripOperationsSummary => ({ trips: 20, inTransit: 5, completed: 15, physicalPallets: 90, palletSpaces: 100, ownPackages: 50, externalPackages: 20, externalAgreedAmounts: [{ currency: 'CNY', amount: 390 }, { currency: 'USD', amount: 100 }], costs: { visible: false, unrecordedTrips: null, unallocatedTrips: null, totals: [] } })
+function render(charts: Charts, totals = summary()) {
+  const wrapper = mount(TripOperationsCharts, { props: { charts, summary: totals }, global: { stubs: {
+    ElButton: { template: '<button><slot/></button>' },
+  } } })
+  wrappers.push(wrapper)
+  return wrapper
+}
+const option = (wrapper: VueWrapper, selector: string) => wrapper.find(selector).findComponent({ name: 'VChart' }).props('option') as EChartsOption
+const series = (options: EChartsOption) => (options.series as PieSeriesOption[])[0]!
+afterEach(() => wrappers.splice(0).forEach(wrapper => wrapper.unmount()))
+
+it('uses four ECharts pies with compact native legends, accurate server totals and daily rates', () => {
+  const charts = emptyCharts()
+  charts.physicalPallets = [{ label: '每日实运托盘', unit: '托', points: [{ label: '2026-10-02', value: 10 }] }]
+  charts.destinationTrips = [{ label: '目的地涉及车次', unit: '次', points: [{ label: 'ONT8', value: 3 }, { label: 'ABE2', value: 8 }] }]
+  charts.externalAgreedAmounts = [{ label: 'CNY', unit: 'CNY', points: [{ label: '2026-10-02', value: 390 }] }]
+  charts.externalPalletRates = [{ label: 'CNY', unit: 'CNY/标准托位', points: [{ label: '2026-10-07', value: 30 }, { label: '2026-10-02', value: 90 }] }]
+  const original = structuredClone(charts)
+  const wrapper = render(charts)
+  expect(wrapper.findAllComponents({ name: 'VChart' })).toHaveLength(4)
+  for (const chart of wrapper.findAllComponents({ name: 'VChart' })) {
+    expect(series(chart.props('option'))).toMatchObject({ type: 'pie', label: { show: false } })
+    expect(chart.props('initOptions')).toEqual({ renderer: 'canvas' })
+    expect(chart.props('updateOptions')).toEqual({ notMerge: true })
+  }
+  expect(wrapper.find('svg').exists()).toBe(false)
+  expect(wrapper.find('.series-caption').exists()).toBe(false)
+  expect(wrapper.find('.chart > .chart-note').exists()).toBe(false)
+  expect(wrapper.find('.chart--pallets .chart-metric').text()).toBe('90 托')
+  expect(wrapper.find('.chart--rates .chart-metric').text()).toContain('CNY/标准托位 30.00')
+  expect(wrapper.find('.chart--rates .chart-metric').attributes('title')).toContain('最近统计日：2026-10-07')
+  const legend = option(wrapper, '.chart--pallets').legend as LegendComponentOption
+  expect(legend.icon).toBe('circle')
+  expect(typeof legend.formatter === 'function' && legend.formatter('2026-10-02')).toBe('10-02')
+  expect(option(wrapper, '.chart--pallets').tooltip).toMatchObject({ trigger: 'item', confine: true, renderMode: 'richText' })
+  expect(series(option(wrapper, '.chart--rates')).data).toEqual([
+    { name: '2026-10-02', value: 90, itemStyle: { color: '#3b82f6' } },
+    { name: '2026-10-07', value: 30, itemStyle: { color: '#14b8a6' } },
+  ])
+  expect(charts).toEqual(original)
+})
+
+it('switches currency without combining monetary amounts or leaving stale ECharts slices', async () => {
+  const charts = emptyCharts()
+  charts.externalAgreedAmounts = [{ label: 'CNY', unit: 'CNY', points: [{ label: '2026-10-02', value: 390 }] }, { label: 'USD', unit: 'USD', points: [{ label: '2026-10-03', value: 100 }] }]
+  const wrapper = render(charts)
+  expect(wrapper.find('.chart--amounts .chart-metric').text()).toBe('CNY 390.00')
+  expect(wrapper.find('.chart--amounts').findAllComponents({ name: 'VChart' })).toHaveLength(1)
+  const usd = wrapper.findAll('.chart--amounts .series-selector button').find(button => button.text() === 'USD')!
+  await usd.trigger('click')
+  expect(usd.attributes('aria-pressed')).toBe('true')
+  expect(wrapper.find('.chart--amounts .chart-metric').text()).toBe('USD 100.00')
+  expect(series(option(wrapper, '.chart--amounts')).data).toEqual([{ name: '2026-10-03', value: 100, itemStyle: { color: '#3b82f6' } }])
+  await wrapper.setProps({ charts: { ...charts, externalAgreedAmounts: [charts.externalAgreedAmounts[0]!] } })
+  expect(wrapper.find('.chart--amounts .chart-metric').text()).toBe('CNY 390.00')
+})
+
+it('keeps every destination in its pie and exposes full legend data only on demand', async () => {
+  const charts = emptyCharts()
+  charts.destinationTrips = [{ label: '目的地涉及车次', unit: '次', points: Array.from({ length: 7 }, (_, index) => ({ label: `FBA-${index}`, value: index + 1 })) }]
+  const wrapper = render(charts)
+  expect(wrapper.find('.chart--destinations .chart-metric').text()).toBe('7 个目的地')
+  const options = option(wrapper, '.chart--destinations')
+  expect(series(options).data).toHaveLength(7)
+  expect((options.legend as LegendComponentOption).data).toHaveLength(5)
+  expect(wrapper.find('.chart-details').exists()).toBe(false)
+  await wrapper.find('.chart-more').trigger('click')
+  expect(wrapper.emitted('show-details')).toHaveLength(1)
+  await wrapper.setProps({ detailsVisible: true })
+  expect(wrapper.find('[aria-label="派送目的地明细"]').findAll('tbody tr')).toHaveLength(7)
+  expect(wrapper.find('[aria-label="派送目的地明细"]').text()).toContain('FBA-0')
+})
+
+it('preserves known zeros and does not draw equal positive shares for an empty sum', () => {
+  const charts = emptyCharts()
+  charts.physicalPallets = [{ label: '托盘', unit: '托', points: [{ label: '2026-10-01', value: 0 }, { label: '2026-10-02', value: 2 }] }]
+  charts.externalPalletRates = [{ label: 'USD', unit: 'USD/标准托位', points: [{ label: '2026-10-01', value: 0 }] }]
+  const wrapper = render(charts)
+  expect(series(option(wrapper, '.chart--rates'))).toMatchObject({ stillShowZeroSum: false, showEmptyCircle: true, data: [{ name: '2026-10-01', value: 0 }] })
+  expect(option(wrapper, '.chart--rates').graphic).toMatchObject([{ style: { text: '暂无正值数据' } }])
+  expect(wrapper.find('.chart--rates .chart-metric').text()).toContain('0.00')
+  expect(series(option(wrapper, '.chart--pallets')).data).toHaveLength(2)
+})
+
+it('shows missing amounts and rates as unknown and omits empty chart widgets', () => {
+  const wrapper = render(emptyCharts(), { ...summary(), physicalPallets: 0, externalAgreedAmounts: [] })
+  expect(wrapper.findAll('.chart-empty')).toHaveLength(4)
+  expect(wrapper.find('.chart--amounts .chart-metric').text()).toBe('—')
+  expect(wrapper.find('.chart--rates .chart-metric').text()).toBe('—')
+  expect(wrapper.findComponent({ name: 'VChart' }).exists()).toBe(false)
+})

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

@@ -1,28 +1,140 @@
 <script setup lang="ts">
-import { computed } from 'vue'
-import type { TripOperationsCharts, TripOperationsSeries } from '../api/tripOperations'
-const props = defineProps<{ charts: TripOperationsCharts }>()
+import { computed, ref } from 'vue'
+import VChart from 'vue-echarts'
+import { use } from 'echarts/core'
+import type { EChartsOption } from 'echarts'
+import { PieChart } from 'echarts/charts'
+import { AriaComponent, GraphicComponent, LegendComponent, TooltipComponent } from 'echarts/components'
+import { CanvasRenderer } from 'echarts/renderers'
+import type { TripOperationsCharts, TripOperationsSeries, TripOperationsSummary } from '../api/tripOperations'
+
+use([PieChart, LegendComponent, TooltipComponent, GraphicComponent, AriaComponent, CanvasRenderer])
+const props = withDefaults(defineProps<{ charts: TripOperationsCharts; summary: TripOperationsSummary; detailsVisible?: boolean }>(), { detailsVisible: false })
+const emit = defineEmits<{ 'show-details': [] }>()
+const selectedSeries = ref<Record<string, string>>({})
+const palette = ['#3b82f6', '#14b8a6', '#f59e0b', '#8b5cf6', '#f46565', '#06b6d4', '#ec4899', '#84cc16', '#6366f1', '#f97316']
 const sections = computed(() => [
-  { title: '实运托盘', note: '按实际发车日（UTC）汇总，物理托盘去重', series: props.charts.physicalPallets },
-  { title: '派送目的地', note: '各目的地涉及的车次，同车多站可分别出现', series: props.charts.destinationTrips },
-  { title: '外接约定金额', note: '按币种分别展示，不代表财务应收或实收', series: props.charts.externalAgreedAmounts },
-  { title: '外接按托报价均价', note: '按确认计价托位加权，排除整单报价', series: props.charts.externalPalletRates },
-])
-function width(value: number, series: TripOperationsSeries) { const max = Math.max(...series.points.map(p => p.value), 0); return max ? value / max * 100 : 0 }
+  { key: 'pallets', title: '实运托盘', note: '按实际发车日（UTC）分布，物理托盘去重', series: props.charts.physicalPallets, money: false },
+  { key: 'destinations', title: '派送目的地', note: '按目的地涉及车次分布，同车多站可分别计入', series: props.charts.destinationTrips, money: false },
+  { key: 'amounts', title: '外接约定金额', note: '按日期分布，各币种独立展示，不代表应收或实收', series: props.charts.externalAgreedAmounts, money: true },
+  { key: 'rates', title: '外接按托报价均价', note: '按日均价数值对比，顶部为最近统计日均价', series: props.charts.externalPalletRates, money: true },
+].map(section => {
+  const series = section.series.filter(series => series.points.length).map(series => ({
+    ...series,
+    points: [...series.points].sort((a, b) => section.key === 'destinations' ? b.value - a.value || a.label.localeCompare(b.label) : a.label.localeCompare(b.label)),
+  }))
+  return { ...section, series, active: series.find(series => series.label === selectedSeries.value[section.key]) ?? series[0] ?? null }
+}))
+const destinationCount = computed(() => new Set(props.charts.destinationTrips.flatMap(series => series.points.map(point => point.label))).size)
+const hasPoints = computed(() => sections.value.some(section => section.series.length))
+const number = (value: number, money = false) => value.toLocaleString('zh-CN', { minimumFractionDigits: money ? 2 : 0, maximumFractionDigits: 2 })
+const color = (index: number) => palette[index % palette.length]!
+const seriesTitle = (series: TripOperationsSeries) => series.label === series.unit ? series.label : `${series.label}（${series.unit}）`
+const amount = (currency: string) => props.summary.externalAgreedAmounts.find(amount => amount.currency === currency)
+const legendLabel = (label: string) => /^\d{4}-\d{2}-\d{2}$/.test(label) ? label.slice(5) : label
+
+function pieOption(series: TripOperationsSeries, money: boolean): EChartsOption {
+  const hasPositive = series.points.some(point => point.value > 0)
+  return {
+    animation: false,
+    aria: { enabled: true, description: `${seriesTitle(series)}，完整日期、图例和数值可在统计详情读取` },
+    tooltip: {
+      trigger: 'item', confine: true, renderMode: 'richText',
+      formatter: params => {
+        if (Array.isArray(params)) return ''
+        return `${params.name}\n${typeof params.value === 'number' ? number(params.value, money) : '—'} ${series.unit}`
+      },
+    },
+    legend: {
+      type: 'plain', left: 'center', bottom: 4, width: series.points.length > 5 ? '82%' : '96%',
+      icon: 'circle', itemWidth: 9, itemHeight: 9, itemGap: 10, selectedMode: false,
+      textStyle: { color: '#8492a6', fontSize: 12 },
+      data: series.points.slice(0, 5).map(point => point.label), formatter: legendLabel,
+      tooltip: { show: true, confine: true },
+    },
+    series: [{
+      name: seriesTitle(series), type: 'pie', radius: 64, center: ['50%', 72],
+      label: { show: false }, labelLine: { show: false },
+      itemStyle: { borderColor: '#fff', borderWidth: 2 },
+      emphasis: { scale: false, focus: 'self' },
+      stillShowZeroSum: false, showEmptyCircle: true,
+      emptyCircleStyle: { color: '#f3f4f6', borderWidth: 0 },
+      data: series.points.map((point, index) => ({ name: point.label, value: point.value, itemStyle: { color: color(index) } })),
+    }],
+    graphic: hasPositive ? [] : [{ type: 'text', left: 'center', top: 66, style: { text: '暂无正值数据', fill: '#8492a6', fontSize: 12 } }],
+  }
+}
 </script>
-<template><section class="operations-charts" aria-label="出车数据统计"><article v-for="section in sections" :key="section.title" class="chart">
-  <strong>{{ section.title }}</strong><p>{{ section.note }}</p>
-  <p v-if="!section.series.some(s => s.points.length)">暂无对应统计</p>
-  <div class="chart-values"><template v-for="(series, si) in section.series" :key="`${series.label}-${si}`"><div v-if="series.points.length"><b>{{ series.label }}（{{ series.unit }}）</b>
-    <div v-for="(point, pi) in series.points" :key="pi" class="point"><span>{{ point.label }}</span><div class="bar-track" aria-hidden="true"><div class="bar" :style="{ width: width(point.value, series) + '%' }" /></div><span>{{ point.value }}</span></div>
-  </div></template></div>
-</article></section></template>
+
+<template>
+  <div class="operations-visualizations">
+    <section class="operations-charts" aria-label="出车统计饼图">
+      <article v-for="section in sections" :key="section.key" class="chart" :class="`chart--${section.key}`" :aria-label="section.title">
+        <h3 :title="section.note">{{ section.title }}</h3>
+        <div class="chart-metric" :title="section.key === 'rates' && section.active ? `最近统计日：${section.active.points[section.active.points.length - 1]!.label}；${section.note}` : section.note">
+          <strong v-if="section.key === 'pallets'">{{ number(summary.physicalPallets) }} <small>托</small></strong>
+          <strong v-else-if="section.key === 'destinations'">{{ number(destinationCount) }} <small>个目的地</small></strong>
+          <template v-else-if="section.key === 'amounts'">
+            <strong v-if="section.active && amount(section.active.label)"><small>{{ section.active.label }}</small> {{ number(amount(section.active.label)!.amount, true) }}</strong>
+            <strong v-else>—</strong>
+          </template>
+          <template v-else>
+            <strong v-if="section.active"><small>{{ section.active.unit }}</small> {{ number(section.active.points[section.active.points.length - 1]!.value, true) }}</strong>
+            <strong v-else>—</strong>
+          </template>
+        </div>
+        <div v-if="section.series.length > 1" class="series-selector" role="group" :aria-label="`${section.title}币种或系列`">
+          <el-button v-for="series in section.series" :key="series.label" size="small" :type="section.active?.label === series.label ? 'primary' : 'default'" :aria-pressed="section.active?.label === series.label" @click="selectedSeries[section.key] = series.label">{{ series.label }}</el-button>
+        </div>
+        <template v-if="section.active">
+          <div class="chart-visualization">
+            <VChart class="pie-chart" :option="pieOption(section.active, section.money)" :init-options="{ renderer: 'canvas' }" :update-options="{ notMerge: true }" autoresize :aria-label="`${section.title}，完整图例和数值见统计详情`" />
+            <el-button v-if="section.active.points.length > 5" class="chart-more" link :aria-label="`查看其余 ${section.active.points.length - 5} 项图例及数值`" @click="emit('show-details')">+{{ section.active.points.length - 5 }}</el-button>
+          </div>
+        </template>
+        <p v-else class="chart-empty">暂无对应统计</p>
+      </article>
+    </section>
+    <section v-if="detailsVisible && hasPoints" class="chart-details" aria-label="完整统计明细">
+      <div class="chart-details-grid">
+        <section v-for="section in sections" :key="section.key" :aria-label="`${section.title}明细`">
+          <h3>{{ section.title }}</h3>
+          <p class="chart-note">{{ section.note }}</p>
+          <p v-if="section.key === 'rates'" class="chart-note">各日均价按确认计价托位加权，排除整单报价；不将每日均价相加或简单平均为期间均价。</p>
+          <p v-if="!section.series.length" class="chart-note">暂无对应统计</p>
+          <table v-for="(series, seriesIndex) in section.series" :key="`${series.label}-${seriesIndex}`" class="density-table">
+            <caption>{{ seriesTitle(series) }}</caption>
+            <thead><tr><th scope="col">{{ section.key === 'destinations' ? '目的地' : '日期（UTC）' }}</th><th scope="col">数值</th></tr></thead>
+            <tbody><tr v-for="(point, pointIndex) in series.points" :key="point.label"><td><span class="legend-dot" :style="{ background: color(pointIndex) }" aria-hidden="true" /> {{ point.label }}</td><td>{{ number(point.value, section.money) }}</td></tr></tbody>
+          </table>
+        </section>
+      </div>
+    </section>
+  </div>
+</template>
+
 <style scoped>
-.operations-charts { display:grid; grid-template-columns:repeat(4,minmax(0,1fr)); gap:var(--admin-space-3); }
-.chart { display:grid; align-content:start; gap:var(--admin-space-2); min-width:0; padding:var(--admin-space-3); border:1px solid var(--cc-border); border-radius:var(--admin-radius); background:var(--admin-surface); }
-.chart > strong { font-size:var(--admin-font-section); }
-.chart p { margin:0; line-height:1.6; color:var(--cc-muted); font-size:var(--admin-font-caption); }
-.chart-values { max-height:220px; overflow:auto; }
-.point { display:grid; grid-template-columns:minmax(95px,1fr) minmax(45px,1fr) minmax(40px,auto); gap:var(--admin-space-2); align-items:center; margin:var(--admin-space-2) 0; }
-.bar-track { height:10px; background:var(--el-fill-color-light); }.bar { height:100%; background:var(--el-color-primary); }
+.operations-visualizations { display: grid; gap: var(--admin-space-3); min-width: 0; }
+.operations-charts, .chart-details-grid { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: var(--admin-space-6); }
+.chart { min-width: 0; padding-right: var(--admin-space-6); border-right: 1px solid var(--cc-border); color: var(--cc-text); text-align: center; }
+.chart:last-child { padding-right: 0; border-right: 0; }
+.chart h3, .chart-details h3 { margin: 0 0 var(--admin-space-2); font-size: var(--admin-font-section); }
+.chart-metric { display: flex; flex-wrap: wrap; align-items: baseline; justify-content: center; gap: var(--admin-space-1) var(--admin-space-5); margin-bottom: var(--admin-space-1); font-variant-numeric: tabular-nums; }
+.chart-metric > strong { font-size: calc(var(--admin-font-title) * 1.25); overflow-wrap: anywhere; }
+.chart-metric small { font-size: var(--admin-font-caption); font-weight: normal; color: var(--cc-muted); }
+.chart-note, .chart-empty { margin: 0; font-size: var(--admin-font-caption); color: var(--cc-muted); line-height: 1.6; }
+.chart-empty { display: grid; min-height: 136px; place-content: center; }
+.series-selector { display: flex; justify-content: center; flex-wrap: wrap; gap: var(--admin-space-2); margin-top: var(--admin-space-2); }
+.series-selector :deep(.el-button + .el-button) { margin-left: 0; }
+.chart-visualization { position: relative; min-width: 0; }
+.pie-chart { display: block; width: 100%; height: 190px; margin: var(--admin-space-2) auto 0; }
+.chart-more { position: absolute; right: 0; bottom: var(--admin-space-1); height: auto; padding: 0; font-size: var(--admin-font-caption); }
+.legend-dot { display: inline-block; width: 9px; height: 9px; border-radius: 50%; flex: 0 0 9px; }
+.chart-details-grid { margin-top: var(--admin-space-5); }
+.chart-details-grid > section { min-width: 0; }
+.chart-details table { width: 100%; table-layout: fixed; }
+.chart-details caption { text-align: left; padding: var(--admin-space-2) 0; color: var(--cc-muted); font-size: var(--admin-font-caption); }
+.chart-details td { overflow-wrap: anywhere; }
+@media (max-width: 1100px) { .operations-charts, .chart-details-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); } .chart:nth-child(2n) { padding-right: 0; border-right: 0; } }
+@media (max-width: 720px) { .operations-charts, .chart-details-grid { grid-template-columns: minmax(0, 1fr); } .chart { padding-right: 0; padding-bottom: var(--admin-space-5); border-right: 0; border-bottom: 1px solid var(--cc-border); } .chart:last-child { padding-bottom: 0; border-bottom: 0; } }
 </style>

src/modules/overseas-master-data/index.ts

@@ -10,3 +10,6 @@ export { default as TripDispatchSelector } from './components/TripDispatchSelect
 export { listTripDispatchCandidates, prepareTrip, type TripPreparation, type DispatchCandidate } from './api/trips'
 
 export type { TripPreviousDispatch } from './tripTypes'
+export { listVehicles } from './api/overseasMasterData'
+export { listDrivers } from './api/drivers'
+export type { DriverDetail } from './driverTypes'

src/modules/overseas-master-data/pages/CapacityOfferDetailView.vue

@@ -89,7 +89,7 @@ watch([page, size], loadInquiries)
 onBeforeUnmount(() => { followupSequence++; sequence++; inquirySequence++ })
 </script>
 <template><AdminPage class="admin-density"><DetailPageLayout class="density-detail-layout surface-panel" aria-label="运力发布详情">
-  <template #header><div class="density-detail-header"><div class="density-detail-heading"><el-button link class="density-back" @click="router.push({ name: 'overseas-master-data-capacity-offers' })">返回拼车接货</el-button><h1 class="density-detail-title">{{ detail?.offer.offerNo || '运力发布详情' }}</h1><span v-if="detail">{{ offerStatusLabels[detail.offer.status] }}</span></div><div class="density-actions"><el-button :loading="loading" @click="load">重新核对</el-button><el-button v-if="hasCreatePermission" type="primary" :disabled="loading || !canCreate" @click="create">登记客户货物</el-button></div></div></template>
+  <template #header><div class="density-detail-header"><div class="density-detail-heading"><el-button link class="density-back" @click="router.push({ name: 'overseas-master-data-capacity-offers' })">返回散板需求</el-button><h1 class="density-detail-title">{{ detail?.offer.offerNo || '运力发布详情' }}</h1><span v-if="detail">{{ offerStatusLabels[detail.offer.status] }}</span></div><div class="density-actions"><el-button :loading="loading" @click="load">重新核对</el-button><el-button v-if="hasCreatePermission" type="primary" :disabled="loading || !canCreate" @click="create">登记客户货物</el-button></div></div></template>
   <LoadErrorState v-if="error" title="发布详情读取失败" :message="error.message" @retry="load"><template #details><ApiErrorMeta :details="error" /></template></LoadErrorState>
   <div v-loading="loading" :aria-busy="loading"><template v-if="detail">
     <dl class="density-fields"><div><dt>车次号</dt><dd><el-button v-if="access.can('platform:fleet:trip:list')" link type="primary" @click="router.push({ name: 'overseas-master-data-trip-detail', params: { tripNo: detail.offer.tripNo } })">{{ detail.offer.tripNo }}</el-button><span v-else>{{ detail.offer.tripNo }}</span></dd></div><div><dt>起运仓</dt><dd>{{ detail.offer.warehouseName }}</dd></div><div><dt>计划发车</dt><dd>{{ offerTime(detail.offer.plannedDepartureAt) }}</dd></div><div><dt>最晚送仓</dt><dd>{{ offerTime(detail.offer.cutoffAt) }}</dd></div><div><dt>调度联系人</dt><dd>{{ detail.offer.contactName || '—' }}</dd></div><div><dt>调度联系方式</dt><dd>{{ detail.offer.contactPhone || '—' }}</dd></div></dl>

src/modules/overseas-master-data/pages/CapacityOffersBehavior.test.ts

@@ -246,6 +246,31 @@ it('highlights only the allowed current step and keeps other actions secondary',
   expect(section.findAll('button').filter(item => !item.element.closest('details')).map(item => item.text())).toEqual(['安排来货'])
 })
 
+it.each([
+  ['all current permissions', ['platform:fleet:capacity-offer:manage', 'platform:fleet:trip:booking-edit', 'platform:fleet:trip:edit', 'platform:overseas-warehouse:dispatch:create'], true],
+  ['legacy smart permission', ['platform:fleet:capacity-offer:manage', 'platform:fleet:trip:booking-edit', 'platform:fleet:trip:edit', 'platform:overseas-warehouse:inbound-order:smart-dispatch'], false],
+  ['missing offer manage', ['platform:fleet:trip:booking-edit', 'platform:fleet:trip:edit', 'platform:overseas-warehouse:dispatch:create'], false],
+  ['missing booking edit', ['platform:fleet:capacity-offer:manage', 'platform:fleet:trip:edit', 'platform:overseas-warehouse:dispatch:create'], false],
+  ['missing trip edit', ['platform:fleet:capacity-offer:manage', 'platform:fleet:trip:booking-edit', 'platform:overseas-warehouse:dispatch:create'], false],
+  ['missing dispatch create', ['platform:fleet:capacity-offer:manage', 'platform:fleet:trip:booking-edit', 'platform:fleet:trip:edit'], false],
+])('keeps table and dialog arrange-dispatch authority aligned: %s', async (_, codes, allowed) => {
+  state.links = new Set(codes)
+  state.manage = codes.includes('platform:fleet:capacity-offer:manage')
+  const row: CapacityInquiry = { ...inquiry, progress: { ...inquiry.progress, primaryAction: 'BIND' } }
+  const table = shallowMount(CapacityInquiryTable, { props: { rows: [row], total: 1, loading: false }, global: { stubs: {
+    DataTable: { props: ['data'], template: '<div><slot name="actions" :row="data[0]" /></div>' },
+    RowActions: { name: 'RowActions', props: ['actions'], template: '<div />' },
+  } } })
+  wrappers.push(table)
+  const actions = table.getComponent({ name: 'RowActions' }).props('actions') as { key: string; visible?: boolean }[]
+  expect(actions.find(action => action.key === 'bind')?.visible).toBe(allowed)
+  const { wrapper: dialog } = mount(CapacityInquiryDialog, { modelValue: true, offer, inquiry: row, readonly: true })
+  await flushPromises()
+  const bind = dialog.findAll('button').find(button => button.text() === '确认排入本车')
+  expect(Boolean(bind)).toBe(allowed)
+  if (bind) { await bind.trigger('click'); expect(dialog.emitted('action')?.at(-1)).toEqual(['bind', row]) }
+})
+
 it('shows the selected destination capacity when confirming and never treats unknown capacity as zero', async () => {
   state.manage = true
   const knownOffer = { ...offer, capacityKnown: true, destinations: [

src/modules/overseas-master-data/pages/CapacityOffersView.vue

@@ -85,7 +85,7 @@ async function load() {
       const query: InquiryQuery = { page: page.value, size: size.value, keyword: String(q.keyword || '') || undefined, status: String(q.status || '') || undefined, scope: manage.value && q.scope === 'TODO' ? 'TODO' : manage.value && q.scope === 'ALL' ? 'ALL' : 'MINE' }
       const value = await listCapacityInquiries(query); if (current === sequence) { inquiries.value = value.records; total.value = value.total }
     }
-  } catch (cause) { if (current === sequence) error.value = getApiErrorDetails(cause, '拼车接货读取失败') }
+  } catch (cause) { if (current === sequence) error.value = getApiErrorDetails(cause, '散板需求读取失败') }
   finally { if (current === sequence) loading.value = false }
 }
 function search() { applied.value = { ...filters.value }; if (page.value !== 1) page.value = 1; else void load() }
@@ -120,12 +120,12 @@ async function recheckEditor() {
 }
 watch([tab, page, size], load); onMounted(load); onBeforeUnmount(() => { followupSequence++; sequence++; editorSequence++ })
 </script>
-<template><AdminPage class="admin-density"><ListPageLayout aria-label="拼车接货">
+<template><AdminPage class="admin-density"><ListPageLayout aria-label="散板需求">
   <DataTable v-if="tab === 'offers'" appearance="integrated" :stripe="false" preference-key="fleet-capacity-offers" column-settings-mode="show" :results-visible="!error" v-model:page="page" v-model:page-size="size" :data="offers" :columns="columns" :loading="loading" :total="total" row-key="offerNo" :empty-text="Object.values(applied).some(Boolean) ? '当前筛选条件下暂无运力发布' : '暂无获准查看的运力发布'">
-    <template #toolbar-start><h1>拼车接货</h1></template><template #toolbar-end><el-button v-if="manage" @click="switchTab('inquiries'); filters = { scope: 'TODO' }; applied = { scope: 'TODO' }">待我处理</el-button><el-button v-if="manage && access.can('platform:fleet:trip:list')" @click="router.push({ name: 'overseas-master-data-trips' })">选择车次发布余位</el-button></template>
+    <template #toolbar-start><h1>散板需求</h1></template><template #toolbar-end><el-button v-if="manage" @click="switchTab('inquiries'); filters = { scope: 'TODO' }; applied = { scope: 'TODO' }">待我处理</el-button><el-button v-if="manage && access.can('platform:fleet:trip:list')" @click="router.push({ name: 'overseas-master-data-trips' })">选择车次发布余位</el-button></template>
     <template #filters>
       <div class="integrated-query-group">
-        <div class="density-status-tabs" role="tablist" aria-label="拼车接货页签"><button role="tab" aria-selected="true" class="is-active" @click="switchTab('offers')">可拼车次</button><button role="tab" aria-selected="false" @click="switchTab('inquiries')">我的登记</button></div>
+        <div class="density-status-tabs" role="tablist" aria-label="散板需求页签"><button role="tab" aria-selected="true" class="is-active" @click="switchTab('offers')">可拼车次</button><button role="tab" aria-selected="false" @click="switchTab('inquiries')">我的登记</button></div>
         <QueryToolbar v-model="filters" :fields="fields" ariaLabel="可拼车次查询" :loading="loading" @search="search" />
       </div>
     </template>
@@ -142,7 +142,7 @@ watch([tab, page, size], load); onMounted(load); onBeforeUnmount(() => { followu
     <template #toolbar-start><h1>{{ applied.scope === 'TODO' ? '待我处理' : applied.scope === 'ALL' ? '全部登记' : '我的登记' }}</h1></template>
     <template #filters>
       <div class="integrated-query-group">
-        <div class="density-status-tabs" role="tablist" aria-label="拼车接货页签"><button role="tab" aria-selected="false" @click="switchTab('offers')">可拼车次</button><button role="tab" aria-selected="true" class="is-active" @click="switchTab('inquiries')">我的登记</button></div>
+        <div class="density-status-tabs" role="tablist" aria-label="散板需求页签"><button role="tab" aria-selected="false" @click="switchTab('offers')">可拼车次</button><button role="tab" aria-selected="true" class="is-active" @click="switchTab('inquiries')">我的登记</button></div>
         <QueryToolbar v-model="filters" :fields="fields" ariaLabel="拼车意向查询" :loading="loading" @search="search" />
       </div>
     </template>

src/modules/overseas-master-data/pages/FleetReportingViews.test.ts

@@ -2,6 +2,8 @@ import { afterEach, expect, it, vi } from 'vitest'
 import { shallowMount, flushPromises, type VueWrapper } from '@vue/test-utils'
 import FleetQuotesView from './FleetQuotesView.vue'
 import TripOperationsView from './TripOperationsView.vue'
+import QueryToolbar from '@/shared/components/QueryToolbar.vue'
+import TripOperationsCharts from '../components/TripOperationsCharts.vue'
 import * as quotes from '../api/fleetQuotes'
 import * as reports from '../api/tripOperations'
 vi.mock('@/core/access/accessPreview', () => ({ useAccessPreviewStore: () => ({ can: (p: string) => p.endsWith(':list') }) }))
@@ -9,10 +11,10 @@ vi.mock('vue-router', () => ({ useRouter: () => ({ push: vi.fn() }) }))
 vi.mock('../api/fleetQuotes', () => ({ listFleetQuotes: vi.fn(), setFleetQuoteStatus: vi.fn(), deleteFleetQuote: vi.fn(), exportFleetQuotes: vi.fn(), saveFleetCsv: vi.fn() }))
 vi.mock('../api/tripOperations', () => ({ listTripOperations: vi.fn(), exportTripOperations: vi.fn() }))
 const wrappers: VueWrapper[] = []
-const layout = { template: '<div><slot/></div>' }
+const layout = { template: '<div><slot name="metrics"/><slot name="state"/><slot/></div>' }
 function mount(component: object) { const wrapper = shallowMount(component, { global: { stubs: { AdminPage: layout, ListPageLayout: layout, QueryToolbar: true,
   DataTable: { name: 'DataTable', props: ['data', 'columns'], template: '<div><slot name="toolbar-start"/><slot name="toolbar-actions"/><slot name="filters"/><slot name="notices"/></div>' }, ElButton: { template: '<button><slot/></button>' },
-  LoadErrorState: true, FleetQuoteEditor: true, FleetQuoteImport: true, ApiErrorMeta: true } } }); wrappers.push(wrapper); return wrapper }
+  ElTooltip: true, LoadErrorState: true, FleetQuoteEditor: true, FleetQuoteImport: true, ApiErrorMeta: true } } }); wrappers.push(wrapper); return wrapper }
 afterEach(() => { wrappers.splice(0).forEach(w => w.unmount()); vi.clearAllMocks() })
 it('quotes read-only view fetches a page once and hides all write/export tools', async () => {
   vi.mocked(quotes.listFleetQuotes).mockResolvedValue({ records: [], total: 0, page: 1, size: 20, pages: 0 })
@@ -23,5 +25,42 @@ it('quotes read-only view fetches a page once and hides all write/export tools',
 it('operations uses server totals rather than displayed page size', async () => {
   vi.mocked(reports.listTripOperations).mockResolvedValue({ page: { records: [], total: 21, page: 1, size: 20, pages: 2 }, summary: { trips: 21, inTransit: 12, completed: 9, physicalPallets: 40, palletSpaces: 40, ownPackages: 70, externalPackages: 10, externalAgreedAmounts: [], costs: { visible: false, unrecordedTrips: null, unallocatedTrips: null, totals: [] } }, charts: { physicalPallets: [], destinationTrips: [], externalAgreedAmounts: [], externalPalletRates: [] } })
   const wrapper = mount(TripOperationsView); await flushPromises()
-  expect(reports.listTripOperations).toHaveBeenCalledTimes(1); expect(wrapper.text()).toContain('实际出车 21 次'); expect(wrapper.text()).not.toContain('导出CSV')
+  expect(reports.listTripOperations).toHaveBeenCalledTimes(1); expect(wrapper.text()).not.toContain('导出CSV')
+  expect(wrapper.find('#operations-statistics-details').exists()).toBe(false)
+  expect(wrapper.findComponent(TripOperationsCharts).props('detailsVisible')).toBe(false)
+  await wrapper.find('[aria-controls="operations-statistics-details"]').trigger('click')
+  expect(wrapper.text()).toContain('实际出车 21 次')
+  expect(wrapper.findComponent(TripOperationsCharts).props('detailsVisible')).toBe(true)
+  expect(reports.listTripOperations).toHaveBeenCalledTimes(1)
+  await wrapper.find('[aria-controls="operations-statistics-details"]').trigger('click')
+  expect(wrapper.find('#operations-statistics-details').exists()).toBe(false)
+  wrapper.findComponent(TripOperationsCharts).vm.$emit('show-details'); await flushPromises()
+  expect(wrapper.find('#operations-statistics-details').exists()).toBe(true)
+  expect(reports.listTripOperations).toHaveBeenCalledTimes(1)
+  expect(wrapper.findComponent(TripOperationsCharts).props('summary').physicalPallets).toBe(40)
+  expect(wrapper.find('.operations-overview').element.compareDocumentPosition(wrapper.findComponent({ name: 'DataTable' }).element) & Node.DOCUMENT_POSITION_FOLLOWING).toBeTruthy()
+  expect(wrapper.findComponent({ name: 'DataTable' }).props('columns').find((column: { key: string }) => column.key === 'finance')).toMatchObject({ defaultVisible: false })
+})
+it('operations queries charts and records together and resets with only one request', async () => {
+  vi.mocked(reports.listTripOperations).mockResolvedValue({ page: { records: [], total: 0, page: 1, size: 20, pages: 0 }, summary: { trips: 0, inTransit: 0, completed: 0, physicalPallets: 0, palletSpaces: 0, ownPackages: 0, externalPackages: 0, externalAgreedAmounts: [], costs: { visible: false, unrecordedTrips: null, unallocatedTrips: null, totals: [] } }, charts: { physicalPallets: [], destinationTrips: [], externalAgreedAmounts: [], externalPalletRates: [] } })
+  const wrapper = mount(TripOperationsView); await flushPromises()
+  const initial = vi.mocked(reports.listTripOperations).mock.calls[0]![0]
+  const toolbar = wrapper.findComponent(QueryToolbar)
+  toolbar.vm.$emit('update:modelValue', { from: '2026-10-01', to: '2026-10-07', keyword: 'TRIP', sourceType: 'EXTERNAL', status: 'IN_TRANSIT' })
+  toolbar.vm.$emit('search'); await flushPromises()
+  expect(reports.listTripOperations).toHaveBeenLastCalledWith(expect.objectContaining({ from: '2026-10-01T00:00:00Z', to: '2026-10-08T00:00:00.000Z', keyword: 'TRIP', sourceType: 'EXTERNAL', status: 'IN_TRANSIT' }))
+  expect(wrapper.text()).toContain('2026-10-01 至 2026-10-07（UTC）')
+  toolbar.vm.$emit('update:modelValue', { from: '2026-09-01', to: '2026-09-07' }); await flushPromises()
+  expect(wrapper.text()).toContain('2026-10-01 至 2026-10-07（UTC）')
+  toolbar.vm.$emit('reset'); toolbar.vm.$emit('search'); await flushPromises()
+  expect(reports.listTripOperations).toHaveBeenCalledTimes(3)
+  expect(reports.listTripOperations).toHaveBeenLastCalledWith(initial)
+  expect(toolbar.props('modelValue')).toMatchObject({ keyword: '', sourceType: '', status: '' })
+})
+it('operations shows query failures without leaving stale statistics', async () => {
+  vi.mocked(reports.listTripOperations).mockRejectedValue(new Error('统计暂不可用'))
+  const wrapper = mount(TripOperationsView); await flushPromises()
+  expect(wrapper.findComponent(TripOperationsCharts).exists()).toBe(false)
+  expect(wrapper.findComponent({ name: 'LoadErrorState' }).attributes('message')).toBe('运营记录加载失败')
+  expect(wrapper.text()).not.toContain('实际出车 0 次')
 })

src/modules/overseas-master-data/pages/TripDetailView.vue

@@ -1,4 +1,5 @@
 <script setup lang="ts">
+import InlineHelp from '@/shared/components/InlineHelp.vue'
 import '@/styles/adminDensity.css'
 import { appointmentReturnTarget, TripAppointmentPanel } from '@/modules/appointment-calendar'
 import { inquiryReturnTarget } from '../inquiryNavigation'
@@ -206,8 +207,7 @@ onBeforeUnmount(() => { generation++; inspectionSequence++; historySequence++ })
       <div v-if="activeTab === 'overview' || isPickup" v-show="activeTab === 'overview'">
         <FormSection v-if="planned && access.can(permission.tripAssign)" class="density-form-section" title="车辆与司机"><TripAssignmentPanel v-if="!pickupLocked" :key="detail.trip.tripNo" :detail="detail" @saved="accept" /></FormSection>
         <TripPickupPanel v-if="isPickup" :detail="detail" @saved="accept" @locked="pickupLocked = $event" />
-        <FormSection v-else class="density-form-section" title="本车排车单"><div v-if="editable" class="trip-inline"><TripDispatchSelector v-model="dispatchNo" :trip-no="detail.trip.tripNo" :disabled="!!busy" /><el-button type="primary" :loading="busy === 'bind'" :disabled="!!busy || !detail.trip.vehicleId" @click="bind">关联排车单</el-button><el-button :loading="busy === 'stops'" :disabled="!!busy || !detail.dispatches.length" @click="matchStops">按货物匹配卸货站</el-button></div>
-          <p>先分配车辆和司机，选择待运排车单后自动匹配卸货站。每单调度审核通过后拣货，确认实际装载并通过理货审核后整车发车。</p>
+        <FormSection v-else class="density-form-section" title="本车排车单"><div v-if="editable" class="trip-inline"><TripDispatchSelector v-model="dispatchNo" :trip-no="detail.trip.tripNo" :disabled="!!busy" /><el-button type="primary" :loading="busy === 'bind'" :disabled="!!busy || !detail.trip.vehicleId" @click="bind">关联排车单</el-button><el-button :loading="busy === 'stops'" :disabled="!!busy || !detail.dispatches.length" @click="matchStops">按货物匹配卸货站</el-button><InlineHelp title="操作说明"><p>先分配车辆和司机，选择待运排车单后自动匹配卸货站。每单调度审核通过后拣货，确认实际装载并通过理货审核后整车发车。</p></InlineHelp></div>
           <DataTable :data="detail.dispatches" :columns="bindingsColumns" row-key="dispatchNo" empty-text="尚未关联排车单"><template #actions="{ row }"><div class="density-actions"><el-button v-if="access.can('platform:overseas-warehouse:dispatch:list')" class="density-action" @click="router.push({ name: 'overseas-dispatch-detail', params: { dispatchNo: row.dispatchNo } })">详情</el-button><el-button v-if="editable" class="density-action" data-tone="danger" :disabled="!!busy" @click="unbind(row.dispatchNo)">解除关联</el-button><el-button v-if="planned && access.can(permission.tripDispatchReview)" class="density-action" :disabled="!!busy || row.review.status === 'APPROVED'" @click="review('APPROVED', row.dispatchNo)">审核通过</el-button><el-button v-if="planned && access.can(permission.tripDispatchReview)" class="density-action" data-tone="danger" :disabled="!!busy" @click="review('REJECTED', row.dispatchNo)">打回</el-button></div></template><template #review="{ row }"><span>{{ tripReviewLabels[row.review.status as keyof typeof tripReviewLabels] }}</span><p v-if="row.review.reason">{{ row.review.reason }}</p><span v-if="row.review.reviewedAt">{{ time(row.review.reviewedAt) }}</span></template><template #boundAt="{ row }">{{ time(row.boundAt) }}</template></DataTable>
         </FormSection>
       </div>

src/modules/overseas-master-data/pages/TripOperationsView.vue

@@ -19,49 +19,82 @@ const submitExport = useExportTask()
 const router = useRouter(), access = useAccessPreviewStore()
 const result = ref<TripOperationsResult | null>(null), page = ref(1), size = ref(20), loading = ref(false), exporting = ref(false), error = ref<ApiErrorDetails | null>(null)
 const recordOpen = ref(false), selected = ref<TripOperationsRow | null>(null)
+const statisticsOpen = ref(false)
 const today = new Date().toISOString().slice(0, 10), monthAgo = new Date(Date.now() - 30 * 86400000).toISOString().slice(0, 10)
-const filters = ref<QueryModel>({ from: monthAgo, to: today, keyword: '', sourceType: '', status: '' })
+const defaultFilters = () => ({ from: monthAgo, to: today, keyword: '', sourceType: '', status: '' })
+const filters = ref<QueryModel>(defaultFilters())
+const displayedRange = ref('')
 let applied: TripOperationsQuery = range(), sequence = 0
 const fields: QueryField[] = [
-  { key: 'from', label: '实际发车起日(UTC)', type: 'date', width: 185 }, { key: 'to', label: '实际发车止日(UTC)', type: 'date', width: 185 },
-  { key: 'keyword', label: '关键词', type: 'input', width: 235, placeholder: '车次 / 发车车牌 / 司机 / 目的仓' },
-  { key: 'sourceType', label: '货源', type: 'select', width: 145, options: [{ value: 'OWN', label: '含自有业务' }, { value: 'EXTERNAL', label: '含外接业务' }] },
-  { key: 'status', label: '状态', type: 'select', width: 130, options: [{ value: 'IN_TRANSIT', label: '在途' }, { value: 'COMPLETED', label: '货物已结案' }] },
+  { key: 'from', label: '实际发车起日(UTC)', placeholder: '发车起日（UTC）', type: 'date', width: 150, props: { 'aria-label': '实际发车起日（UTC）' } },
+  { key: 'to', label: '实际发车止日(UTC)', placeholder: '发车止日（UTC）', type: 'date', width: 150, props: { 'aria-label': '实际发车止日（UTC）' } },
+  { key: 'keyword', label: '关键词', type: 'input', width: 270, placeholder: '车次 / 车牌 / 司机 / 目的仓', props: { 'aria-label': '车次、车牌、司机或目的仓' } },
+  { key: 'sourceType', label: '货源', placeholder: '全部货源', type: 'select', width: 140, props: { 'aria-label': '货源' }, options: [{ value: 'OWN', label: '含自有业务' }, { value: 'EXTERNAL', label: '含外接业务' }] },
+  { key: 'status', label: '状态', placeholder: '全部状态', type: 'select', width: 140, props: { 'aria-label': '状态' }, options: [{ value: 'IN_TRANSIT', label: '在途' }, { value: 'COMPLETED', label: '货物已结案' }] },
 ]
-const columns: DataTableColumn[] = [{ key: 'actions', label: '操作', width: 185, fixed: 'left', slotName: 'actions' }, { key: 'tripNo', label: '车次号', minWidth: 220 },
+const columns: DataTableColumn[] = [{ key: 'actions', label: '操作', width: 140, fixed: 'left', slotName: 'actions' }, { key: 'tripNo', label: '车次号', minWidth: 220 },
   { key: 'status', label: '状态', width: 125, slotName: 'status' }, { key: 'vehiclePlate', label: '发车车牌', minWidth: 125 }, { key: 'driverName', label: '发车司机', minWidth: 100 },
   { key: 'warehouseName', label: '起运仓', minWidth: 150 }, { key: 'destinations', label: '目的地', minWidth: 180, slotName: 'destinations' },
-  { key: 'departedAt', label: '实际发车(UTC)', minWidth: 190 }, { key: 'completedAt', label: '货物结案(UTC)', minWidth: 190 },
-  { key: 'physicalPallets', label: '实物托盘', width: 100 }, { key: 'palletSpaces', label: '标准托位', width: 100 }, { key: 'ownPackages', label: '自有箱数', width: 100 }, { key: 'externalPackages', label: '外接箱数', width: 100 },
-  { key: 'agreed', label: '外接约定金额', minWidth: 170, slotName: 'agreed' }, { key: 'distance', label: '实际里程(mile)', width: 140, slotName: 'distance' }, { key: 'fuel', label: '实际油耗(L)', width: 130, slotName: 'fuel' }, { key: 'finance', label: '应收 / 实收', minWidth: 260, slotName: 'finance' }, { key: 'cost', label: '已登记直接成本', minWidth: 200, slotName: 'cost' }, { key: 'allocated', label: '自有 / 外接分摊', minWidth: 240, slotName: 'allocated' }]
+  { key: 'departedAt', label: '实际发车(UTC)', minWidth: 190 }, { key: 'physicalPallets', label: '实物托盘', width: 100 },
+  { key: 'agreed', label: '外接约定金额', minWidth: 170, slotName: 'agreed' },
+  { key: 'completedAt', label: '货物结案(UTC)', minWidth: 190, defaultVisible: false },
+  { key: 'palletSpaces', label: '标准托位', width: 100, defaultVisible: false }, { key: 'ownPackages', label: '自有箱数', width: 100, defaultVisible: false }, { key: 'externalPackages', label: '外接箱数', width: 100, defaultVisible: false },
+  { key: 'distance', label: '实际里程(mile)', width: 140, slotName: 'distance', defaultVisible: false }, { key: 'fuel', label: '实际油耗(L)', width: 130, slotName: 'fuel', defaultVisible: false },
+  { key: 'finance', label: '应收 / 实收', minWidth: 260, slotName: 'finance', defaultVisible: false }, { key: 'cost', label: '已登记直接成本', minWidth: 200, slotName: 'cost', defaultVisible: false }, { key: 'allocated', label: '自有 / 外接分摊', minWidth: 240, slotName: 'allocated', defaultVisible: false }]
 function range(): TripOperationsQuery {
   const from = String(filters.value.from || monthAgo), to = String(filters.value.to || today)
   if (!/^\d{4}-\d{2}-\d{2}$/.test(from) || !/^\d{4}-\d{2}-\d{2}$/.test(to) || Number.isNaN(Date.parse(from)) || Number.isNaN(Date.parse(to))) throw new Error('请输入有效日期 YYYY-MM-DD')
   return { from: `${from}T00:00:00Z`, to: new Date(Date.parse(`${to}T00:00:00Z`) + 86400000).toISOString(), keyword: String(filters.value.keyword || '') || undefined, sourceType: (filters.value.sourceType || undefined) as TripOperationsQuery['sourceType'], status: String(filters.value.status || '') || undefined }
 }
-async function load() { const current = ++sequence; loading.value = true; error.value = null; try { const data = await listTripOperations({ ...applied, page: page.value, size: size.value }); if (current === sequence) result.value = data } catch (e) { if (current === sequence) { result.value = null; error.value = getApiErrorDetails(e, '运营记录加载失败') } } finally { if (current === sequence) loading.value = false } }
+async function load() {
+  const current = ++sequence, query = { ...applied, page: page.value, size: size.value }
+  loading.value = true; error.value = null
+  try {
+    const data = await listTripOperations(query)
+    if (current === sequence) {
+      result.value = data
+      displayedRange.value = `${query.from.slice(0, 10)} 至 ${new Date(Date.parse(query.to) - 86400000).toISOString().slice(0, 10)}（UTC）`
+    }
+  } catch (e) {
+    if (current === sequence) { result.value = null; error.value = getApiErrorDetails(e, '运营记录加载失败') }
+  } finally { if (current === sequence) loading.value = false }
+}
 function search() { try { applied = range(); if (page.value !== 1) page.value = 1; else void load() } catch (e) { error.value = getApiErrorDetails(e, '日期范围无效') } }
+function resetFilters() { filters.value = defaultFilters() }
 function openRecord(tripNo: unknown) { const row = result.value?.page.records.find(item => item.tripNo === tripNo); if (row) { selected.value = row; recordOpen.value = true } }
 async function download() { exporting.value = true; try { await submitExport('TRIP_OPERATIONS_LIST', '出车记录', applied) } catch (e) { error.value = getApiErrorDetails(e, '导出失败') } finally { exporting.value = false } }
 const money = (rows: TripOperationsMoney[]) => rows.length ? rows.map(r => `${r.currency} ${r.amount.toFixed(2)}`).join(' / ') : '—'
 watch([page, size], load); onMounted(load); onBeforeUnmount(() => { sequence++ })
 </script>
 <template><AdminPage class="admin-density"><ListPageLayout aria-label="出车记录">
+  <template #metrics>
+    <section class="operations-overview" aria-labelledby="operations-statistics-title" :aria-busy="loading">
+      <header class="operations-heading">
+        <h2 id="operations-statistics-title">出车数据统计</h2>
+        <div class="operations-heading-tools">
+          <span class="operations-note">{{ loading ? '正在更新…' : displayedRange }}</span>
+          <el-button v-if="result" link :aria-expanded="statisticsOpen" aria-controls="operations-statistics-details" @click="statisticsOpen = !statisticsOpen">{{ statisticsOpen ? '收起详情' : '统计详情' }}</el-button>
+        </div>
+      </header>
+      <template v-if="result">
+        <TripOperationsCharts :charts="result.charts" :summary="result.summary" :details-visible="statisticsOpen" @show-details="statisticsOpen = true" />
+        <section v-if="statisticsOpen" id="operations-statistics-details" class="operations-detail-body" aria-label="统计汇总与口径">
+          <div class="operations-summary" aria-live="polite">
+            <span>实际出车 <strong>{{ result.summary.trips }}</strong> 次</span><span>在途 <strong>{{ result.summary.inTransit }}</strong> 次</span><span>货物结案 <strong>{{ result.summary.completed }}</strong> 次</span>
+          </div>
+          <p v-if="result.summary.costs.visible" class="operations-note">已登记直接成本：{{ result.summary.costs.totals.length ? result.summary.costs.totals.map(c => `${c.currency} ${c.directCost.toFixed(2)}`).join(' / ') : '—' }}；未登记 {{ result.summary.costs.unrecordedTrips ?? '—' }} 趟，已登记但未能分摊 {{ result.summary.costs.unallocatedTrips ?? '—' }} 趟。</p>
+          <p class="operations-note">按实际发车时间查询，每趟车只计一次；货源筛选展示含该类货物的整趟车。物理托盘去重；同车多站可分别计入目的地。外接约定金额不代表应收或实收，结案不代表车辆与司机已释放。</p>
+        </section>
+      </template>
+      <p v-else class="operations-placeholder operations-note" role="status">{{ loading ? '正在加载出车统计…' : '暂无统计数据' }}</p>
+    </section>
+  </template>
+  <template #state>
+    <LoadErrorState v-if="error" title="查询或导出失败" :message="error.message" @retry="load"><template #details><ApiErrorMeta :details="error" /></template></LoadErrorState>
+  </template>
   <DataTable appearance="integrated" :stripe="false" column-settings-mode="show" :results-visible="true" preference-key="fleet-operations-table" v-model:page="page" v-model:page-size="size" :data="result?.page.records || []" :columns="columns" :total="result?.page.total || 0" :loading="loading" row-key="tripNo" empty-text="该范围暂无实际出车记录">
     <template #toolbar-start><h1>出车记录</h1></template>
-    <template #filters><QueryToolbar v-model="filters" :fields="fields" ariaLabel="运营记录查询" preference-key="fleet-operations-query" :loading="loading" @search="search" @reset="search" /></template>
-    <template #notices>
-      <div class="operations-overview">
-        <LoadErrorState v-if="error" title="查询或导出失败" :message="error.message" @retry="load"><template #details><ApiErrorMeta :details="error" /></template></LoadErrorState>
-        <TripOperationsCharts v-if="result" :charts="result.charts" />
-        <div v-if="result" class="operations-summary" aria-live="polite">
-          <span>实际出车 <strong>{{ result.summary.trips }}</strong> 次</span><span>在途 <strong>{{ result.summary.inTransit }}</strong> 次</span><span>货物结案 <strong>{{ result.summary.completed }}</strong> 次</span>
-          <span>实物托盘 <strong>{{ result.summary.physicalPallets }}</strong> 托</span><span>外接约定 {{ money(result.summary.externalAgreedAmounts) }}</span>
-        </div>
-        <p v-if="result?.summary.costs.visible" class="operations-note">已登记直接成本：{{ result.summary.costs.totals.length ? result.summary.costs.totals.map(c => `${c.currency} ${c.directCost.toFixed(2)}`).join(' / ') : '—' }}；未登记 {{ result.summary.costs.unrecordedTrips }} 趟，已登记但未能分摊 {{ result.summary.costs.unallocatedTrips }} 趟。</p>
-        <p class="operations-note">按实际发车时间查询，每趟车只计一次；货源筛选展示含该类货物的整趟车。约定金额不代表应收或实收，结案不代表车辆与司机已释放。</p>
-      </div>
-    </template>
+    <template #filters><QueryToolbar v-model="filters" :fields="fields" ariaLabel="运营记录查询" preference-key="fleet-operations-query" :loading="loading" @search="search" @reset="resetFilters" /></template>
     <template #toolbar-actions><el-button v-if="access.can('platform:fleet:operations:export') && access.can('platform:download:list')" :loading="exporting" @click="download">导出</el-button></template>
     <template #actions="{ row }"><div class="density-actions row-actions admin-text-actions"><el-button v-if="access.can('platform:fleet:trip:list')" class="density-action" @click="router.push({ name: 'overseas-master-data-trip-detail', params: { tripNo: row.tripNo } })">详情</el-button><el-button class="density-action" @click="openRecord(row.tripNo)">实测记录</el-button></div></template>
     <template #status="{ row }">{{ row.status === 'COMPLETED' ? '货物已结案' : '在途' }}</template><template #destinations="{ row }">{{ row.destinations.map((d: TripOperationsRow['destinations'][number]) => d.label).join(' / ') }}</template>
@@ -73,7 +106,11 @@ watch([page, size], load); onMounted(load); onBeforeUnmount(() => { sequence++ }
   <TripOperationsRecordDialog v-model="recordOpen" :row="selected" :readonly="!access.can('platform:fleet:operations:edit')" @saved="load" />
 </ListPageLayout></AdminPage></template>
 <style scoped>
-.operations-overview { display: grid; gap: var(--admin-space-3); min-width: 0; }
+.operations-overview { display: grid; gap: var(--admin-space-3); min-width: 0; padding: var(--admin-space-5); background: var(--admin-surface); border: 1px solid var(--cc-border); border-radius: var(--admin-radius); }
+.operations-heading, .operations-heading-tools { display: flex; flex-wrap: wrap; align-items: center; justify-content: space-between; gap: var(--admin-space-3) var(--admin-space-6); }
+.operations-heading h2 { margin: 0; font-size: var(--admin-font-title); }
+.operations-detail-body { display: grid; gap: var(--admin-space-3); border-top: 1px solid var(--cc-border); padding-top: var(--admin-space-3); }
 .operations-summary { display: flex; flex-wrap: wrap; gap: var(--admin-space-2) var(--admin-space-6); font-variant-numeric: tabular-nums; }
 .operations-note { margin: 0; color: var(--cc-muted); font-size: var(--admin-font-caption); line-height: 1.6; }
+.operations-placeholder { min-height: var(--admin-empty-height); display: grid; place-content: center; }
 </style>

src/modules/overseas-master-data/routes.ts

@@ -6,13 +6,13 @@ export const overseasMasterDataRoutes = [
     path: 'overseas-master-data/capacity-offers',
     name: 'overseas-master-data-capacity-offers',
     component: () => import('./pages/CapacityOffersView.vue'),
-    meta: { title: '拼车接货', description: '查看车次可接运力并跟进拼车意向', permission: permission.capacityOfferList, permissionAnyOf: [permission.capacityOfferManage], showPageHeading: false },
+    meta: { title: '散板需求', description: '查看车次可接运力并跟进拼车意向', permission: permission.capacityOfferList, permissionAnyOf: [permission.capacityOfferManage], showPageHeading: false },
   },
   {
     path: 'overseas-master-data/capacity-offers/:offerNo',
     name: 'overseas-master-data-capacity-offer-detail',
     component: () => import('./pages/CapacityOfferDetailView.vue'),
-    meta: { title: '拼车需求详情', description: '核对可接运力与本车拼车意向', permission: permission.capacityOfferList, permissionAnyOf: [permission.capacityOfferManage], showPageHeading: false },
+    meta: { title: '散板需求详情', description: '核对可接运力与本车拼车意向', permission: permission.capacityOfferList, permissionAnyOf: [permission.capacityOfferManage], showPageHeading: false },
   },
   {
     path: 'overseas-master-data/fleet-quotes',

src/modules/overseas-warehouse/AGENTS.md

@@ -21,11 +21,11 @@
 |---|---|---|
 | 退货预报审核、退货驳回 | `pages/LastMileOrdersView.vue`、`api/lastMileOrders.ts` 的 `reviewReturnOrder` | 尾程订单内 `RETURN_RELABEL + PENDING_REVIEW` 行进入审核，来源退货号取 `sourceOrderNo`；请求 `/platform/v1/last-leg/return-orders/{returnNo}/review` 携带 `X-Customer-Id`，结论 `APPROVE/REJECT`，驳回必填原因。按钮权限入口为 `permissions.ts` 的 `returnOrderReview`；服务端归 `returnreceipt/`，通过后才能签收，不是仓储转运审核或换标完工确认 |
 | 换标申请审核、待审核按钮与驳回原因 | `pages/RelabelOrdersView.vue`、`pages/RelabelOrderDetailView.vue`、`api/relabelOrders.ts` | 列表审核动作仅在 `PENDING_REVIEW` 显示，动作选择为审核通过/已驳回，驳回原因必填；审核后不再显示审核按钮。回归见 `pages/RelabelOrdersView.test.ts`、`pages/RelabelOrderDetailView.test.ts`；PDA 完工、客户确认与申请审核分别定位，不混用状态入口 |
-| 排车车型、托位容量与限重提示 | `dispatchVehicleSpecs.ts`、`components/SmartDispatchDialog.vue`、`pages/DispatchesView.vue` | 预排车型与排车编辑选项共用规格入口：大车 30 托/40000 LB，小车 15 托/10000 LB；超重提示在预排组件，不能把前端提示当作服务端允许提交的依据。回归见 `pages/DispatchesView.test.ts`、`pages/prototypeContract.test.ts` |
+| 排车资源、草稿容器与实际容量 | `components/DispatchResourceFields.vue`、`components/SmartDispatchDialog.vue`、`dispatchContracts.ts` | 车辆/司机分别选择已有档案或临时外配，容量取真实档案或本趟填写的托位、千克及立方米，不按车型名称推算。草稿容器容量不代替车辆实测或装载校验；取证、审核前补齐规则见当前排车正式契约 |
 | 仓储转运审核、通过与驳回 | `pages/LastMileOrdersView.vue`、`components/WarehouseTransferReviewDialog.vue` | `api/warehouseTransfers.ts` 的列表、详情及 `/warehouse-transfers/{transferNo}/review`；审核按钮要求 `permissions.ts` 的 `warehouseTransferApprove` 且行类型为 `WAREHOUSE_TRANSFER`、状态为 `PENDING_REVIEW`。请求携带该行客户范围和转运单号，审核结论为 `APPROVE/REJECT`，驳回原因必填；这是尾程订单内的审核弹框，不是独立审核路由或排车转派送入口 |
 | 尾程订单控制与柜级入仓计划转换 | `pages/LastMileOrdersView.vue`、`pages/LastMileOrderDetailView.vue` | 柜子工作台按 `sourceContainerBookingId` 消费 `/orders/container-summaries`；服务端分页返回全部稳定来源柜，计划已经齐全的柜仍保留用于接柜仓查询和修改，并按冻结 `plannedArrivalAt` 升序、空值最后排序。详情返回全柜订单且不受列表分页截断；单票手工计划保存后，由服务端在整柜最后一票计划齐全时自动生成并绑定全柜托盘码，一票柜立即生成；`resourcePendingPlanCount` 只表示自动生成异常的重试入口，不是正常人工步骤。柜级确认弹框先调用 `/inbound-plans/container-preview`，按服务端 FBA/一件代发/私人地址分组展示头程已有、海外仓补充和最终托数以及 `readiness/blockers`；散货最终托数不得少于头程已有托盘码，差额连续补码且不阻断流程；一件代发必须严格按不可变头程封托托盘数整体入库，单票表单托数锁定且服务端再次失败关闭校验。前端不计算托数、不逐票建计划、不预占托盘，再把同一 `snapshotVersion/snapshotHash` 原样提交 `/inbound-plans/convert-container`，快照冲突后重新获取预览。服务端只为剩余订单逐票生成独立计划，并为异常遗留的人工计划补齐真实托盘，整批原子且重放不得产生第二批资源。单票完整入库计划、暂扣/解除和八行人工节点均从 `api/lastMileOrders.ts` 提交订单版本与幂等键；预计到仓时间只读展示来源柜冻结值，不进入人工计划请求，服务端按整柜校验并写入同一日期；入仓码只读展示并提交订单冻结值，不允许人工改写。新增暂扣只在 `INBOUND_COMPLETED` 开放，解除暂扣保持可用；暂扣不阻断入库计划，只限制后续排车和出库。人工节点一经保存不得回退柜级节点。转仓候选只取 `../iam/api/platformIam.ts` 的平台公共 `ACTIVE + FBA` 仓主档；Backend `lastleg-service/` |
 | 入仓单、入仓计划、FBA 预约 | `pages/InboundOrdersView.vue`、`pages/InboundOrderDetailView.vue` | 列表/预约 `api/inboundOrders.ts`，计划列表/详情 `api/inboundPlans.ts`；Backend `lastleg-service/inboundplan/` |
-| 排车查询、智能预排与转派送 | `pages/DispatchesView.vue`、`pages/DispatchDetailView.vue`、`components/SmartDispatchDialog.vue` | `api/dispatches.ts`；Backend `lastleg-service/dispatch/`、`delivery/`；覆盖详情、候选、草稿柜、托盘锁、`pre-arrange` 和 `transfer-delivery`。路线只读并由已排托盘关联的 FBA 仓去重后以英文逗号连接，预排和普通编辑均不接收人工路线。一次转派送仍生成一张车辆级出库单，响应的 `deliveries` 按目的 FBA 仓返回多张派送单。页面能力必须由正式路由、API 调用和测试共同证明 |
+| 排车查询、整车草稿、审核及派送安排 | `pages/DispatchesView.vue`、`pages/DispatchDetailView.vue`、`components/SmartDispatchDialog.vue`、`components/DispatchWorkflowDialog.vue` | `api/dispatches.ts`、`dispatchContracts.ts`、`dispatchCommandRecovery.ts`；Backend `lastleg-service/dispatch/`、`delivery/`。一单一趟、同仓多客户多目的地，空单或先选货均可；候选使用来源版本，草稿走服务器token及公共版本，全部容器原子转换。当前规则见`../../../../../docs/海外仓业务/排车列表统一作业改造契约.md`，不恢复旧单客户预排协议 |
 | 海外出库与派送 | `pages/OutboundsView.vue`、`pages/OutboundDetailView.vue`、`pages/DeliveryOrdersView.vue`、`pages/DeliveryOrderDetailView.vue` | `api/outbounds.ts`、`api/deliveryOrders.ts`；出库详情使用 `deliveries` 展示按目的 FBA 仓拆出的全部派送单，派送列表和详情必须显示目的 FBA 仓。人工状态入口不提供完成派送；签收资料保存成功后提示自动完成并刷新列表。出库列表按类型筛选并展示中文类型，状态须覆盖 `WAIT_PICK/待拣货`、`PICKING/拣货中`、`PICKED/已拣货`、`WAIT_OUTBOUND/待出库`、`OUTBOUNDED/已出库` 和 `CANCELLED/已取消`；仅未开始的 `WAIT_PICK/WAIT_OUTBOUND` 允许取消。一件代发新建弹窗直接跨客户加载服务端可用候选，不单独展示客户筛选，海外仓必选并优先默认洛杉矶仓；订单条件可按订单号、入库单号、客户、托盘号、SKU 或品名查询/重置，以托盘+SKU 行分页多选。提交时从所选行解析唯一客户，并校验所选行属于当前唯一海外仓，不要求先选客户。退货出库客户下拉同时展示客户名称与联系电话并支持手机号检索，客户和仓库选项独立容错加载；选择客户后须立即按当前默认/已选海外仓加载库存。SKU 与箱号查询均使用输入态/已查询态分离，只允许点击查询按钮后生效；支持英文逗号批量条件，查询时清除空格并按任一条件命中，左右列表分别提供每页 5/10/20/50 条选择。SKU 列表只展示 `availableQuantity > 0` 的未占用可用数量，合箱后已扣减为零的 SKU 不再作为可选库存显示，实际作业以可用箱唛选择和箱内 SKU 明细扣减为准。取消、派送列表/详情及退回入口对应 Backend `lastleg-service/delivery/`、`dropship/` |
 | 异常退回与客户回访 | `pages/ExceptionOrdersView.vue`、`pages/CustomerVisitsView.vue` | `api/exceptionOrders.ts`、`api/customerVisits.ts`；异常关系解析、异常建档、派送退回、完成/状态和回访附件对应 Backend `lastleg-service/exceptionorder/`、`customervisit/` |
 | 库存余额、库位与流水 | `pages/InventoryView.vue`、`pages/InventoryDetailView.vue`、`pages/InventoryTransactionsView.vue` | `api/inventory.ts`；业务库存归 `lastleg-service/inventory/`，实物资源归 `warehouse-overseas-service/` |
@@ -34,18 +34,19 @@
 
 ## 履约硬边界
 
-- 智能排车来源支持 `RELABEL`（待出库换标单），切换后不传已选入库计划 ID，按客户已确认、卡车派送且未排车的换标库存查询。提交换标号从候选 `orderRefs` 读取，不能把展示的原入库单号 `orderNo` 当换标号；沿用来源库存、托盘与箱唛，不生成新入库单。
+- 排车详情固定四个彩色图标页签：车辆信息、排车信息、单据信息、关联订单明细。五阶段及审核分区、逐动作Gate由服务端返回；取消独立于阶段。装车完成须真实PDA拣货核平，装车与实际发车分别确认；Admin和PDA共用正式版本化命令。已有单写入提交recordVersion（0合法）、原幂等键和完整载荷；未知结果保留原请求核对，成功后另读当前事实。
+- 智能排车来源支持 `RELABEL`（待出库换标单），按服务端候选的`selection.relabelNo/sourceVersion`提交，不用展示订单号或原入仓号替代换标身份；沿用真实库存、托盘与箱唛，不生成新入库单。客户和仓库归属由服务端核验，不在前端拼接客户子排车。
 
 - 托盘管理单张打印：`pages/PalletsView.vue` 每行“打印”经 `api/pallets.ts` 的 `getPalletLabelPdf` 下载当前托盘一页 PDF；使用该行仓库 ID 与托盘 ID，权限复用托盘列表。Backend `warehouse-overseas-service` 的 `PalletLabelPrintService` 读取公共托盘；有 FBA 仓码的托盘与国内统一使用 Print `FBA_PALLET_A4_LANDSCAPE_V1`（297×210 mm，FBA 仓码、完整托盘号 Code 128、托盘号文字），其他托盘使用 `INBOUND_MARK_V1`。不在前端生成标签、改码或维护第二套模板。
 
-- API 为 `api/dispatches.ts`、`api/outbounds.ts`、`api/deliveryOrders.ts`；Backend `lastleg-service/dispatch/`、`delivery/`、`dropship/`。一件代发独立出库，从服务端库存位置选择并携带幂等键；普通出库经头程排车转出库；换标只有平台卡车进入预排车，普通自提、亚马逊自提、客户自提及快递由客户确认直接创建出库任务；普通库存仍按托盘快照绑定头程箱唛，PDA 按托盘作业，详情展示箱唛与已拣数量；排车转派送按稳定 `dispatchNo` 进入服务端命令，可在 `PENDING_DEPARTURE`、`PICKING`、`READY_TO_DEPART` 状态执行并须在 PDA 发车前生成一张待出库单及按目的 FBA 仓拆分的派送单
+- API 为 `api/dispatches.ts`、`api/outbounds.ts`、`api/deliveryOrders.ts`；Backend `lastleg-service/dispatch/`、`delivery/`、`dropship/`。一件代发独立出库，从服务端库存位置选择并携带幂等键；换标只有平台卡车进入排车，普通自提、亚马逊自提、客户自提及快递由客户确认直接创建出库任务。整车派送安排在装车完成后、实际发车前进行；每客户一张出库单，每客户每目的地一张派送单，公开完整数组，不能回退为单个outboundNo或按客户拆排车头。
 - API 为 `api/exceptionOrders.ts`、`api/customerVisits.ts`；Backend `lastleg-service/exceptionorder/`、`customervisit/`。异常处理只消费服务端 `allowedActions/version`；完成时至少上传一份异常证据。派送退回先从服务端原出库拣货事实选择入仓单和可退箱数，不允许自由填写 SKU/数量；退回海外仓时必须选择服务端校验的目标托盘和库位，库存恢复、异常完成与派送 `RETURNED` 由服务端原子推进。回访附件和派送完成/状态均走海外真实 API
 
 ## 验证
 
 - 一件代发出库候选选择：`pages/OutboundsView.vue` 按 `inventoryPositionId + skuCode` 保留跨页选择，只提供本页全选；查询/重置回到第一页，切换海外仓清空选择。提交仍校验同客户、同海外仓，数量取所选行的 `availablePackages`（箱数），不能按 SKU 件数替代；候选同时展示当前可出箱数对应的毛重、材积重和体积，创建出库单时服务端按本次出库箱数占实际入库箱数的比例冻结三项测量快照。候选交互回归见 `pages/OutboundsView.selection.test.ts`；状态展示与取消门禁见 `pages/OutboundsView.test.ts`、`pages/OutboundDetailView.test.ts`。
 - 转运审核定向测试：从应用根运行 `pnpm test src/modules/overseas-warehouse/api/warehouseTransfers.test.ts src/modules/overseas-warehouse/pages/prototypeContract.test.ts`，分别核对客户作用域/API 与审核入口权限、状态。
-- 排车转派送弹框打开时并行读取一次`getDispatchExternalFreight`和`getDispatchFeeCoverage`；不逐行查费用。`DeliveryFeeCoveragePanel`按实际各票原费用明确勾选派送/装车/买约，提交来源ID/版本/hash与货物摘要，不按金额推断覆盖。`fullyCoveredServices`只控制输入展示，服务端重新核验；只有全部货物已包含的项目才不提交新增应收，部分覆盖仍需填剩余项目。外接报价只读并提交externalFreightHash。派送详情显示确认时的原费用覆盖快照，原费用金额与本次新增费用分开展示；不能将原费用再次记入新费用行。
+- 派送安排弹框通过`getDispatchArrangement`读取整车分组、实际货物、外接报价及原费用依据，`DispatchArrangeFields.vue`按真实客户目的地组提交；不逐行查费用，不按金额推断覆盖，不把原费用再次记入新费用行。移货必须使用`GET items`返回的真实dispatchItemId及逐项remove Gate；路线仅重排`GET route`返回的既有全部目的地，包含外接点，不能新增或猜测目的地。附件沿`DispatchEvidenceFiles.vue`的本车鉴权上传/读取，上传与主单引用保存分开。
 - 出库取消提示先解除车次关联，取消后仍须在排车列表释放原排车占用；不提示库存已自动回滚。派送详情费用读取reviewStatus/sourceStatus/voidStatus，同一详情响应展示待财务确认、待财务处理、确认作废，不逐行查询，也不把取消成功视为费用作废。货柜费用面板直接消费同一费用来源接口，待确认时同样禁止调整和重复作废，沿用原页面/弹框承载。
 - 排车列表编辑、托盘移除、BOL PDF 和转派送从 `pages/DispatchesView.vue` → `api/dispatches.ts` 进入；智能预排的候选、草稿柜与托盘锁从 `components/SmartDispatchDialog.vue` 进入。回归为 `pages/DispatchesView.test.ts`、`pages/prototypeContract.test.ts`，不要把列表操作与预排草稿当作同一入口。
 - 从应用根按目标页面选择相邻测试：`pnpm test src/modules/overseas-warehouse/<目标测试路径>`；API 或类型变化同时运行 `pnpm typecheck`。应用完整门禁继续遵循上层指引。

src/modules/overseas-warehouse/api/dispatches.test.ts

@@ -1,161 +1,131 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { http } from '@/shared/api/http'
-import { cancelDispatch, createDispatchDraftContainer, deleteDispatchDraftContainer, getDispatch, getDispatchBolPdf, getDispatchExternalFreight, getDispatchFeeCoverage, listDispatchCandidates, listDispatchDrafts, listDispatches, lockDispatchDraftPallet, preArrangeDispatch, preArrangeDraftDispatch, releaseDispatchDraft, transferDispatchToDelivery, unlockDispatchDraftPallet, updateDispatch, getBatchDispatchCandidates } from './dispatches'
-
-vi.mock('@/shared/api/http', async (importOriginal) => ({ ...(await importOriginal<typeof import('@/shared/api/http')>()), http: { get: vi.fn(), post: vi.fn(), put: vi.fn(), delete: vi.fn() } }))
-
-describe('dispatch overseas API', () => {
-  it('reads an immutable batch and preserves its exact per-source allocations on grouped submission', async () => {
-    const allocation = { planPalletId: '9007199254740993', batchKey: 'FBA_APPOINTMENT:9', customerId: '9007199254740999', sourceKey: 'BOOKING:2', destinationKey: 'FBA:ONT8', packageCount: 12 }
-    vi.mocked(http.get).mockResolvedValue({ code: '200', data: { batchKey: allocation.batchKey, version: 4, candidates: [], blockReasons: [] } })
-    await getBatchDispatchCandidates(allocation.batchKey)
-    expect(http.get).toHaveBeenCalledWith('/platform/v1/last-leg/appointment-planning/batches/FBA_APPOINTMENT%3A9/dispatch-candidates')
-    vi.mocked(http.post).mockResolvedValue({ code: '200', data: [] })
-    const request = { draftToken: 'draft-1', groups: [{ draftContainerId: 'container-1', planPalletIds: [allocation.planPalletId], returnReceiptIds: [], batchAllocations: [allocation] }] }
-    await preArrangeDraftDispatch(request)
-    expect(http.post).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/drafts/pre-arrange', request)
-  })
-  it('submits all explicit draft groups once and preserves container and source identities', async () => {
-    const payload = { draftToken: 'original-draft', groups: [
-      { draftContainerId: '190000000000000099', planPalletIds: ['11', '13'], returnReceiptIds: [] },
-      { draftContainerId: '190000000000000100', planPalletIds: ['12'], returnReceiptIds: ['22'] },
-    ] }
-    const result = payload.groups.map((group, index) => ({ draftContainerId: group.draftContainerId, dispatch: { id: String(index), dispatchNo: `DS-${index}` } }))
-    vi.mocked(http.post).mockResolvedValue({ code: '200', data: result })
-    expect(await preArrangeDraftDispatch(payload)).toEqual(result)
-    expect(http.post).toHaveBeenCalledExactlyOnceWith('/platform/v1/last-leg/dispatches/drafts/pre-arrange', payload)
-  })
-  it('propagates a batch rejection without falling back to a flat or repeated command', async () => {
-    vi.mocked(http.post).mockResolvedValue({ code: 'A0409', message: '草稿来源已变化', data: null })
-    await expect(preArrangeDraftDispatch({ draftToken: 'original-draft', groups: [
-      { draftContainerId: 'container', planPalletIds: ['11'], returnReceiptIds: [] },
-    ] })).rejects.toThrow('草稿来源已变化')
-    expect(http.post).toHaveBeenCalledTimes(1)
-  })
-  it('locks and submits actual return receipts without pretending they are plan pallets', async () => {
-    vi.mocked(http.post).mockResolvedValue({ code: '200', data: null })
-    await lockDispatchDraftPallet('RETURN:190000000000000099', 'draft-return', 'container-1')
-    expect(http.post).toHaveBeenLastCalledWith('/platform/v1/last-leg/dispatches/draft-locks/lock', {
-      sourceType: 'RETURN_RECEIPT', returnReceiptId: '190000000000000099', draftToken: 'draft-return', draftContainerId: 'container-1',
-    })
-    await unlockDispatchDraftPallet('RETURN:190000000000000099', 'draft-return')
-    expect(http.post).toHaveBeenLastCalledWith('/platform/v1/last-leg/dispatches/draft-locks/unlock', {
-      sourceType: 'RETURN_RECEIPT', returnReceiptId: '190000000000000099', draftToken: 'draft-return',
-    })
-    await preArrangeDispatch({ planPalletIds: [], returnReceiptIds: ['190000000000000099'], draftToken: 'draft-return' })
-    expect(http.post).toHaveBeenLastCalledWith('/platform/v1/last-leg/dispatches/pre-arrange', {
-      planPalletIds: [], returnReceiptIds: ['190000000000000099'], draftToken: 'draft-return',
-    })
-  })
-  it('reads external freight from the scoped dispatch without a supplied customer', async () => {
-    vi.mocked(http.get).mockResolvedValue({ code: '200', data: { snapshotHash: 'hash', requiresDeliveryFee: false, quotes: [] } })
-    expect(await getDispatchExternalFreight('DP/1')).toEqual({ snapshotHash: 'hash', requiresDeliveryFee: false, quotes: [] })
-    expect(http.get).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/DP%2F1/external-freight')
-  })
-  it('loads per-shipment coverage without exposing a caller-supplied customer or losing long IDs', async () => {
-    vi.mocked(http.get).mockResolvedValue({ code: '200', data: { dispatchNo: 'DP/1', sourceComplete: true, blockReason: null, cargoHash: 'hash', cargo: [], feeSources: [{ financeFeeId: '190000000000000099', sourceFeeId: '190000000000000100', customerId: '101', sourceInboundId: '11', sourceVersion: '2', amount: '100.25' }] } })
-    const result = await getDispatchFeeCoverage('DP/1')
-    expect(http.get).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/DP%2F1/fee-coverage')
-    expect(result.feeSources[0]).toMatchObject({ financeFeeId: '190000000000000099', sourceVersion: 2, amount: 100.25 })
-  })
-  beforeEach(() => {
-    vi.mocked(http.get).mockReset()
-    vi.mocked(http.post).mockReset()
-    vi.mocked(http.put).mockReset()
-    vi.mocked(http.delete).mockReset()
-  })
-
-  it('uses the platform dispatch page without customer scope', async () => {
-    vi.mocked(http.get).mockResolvedValue({
-      code: '200', message: 'success', data: { records: [], page: 2, size: 50, total: 0, pages: 0 },
-    })
-
-    await listDispatches({
-      page: 2, size: 50, dispatchNo: 'PC-1',
-      vehiclePlate: 'CA-100', status: 'PENDING_DEPARTURE', fbaAppointmentNo: 'FBA-1',
-    })
-
-    expect(http.get).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches', {
-      params: {
-        page: 2, size: 50, dispatchNo: 'PC-1',
-        vehiclePlate: 'CA-100', status: 'PENDING_DEPARTURE', fbaAppointmentNo: 'FBA-1',
-      },
-    })
-  })
-
-  it('loads a platform dispatch detail by encoded dispatch number', async () => {
-    vi.mocked(http.get).mockResolvedValue({ code: '200', message: 'success', data: { id: '1', dispatchNo: 'PC/1' } })
-
-    await getDispatch('PC/1')
-
-    expect(http.get).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/PC%2F1')
-  })
-
-  it('requests the generated BOL as a PDF blob', async () => {
-    vi.mocked(http.get).mockResolvedValue(new Blob(['%PDF-test']))
-    await getDispatchBolPdf('PC/1')
-    expect(http.get).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/PC%2F1/prints/bol', { responseType: 'blob' })
-  })
-
-  it('loads candidates and creates a pre-arrange dispatch in an explicit customer scope', async () => {
-    vi.mocked(http.get).mockResolvedValue({ code: '200', message: 'success', data: [] })
-    vi.mocked(http.post).mockResolvedValue({ code: '200', message: 'success', data: { id: '1', dispatchNo: 'PC-1' } })
-    await listDispatchCandidates({ planIds: '101,102', fbaWarehouseCode: 'ONT8', sourceStage: 'PLAN' })
-    await preArrangeDispatch({ planPalletIds: ['190000000000000099'] })
-    expect(http.get).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/candidates', { params: { planIds: '101,102', fbaWarehouseCode: 'ONT8', sourceStage: 'PLAN' } })
-    expect(http.post).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/pre-arrange', { planPalletIds: ['190000000000000099'] })
-  })
-
-  it('loads platform candidates without selected inbound plans', async () => {
-    vi.mocked(http.get).mockResolvedValue({ code: '200', message: 'success', data: [] })
-
-    await listDispatchCandidates({ sourceStage: 'RECEIVED' })
-
-    expect(http.get).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/candidates', {
-      params: { sourceStage: 'RECEIVED' },
-    })
-  })
-
-  it('locks, unlocks, and releases intelligent dispatch drafts through dedicated endpoints', async () => {
-    vi.mocked(http.post).mockResolvedValue({ code: '200', message: 'success', data: null })
-
-    await lockDispatchDraftPallet('99', 'draft-1')
-    await unlockDispatchDraftPallet('99', 'draft-1')
-    await releaseDispatchDraft('draft-1')
-
-    expect(http.post).toHaveBeenNthCalledWith(1, '/platform/v1/last-leg/dispatches/draft-locks/lock', { planPalletId: '99', draftToken: 'draft-1' })
-    expect(http.post).toHaveBeenNthCalledWith(2, '/platform/v1/last-leg/dispatches/draft-locks/unlock', { planPalletId: '99', draftToken: 'draft-1' })
-    expect(http.post).toHaveBeenNthCalledWith(3, '/platform/v1/last-leg/dispatches/draft-locks/release', { draftToken: 'draft-1' })
-  })
-
-  it('edits and cancels only by dispatchNo without customer scope or status mutation', async () => {
-    vi.mocked(http.put).mockResolvedValue({ code: '200', message: 'success', data: { id: '1', dispatchNo: 'PC/1' } })
-    vi.mocked(http.delete).mockResolvedValue({ code: '200', message: 'success', data: null })
-    await updateDispatch('PC/1', { vehiclePlate: 'CA-100' })
-    await cancelDispatch('PC/1')
-    expect(http.put).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/PC%2F1', { vehiclePlate: 'CA-100' })
-    expect(http.put).not.toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ status: expect.anything() }))
-    expect(http.delete).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/PC%2F1')
-  })
-
-  it('transfers to delivery only by dispatchNo without customerId', async () => {
-    vi.mocked(http.post).mockResolvedValue({ code: '200', message: 'success', data: { dispatchNo: 'PC/1', outboundNo: 'OUT-1', outboundStatus: 'PICKED', palletCount: 2, packageCount: 20, deliveries: [{ deliveryNo: 'DEL-1', deliveryStatus: 'WAIT_DELIVERY', destinationWarehouseCode: 'ACY2', palletCount: 2, packageCount: 20 }], replayed: false } })
-    const payload = { idempotencyKey: 'transfer-1', plannedDeliveryAt: '2026-09-01T10:00:00', deliveryMethod: 'TRUCK_PALLET', pickupMethod: 'WAREHOUSE_PICKUP', loadingType: 'PALLET', fees: [{ feeType: 'DELIVERY_FEE', feeName: '派送费用', direction: 'RECEIVABLE' as const, currency: 'USD' as const, amount: 10 }] }
-    await transferDispatchToDelivery('PC/1', payload)
-    expect(http.post).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/PC%2F1/transfer-delivery', payload)
-  })
-
-  it('loads drafts and preserves long container ids in create and delete paths', async () => {
-    vi.mocked(http.get).mockResolvedValue({ code: '200', message: 'success', data: [] })
-    vi.mocked(http.post).mockResolvedValue({ code: '200', message: 'success', data: { id: '190000000000000099', capacity: 30, palletIds: [] } })
-    vi.mocked(http.delete).mockResolvedValue({ code: '200', message: 'success', data: null })
-
-    await listDispatchDrafts()
-    await createDispatchDraftContainer('draft/1', 30)
-    await deleteDispatchDraftContainer('draft/1', '190000000000000099')
-
-    expect(http.get).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/drafts')
-    expect(http.post).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/drafts/containers', { draftToken: 'draft/1', capacity: 30 })
-    expect(http.delete).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/drafts/draft%2F1/containers/190000000000000099')
-  })
+import * as api from './dispatches'
+import { candidate, command, detail, loadingPreview, page } from '../dispatchTestFixtures'
+import type { ArrangeDelivery, CreateDispatch, DispatchBatchAllocation, DraftSelection, LoadingComplete, ReasonCommand, ReviewCommand, UpdateDispatch, Version, VersionCommand } from '../dispatchContracts'
+vi.mock('@/shared/api/http', () => ({ http: { get: vi.fn(), post: vi.fn(), put: vi.fn(), delete: vi.fn() }, unwrapApiResponse: (value: { data: unknown }) => value.data }))
+const body = { recordVersion: 0, idempotencyKey: 'original-key', reason: '核对原因' }
+const draft = () => ({ draftToken: 'server-token', recordVersion: 0, status: 'ACTIVE', warehouseId: '321', containers: [], sources: [candidate()], expiresAt: '' })
+const file = () => ({ fileId: '9007199254740993', fileName: '证据.png', contentType: 'image/png', sizeBytes: 3 })
+beforeEach(() => {
+  vi.clearAllMocks()
+  vi.mocked(http.get).mockImplementation(async url => ({ data: url.endsWith('/items') ? { dispatchNo: 'PC/1', recordVersion: 0, status: 'ACTIVE', stage: 'BEFORE_LOADING', items: [] } : url.includes('/evidence/') ? file() : url.endsWith('/loading') ? loadingPreview() : url.includes('/commands/') ? command('EDIT') : detail() }))
+  vi.mocked(http.post).mockImplementation(async url => ({ data: url.endsWith('/pre-arrange') ? { draftToken: 'server-token', vehicles: [], replayed: false } : url.includes('/draft') ? draft() : url.includes('/evidence/') ? file() : command('EDIT') }))
+  vi.mocked(http.put).mockResolvedValue({ data: command('EDIT') })
+  vi.mocked(http.delete).mockResolvedValue({ data: draft() })
+})
+
+describe('native whole-vehicle dispatch API', () => {
+  it.each([0, '0', '9007199254740993'])('preserves authoritative batch version %s across direct create, add cargo and grouped conversion', async recordVersion => {
+    const allocation: DispatchBatchAllocation = { planPalletId: '11', batchKey: 'FBA_APPOINTMENT:1', customerId: 'C1', sourceKey: 'ORDER:1', destinationKey: 'FBA:ONT8', packageCount: 2, recordVersion }
+    const create: CreateDispatch = { warehouseId: '321', idempotencyKey: 'create', vehicle: null, driver: null, plannedDepartureAt: null, estimatedArrivalAt: null, remark: null, cargo: [candidate().selection], batchAllocations: [allocation] }
+    await api.createDispatch(create); await api.addDispatchCargo('PC/1', { ...body, cargo: create.cargo, batchAllocations: [allocation] }); await api.convertDispatchDraft({ ...body, draftToken: 'draft', groups: [{ draftContainerId: 'container', dispatch: create }] })
+    expect(vi.mocked(http.post).mock.calls[0]![1]).toBe(create)
+    expect(vi.mocked(http.post).mock.calls[1]![1]).toMatchObject({ batchAllocations: [{ recordVersion }] })
+    expect(vi.mocked(http.post).mock.calls[2]![1]).toMatchObject({ groups: [{ dispatch: { batchAllocations: [{ recordVersion }] } }] })
+  })
+  it.each([undefined, null, -1, '', 'bad', 9007199254740992])('rejects missing or invalid nested batch version %s before any write or candidate handoff', async value => {
+    const allocation = { planPalletId: '11', batchKey: 'FBA_APPOINTMENT:1', customerId: 'C1', sourceKey: 'ORDER:1', destinationKey: 'FBA:ONT8', packageCount: 2, recordVersion: value } as unknown as DispatchBatchAllocation
+    const create: CreateDispatch = { warehouseId: '321', idempotencyKey: 'create', vehicle: null, driver: null, plannedDepartureAt: null, estimatedArrivalAt: null, remark: null, cargo: [candidate().selection], batchAllocations: [allocation] }
+    await expect(Promise.resolve().then(() => api.createDispatch(create))).rejects.toThrow('重新读取候选')
+    await expect(Promise.resolve().then(() => api.addDispatchCargo('PC/1', { ...body, cargo: create.cargo, batchAllocations: [allocation] }))).rejects.toThrow('重新读取候选')
+    await expect(Promise.resolve().then(() => api.convertDispatchDraft({ ...body, draftToken: 'draft', groups: [{ draftContainerId: 'container', dispatch: create }] }))).rejects.toThrow('重新读取候选')
+    expect(http.post).not.toHaveBeenCalled()
+    vi.mocked(http.get).mockResolvedValueOnce({ data: { batchKey: allocation.batchKey, version: 5, candidates: [{ allocations: [allocation] }], blockReasons: [] } })
+    await expect(api.getBatchDispatchCandidates(allocation.batchKey)).rejects.toThrow('重新读取候选')
+  })
+  it('rejects inconsistent original versions of the same batch across conversion groups', () => {
+    const allocation = { planPalletId: '11', batchKey: 'FBA_APPOINTMENT:1', customerId: 'C1', sourceKey: 'ORDER:1', destinationKey: 'FBA:ONT8', packageCount: 2, recordVersion: '9007199254740993' }
+    const create: CreateDispatch = { warehouseId: '321', idempotencyKey: 'create', vehicle: null, driver: null, plannedDepartureAt: null, estimatedArrivalAt: null, remark: null, cargo: [], batchAllocations: [allocation] }
+    expect(() => api.convertDispatchDraft({ ...body, draftToken: 'draft', groups: [{ draftContainerId: 'A', dispatch: create }, { draftContainerId: 'B', dispatch: { ...create, batchAllocations: [{ ...allocation, recordVersion: '9007199254740994' }] } }] })).toThrow('同一预约批次的版本不一致')
+    expect(http.post).not.toHaveBeenCalled()
+  })
+  it('uses actual item, route and evidence endpoints with native multipart and authenticated blob content', async () => {
+    await api.getDispatchItems('PC/1'); await api.getDispatchRoute('PC/1'); await api.getDispatchEvidence('PC/1', 'DRIVER', '9007199254740993')
+    expect(vi.mocked(http.get).mock.calls.map(call => call[0])).toEqual(['/platform/v1/last-leg/dispatches/PC%2F1/items', '/platform/v1/last-leg/dispatches/PC%2F1/route', '/platform/v1/last-leg/dispatches/PC%2F1/evidence/DRIVER/9007199254740993'])
+    const file = new File(['png'], '证据.png', { type: 'image/png' }); await api.uploadDispatchEvidence('PC/1', 'VEHICLE', file)
+    const upload = vi.mocked(http.post).mock.calls[0]!
+    expect(upload[0]).toBe('/platform/v1/last-leg/dispatches/PC%2F1/evidence/VEHICLE'); expect(upload[1]).toBeInstanceOf(FormData); expect((upload[1] as FormData).get('file')).toBe(file)
+    await api.getDispatchEvidenceContent('PC/1', 'VEHICLE', '301'); expect(http.get).toHaveBeenLastCalledWith('/platform/v1/last-leg/dispatches/PC%2F1/evidence/VEHICLE/301/content', { responseType: 'blob' })
+  })
+  it('reorders only the supplied existing destination keys with explicit native version zero', async () => {
+    await expect(api.reorderDispatchRoute('PC/1', { recordVersion: null as unknown as number, idempotencyKey: 'key', destinationKeys: [], reason: '路线调整' })).rejects.toThrow('版本')
+    expect(http.put).not.toHaveBeenCalled()
+    const request = { recordVersion: 0, idempotencyKey: 'key', destinationKeys: ['CODE:ONT8', 'PRIVATE:actual'], reason: '现场卸货顺序调整' }
+    await api.reorderDispatchRoute('PC/1', request); expect(http.put).toHaveBeenCalledExactlyOnceWith('/platform/v1/last-leg/dispatches/PC%2F1/route', request)
+  })
+  it('queries five-stage rows with server review sections and preserves statistics', async () => {
+    vi.mocked(http.get).mockResolvedValueOnce({ data: page() })
+    const query = { page: 2, size: 20, stage: 'BEFORE_LOADING' as const, beforeLoadingSection: 'DISPATCH_REVIEW' as const, reviewStatus: 'PENDING' as const, status: 'ACTIVE' as const }
+    const result = await api.listDispatches(query)
+    expect(http.get).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches', { params: query }); expect(result.statistics.stageCounts.DELIVERING).toBe(1)
+  })
+  it('reads the four-object detail and loading without customer scope, encoding business numbers', async () => {
+    await api.getDispatch('PC/1'); await api.getDispatchLoading('PC/1'); await api.getDispatchCommand('PC/1', 'key/1')
+    expect(vi.mocked(http.get).mock.calls.map(call => call[0])).toEqual(['/platform/v1/last-leg/dispatches/PC%2F1', '/platform/v1/last-leg/dispatches/PC%2F1/loading', '/platform/v1/last-leg/dispatches/PC%2F1/commands/key%2F1'])
+  })
+  it('reads candidates with their exact sourceVersion and repeated plan query parameters', async () => {
+    const data = { candidates: [candidate()], snapshotAt: '2026-10-19T10:00:00Z', complete: true }
+    vi.mocked(http.get).mockResolvedValueOnce({ data })
+    expect(await api.listDispatchCandidates({ warehouseId: '321', planIds: ['11', '12'] })).toEqual(data)
+    expect(http.get).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/candidates', { params: { warehouseId: '321', planIds: ['11', '12'] }, paramsSerializer: { indexes: null } })
+  })
+  it('creates an empty real dispatch without an artificial customer or cargo', async () => {
+    const request: CreateDispatch = { idempotencyKey: 'create', warehouseId: '321', vehicle: null, driver: null, plannedDepartureAt: null, estimatedArrivalAt: null, remark: null, cargo: [], batchAllocations: [] }
+    await api.createDispatch(request); expect(http.post).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches', request)
+  })
+  it.each(['cancel', 'remove', 'review', 'loading-review', 'return', 'loading', 'depart', 'arrange', 'add', 'submit', 'draft-container', 'draft-select', 'draft-release', 'draft-convert', 'draft-snapshot'])('rejects missing/null/negative versions before %s requests and accepts zero', async action => {
+    const invoke = (value: unknown) => {
+      const request = { ...body, recordVersion: value as Version }
+      switch (action) {
+        case 'cancel': return api.cancelDispatch('PC/1', request)
+        case 'remove': return api.removeDispatchItem('PC/1', '11', request)
+        case 'review': return api.reviewDispatch('PC/1', request as unknown as ReviewCommand)
+        case 'loading-review': return api.reviewDispatchLoading('PC/1', request as unknown as ReviewCommand)
+        case 'return': return api.returnDispatchToReview('PC/1', request)
+        case 'loading': return api.completeDispatchLoading('PC/1', request as unknown as LoadingComplete)
+        case 'depart': return api.departDispatch('PC/1', { ...request, remark: null })
+        case 'arrange': return api.transferDispatchToDelivery('PC/1', request as unknown as ArrangeDelivery)
+        case 'add': return api.addDispatchCargo('PC/1', { ...request, cargo: [], batchAllocations: [] })
+        case 'submit': return api.submitDispatchReview('PC/1', { ...request, remark: null })
+        case 'draft-container': return api.createDispatchDraftContainer({ ...request, draftToken: 'draft', capacity: 30 })
+        case 'draft-select': return api.lockDispatchDraftPallet(request as unknown as DraftSelection)
+        case 'draft-release': return api.releaseDispatchDraft({ ...request, draftToken: 'draft' })
+        case 'draft-convert': return api.convertDispatchDraft({ ...request, draftToken: 'draft', groups: [] })
+        default: return api.saveDispatchDraftSnapshot({ ...request, draftToken: 'draft', planIds: [], containers: [] })
+      }
+    }
+    for (const invalid of [undefined, null, -1, '', 'bad', Number.MAX_SAFE_INTEGER + 1]) await expect(Promise.resolve().then<unknown>(() => invoke(invalid))).rejects.toThrow('版本')
+    expect(http.post).not.toHaveBeenCalled(); await invoke(0); expect(vi.mocked(http.post).mock.calls[0]![1]).toEqual(expect.objectContaining({ recordVersion: 0 }))
+  })
+  it('updates only an existing appointment reference and its explicit version', async () => {
+    const request: UpdateDispatch = { ...body, vehicle: null, driver: null, plannedDepartureAt: null, estimatedArrivalAt: null, remark: null, vehicleAppointment: { referenceNo: 'AP-1', recordVersion: 0 } }
+    await api.updateDispatch('PC/1', request); expect(http.put).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/PC%2F1', request)
+    await expect(api.updateDispatch('PC/1', { ...request, vehicleAppointment: { referenceNo: 'AP-1', recordVersion: null as unknown as Version } })).rejects.toThrow('版本')
+    await expect(api.updateDispatch('PC/1', { ...request, recordVersion: undefined as unknown as Version })).rejects.toThrow('版本')
+  })
+  it('uses versioned removal and cancellation POSTs instead of unversioned deletes', async () => {
+    await api.cancelDispatch('PC/1', body); await api.removeDispatchItem('PC/1', 'item/1', body)
+    expect(vi.mocked(http.post).mock.calls.map(call => call[0])).toEqual(['/platform/v1/last-leg/dispatches/PC%2F1/cancel', '/platform/v1/last-leg/dispatches/PC%2F1/items/item%2F1/remove']); expect(http.delete).not.toHaveBeenCalled()
+  })
+  it('preserves complete grouped arrangement evidence and returns an immutable command envelope', async () => {
+    const outbound = (customerId: string) => ({ customerId, customerName: `客户${customerId}`, outboundNo: `OUT-${customerId}`, status: 'WAIT_OUTBOUND', packageCount: 2, palletCount: 1 })
+    const delivery = (customerId: string) => ({ ...outbound(customerId), groupKey: customerId, deliveryNo: `DEL-${customerId}`, destination: candidate().destination })
+    const data = { ...command('ARRANGE_DELIVERY'), result: { dispatchNo: 'PC/1', recordVersion: '9007199254740993', arrangementKey: 'arrange', cargoHash: 'cargo', arrangedAt: '2026-10-19T10:00:00Z', outbounds: [outbound('A'), outbound('B')], deliveries: [delivery('A'), delivery('B')] } }
+    vi.mocked(http.post).mockResolvedValueOnce({ data })
+    const request: ArrangeDelivery = { ...body, recordVersion: '9007199254740993', cargoHash: 'cargo', loadingCompletionHash: 'loaded', groups: [] }
+    expect(await api.transferDispatchToDelivery('PC/1', request)).toEqual(data); expect(http.post).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/PC%2F1/transfer-delivery', request)
+  })
+  it('keeps draft version, server token and source evidence and converts explicit groups atomically', async () => {
+    const source = candidate().selection
+    await api.lockDispatchDraftPallet({ ...body, draftToken: 'server-token', draftContainerId: '190000000000000011', source })
+    expect(http.post).toHaveBeenLastCalledWith('/platform/v1/last-leg/dispatches/draft-locks/lock', { ...body, draftToken: 'server-token', draftContainerId: '190000000000000011', source })
+    await api.convertDispatchDraft({ ...body, draftToken: 'server-token', groups: [] }); expect(http.post).toHaveBeenLastCalledWith('/platform/v1/last-leg/dispatches/drafts/pre-arrange', { ...body, draftToken: 'server-token', groups: [] })
+  })
+  it('deletes draft containers with the body version and never invents successful response data', async () => {
+    vi.mocked(http.delete).mockRejectedValueOnce(new Error('server failure'))
+    await expect(api.deleteDispatchDraftContainer('draft/1', 'container/1', body as ReasonCommand)).rejects.toThrow('server failure')
+    expect(http.delete).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/drafts/draft%2F1/containers/container%2F1', { data: body })
+  })
+  it('reads BOL as a PDF blob', async () => { await api.getDispatchBolPdf('PC/1'); expect(http.get).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/PC%2F1/prints/bol', { responseType: 'blob' }) })
 })

src/modules/overseas-warehouse/api/dispatches.ts

@@ -1,346 +1,65 @@
 import { http, unwrapApiResponse, type ApiEnvelope } from '@/shared/api/http'
+import type { DispatchEvidenceKind, DispatchRoute, DispatchRouteCommand } from '../dispatchContracts'
+import { requireVersion, requireBatchVersions, type AddCargo, type ArrangeDelivery, type CandidateQuery, type ConvertDraft, type CreateDispatch, type DispatchQuery, type DraftContainer, type DraftSelection, type LoadingComplete, type ReasonCommand, type ReviewCommand, type UpdateDispatch, type VersionCommand, type DispatchBatchAllocation } from '../dispatchContracts'
+import { normalizeArrangementPreview, normalizeCandidateList, normalizeConvertedDraft, normalizeDispatchCommand, normalizeDispatchDetail, normalizeDispatchDraft, normalizeDispatchItems, normalizeDispatchPage, normalizeEvidenceFile, normalizeLoadingPreview, type ArrangementPreviewWire, type CandidateListWire, type CommandResultWire, type ConvertedDraftWire, type DispatchDetailWire, type DispatchDraftWire, type DispatchEvidenceFileWire, type DispatchItemsWire, type DispatchPageWire, type LoadingPreviewWire } from '../dispatchWire'
+export type { DispatchBatchReference, DispatchBatchAllocation } from '../dispatchContracts'
 
-import { normalizeOverseasPage, type OverseasPagePayload } from './lastMileOrders'
-
-export interface DispatchQuery {
-  page: number
-  size: number
-  dispatchNo?: string
-  vehiclePlate?: string
-  status?: string
-  fbaAppointmentNo?: string
-  stage?: 'BEFORE_LOADING' | 'LOADING' | 'AFTER_LOADING' | 'CANCELLED'
-}
-
-export interface DispatchReview { status: 'PENDING' | 'APPROVED' | 'REJECTED'; reason: string | null; reviewedAt: string | null }
-export interface DispatchWorkflow { tripNo: string; dispatchReview: DispatchReview; loadingReview: DispatchReview }
-export interface DispatchActions {
-  canEdit: boolean
-  editBlockReason: string | null
-  canCancel: boolean
-  cancelBlockReason: string | null
-  canRemovePallet: boolean
-  removePalletBlockReason: string | null
-  canTransfer: boolean
-  transferBlockReason: string | null
-  outboundNo: string | null
-  outboundStatus: string | null
-}
-
-export interface DispatchPalletCandidateDto {
-  sourceType?: 'INBOUND_PLAN' | 'RETURN_RECEIPT'
-  returnReceiptId?: string | null
-  returnReceiptNo?: string | null
-  planId?: string | null
-  planPalletId?: string | null
-  warehousePalletId?: string | null
-  orderId: string
-  customerId?: string | null
-  customerName?: string | null
-  planNo?: string | null
-  orderType?: string | null
-  volumeWeightKg?: number | null
-  grossWeightKg?: number | null
-  containerNo?: string | null
-  appointmentAt?: string | null
-  expectedLoadingAt?: string | null
-  overseasWarehouseId?: string | null
-  overseasWarehouseCode?: string | null
-  overseasWarehouseName?: string | null
-  orderNo?: string | null
-  orderRefs?: string | null
-  inboundCode?: string | null
-  palletNo?: string | null
-  destinationWarehouseId?: string | null
-  destinationWarehouseCode?: string | null
-  destinationWarehouseName?: string | null
-  fbaWarehouseCode?: string | null
-  packageCount?: number | null
-  volumeCbm?: number | null
-  sourceStage?: 'PLAN' | 'RECEIVED' | 'RELABEL' | null
-  cartonMarks?: string | null
-  relabelCartonMarks?: string | null
-  destinationType?: 'FBA' | 'PRIVATE' | null
-  deliveryAddress?: string | null
-  postalCode?: string | null
-  contactName?: string | null
-  contactPhone?: string | null
-}
-
-export interface DispatchCandidateQuery {
-  planIds?: string
-  orderNo?: string
-  fbaWarehouseCode?: string
-  sourceStage?: 'PLAN' | 'RECEIVED' | 'RELABEL'
-  draftToken?: string
-}
-export interface DispatchDraftContainerDto { id: string; capacity: number; palletIds: string[] }
-export interface DispatchDraftDto { draftToken: string; containers?: DispatchDraftContainerDto[] }
-
-export interface PreArrangeDispatchPayload {
-  batchAllocations?: DispatchBatchAllocation[]
-  planPalletIds: string[]
-  returnReceiptIds?: string[]
-  fbaAppointmentNo?: string
-  fbaAppointmentStatus?: string
-  vehicleAppointmentStatus?: string
-  draftToken?: string
-  relabelNo?: string
-}
-
-export interface PreArrangeDispatchDraftGroup {
-  batchAllocations?: DispatchBatchAllocation[]
-  draftContainerId: string
-  planPalletIds: string[]
-  returnReceiptIds: string[]
-}
-export interface PreArrangeDispatchDraftPayload {
-  draftToken: string
-  groups: PreArrangeDispatchDraftGroup[]
-}
-export interface PreArrangeDispatchDraftResult {
-  draftContainerId: string
-  dispatch: DispatchSummaryDto
-}
-export interface DispatchBatchAllocation { planPalletId: string; batchKey: string; customerId: string; sourceKey: string; destinationKey: string; packageCount: number }
-export interface BatchDispatchCandidate { planPalletId: string; palletNo: string; planId: string; planNo: string; customerId: string; sourceStage: string; packageCount: number | null; allocations: DispatchBatchAllocation[]; blockReasons: string[] }
-export interface BatchDispatchCandidates { batchKey: string; version: number; candidates: BatchDispatchCandidate[]; blockReasons: string[] }
-export async function getBatchDispatchCandidates(batchKey: string) {
-  return unwrapApiResponse(await http.get<ApiEnvelope<BatchDispatchCandidates>, ApiEnvelope<BatchDispatchCandidates>>(`/platform/v1/last-leg/appointment-planning/batches/${encodeURIComponent(batchKey)}/dispatch-candidates`))
-}
-
-export interface DispatchBatchReference { batchKey: string; batchNo: string | null; customerId: string; sources: Array<{ sourceKey: string; destinationKey: string; packageCount: number }> }
-export interface DispatchSummaryDto {
-  actions?: DispatchActions
-  appointmentBatches: DispatchBatchReference[]
-  workflow?: DispatchWorkflow | null
-  id: string
-  dispatchNo: string
-  vehiclePlate?: string | null
-  driverName?: string | null
-  driverPhone?: string | null
-  carrierName?: string | null
-  orderNos?: string | null
-  route?: string | null
-  overseasWarehouseId?: string | null
-  overseasWarehouseName?: string | null
-  departAt?: string | null
-  fbaAppointmentNo?: string | null
-  fbaAppointmentStatus?: string | null
-  vehicleAppointmentStatus?: string | null
-  estimatedArrivalAt?: string | null
-  status?: string | null
-  itemCount?: number | null
-  palletCount?: number | null
-  packageCount?: number | null
-  pickedPackageCount?: number | null
-  shippedPackageCount?: number | null
-  remainingPackageCount?: number | null
-  partialCompletionReason?: string | null
-  createdAt?: string | null
-  items?: DispatchItemDto[]
-  bolLines?: DispatchBolLineDto[]
-}
-
-export interface DispatchBolLineDto {
-  containerNo?: string | null
-  palletNo?: string | null
-  fbaWarehouseCode?: string | null
-  destinationWarehouseName?: string | null
-  warehouseNo?: string | null
-  fbaShipmentId?: string | null
-  poReferenceNo?: string | null
-  packageCount: number
-}
-
-export interface UpdateDispatchPayload {
-  vehiclePlate?: string | null
-  driverName?: string | null
-  driverPhone?: string | null
-  carrierName?: string | null
-  departAt?: string | null
-  fbaAppointmentNo?: string | null
-  fbaAppointmentStatus?: string | null
-  vehicleAppointmentStatus?: string | null
-  estimatedArrivalAt?: string | null
-}
-
-export interface DispatchItemDto {
-  id: string
-  planPalletId: string
-  warehousePalletId?: string | null
-  palletNo?: string | null
-  overseasWarehouseId?: string | null
-  overseasWarehouseName?: string | null
-  orderNo?: string | null
-  orderRefs?: string | null
-  inboundCode?: string | null
-  destinationWarehouseCode?: string | null
-  destinationWarehouseName?: string | null
-  fbaWarehouseCode?: string | null
-  packageCount?: number | null
-  grossWeightKg?: number | null
-  volumeWeightKg?: number | null
-  volumeCbm?: number | null
-  sourceStage?: string | null
-}
+const base = '/platform/v1/last-leg/dispatches'
+const path = (dispatchNo: string) => `${base}/${encodeURIComponent(dispatchNo)}`
+async function get<T>(url: string) { return unwrapApiResponse(await http.get<ApiEnvelope<T>, ApiEnvelope<T>>(url)) }
+async function post<T>(url: string, body: object) { return unwrapApiResponse(await http.post<ApiEnvelope<T>, ApiEnvelope<T>>(url, body)) }
+const postCommand = (url: string, body: object) => post<CommandResultWire>(url, body).then(normalizeDispatchCommand)
+const postDraft = (url: string, body: object) => post<DispatchDraftWire>(url, body).then(normalizeDispatchDraft)
+function versioned<T extends VersionCommand>(body: T): T { requireVersion(body.recordVersion); return body }
 
 export async function listDispatches(query: DispatchQuery) {
-  const response = await http.get<ApiEnvelope<OverseasPagePayload<DispatchSummaryDto>>, ApiEnvelope<OverseasPagePayload<DispatchSummaryDto>>>(
-    '/platform/v1/last-leg/dispatches',
-    { params: query },
-  )
-  return normalizeOverseasPage(unwrapApiResponse(response))
+  return normalizeDispatchPage(unwrapApiResponse(await http.get<ApiEnvelope<DispatchPageWire>, ApiEnvelope<DispatchPageWire>>(base, { params: query })))
 }
+export const getDispatch = (dispatchNo: string) => get<DispatchDetailWire>(path(dispatchNo)).then(normalizeDispatchDetail)
+export const getDispatchItems = (no: string) => get<DispatchItemsWire>(`${path(no)}/items`).then(normalizeDispatchItems)
+export const getDispatchRoute = (no: string) => get<DispatchRoute>(`${path(no)}/route`)
+export async function reorderDispatchRoute(no: string, body: DispatchRouteCommand) { return normalizeDispatchCommand(unwrapApiResponse(await http.put<ApiEnvelope<CommandResultWire>, ApiEnvelope<CommandResultWire>>(`${path(no)}/route`, versioned(body)))) }
+const evidencePath = (no: string, kind: DispatchEvidenceKind, id?: string) => `${path(no)}/evidence/${kind}${id ? `/${encodeURIComponent(id)}` : ''}`
+export async function uploadDispatchEvidence(no: string, kind: DispatchEvidenceKind, file: File) { const form = new FormData(); form.append('file', file); return post<DispatchEvidenceFileWire>(evidencePath(no, kind), form).then(normalizeEvidenceFile) }
+export const getDispatchEvidence = (no: string, kind: DispatchEvidenceKind, id: string) => get<DispatchEvidenceFileWire>(evidencePath(no, kind, id)).then(normalizeEvidenceFile)
+export const getDispatchEvidenceContent = (no: string, kind: DispatchEvidenceKind, id: string) => http.get<Blob, Blob>(`${evidencePath(no, kind, id)}/content`, { responseType: 'blob' })
+export const getDispatchLoading = (dispatchNo: string) => get<LoadingPreviewWire>(`${path(dispatchNo)}/loading`).then(normalizeLoadingPreview)
+export const getDispatchCommand = (dispatchNo: string, key: string) => get<CommandResultWire>(`${path(dispatchNo)}/commands/${encodeURIComponent(key)}`).then(normalizeDispatchCommand)
+export const createDispatch = (body: CreateDispatch) => { requireBatchVersions(body.batchAllocations); return postCommand(base, body) }
+export async function updateDispatch(dispatchNo: string, body: UpdateDispatch) {
+  versioned(body)
+  if (body.vehicleAppointment) requireVersion(body.vehicleAppointment.recordVersion)
+  return normalizeDispatchCommand(unwrapApiResponse(await http.put<ApiEnvelope<CommandResultWire>, ApiEnvelope<CommandResultWire>>(path(dispatchNo), body)))
+}
+export const addDispatchCargo = (no: string, body: AddCargo) => { versioned(body); requireBatchVersions(body.batchAllocations); return postCommand(`${path(no)}/items`, body) }
+export const removeDispatchItem = (no: string, itemId: string, body: ReasonCommand) => postCommand(`${path(no)}/items/${encodeURIComponent(itemId)}/remove`, versioned(body))
+export const cancelDispatch = (no: string, body: ReasonCommand) => postCommand(`${path(no)}/cancel`, versioned(body))
+export const submitDispatchReview = (no: string, body: VersionCommand & { remark: string | null }) => postCommand(`${path(no)}/submit-review`, versioned(body))
+export const reviewDispatch = (no: string, body: ReviewCommand) => postCommand(`${path(no)}/dispatch-review`, versioned(body))
+export const reviewDispatchLoading = (no: string, body: ReviewCommand) => postCommand(`${path(no)}/loading-review`, versioned(body))
+export const returnDispatchToReview = (no: string, body: ReasonCommand) => postCommand(`${path(no)}/return-to-review`, versioned(body))
+export const completeDispatchLoading = (no: string, body: LoadingComplete) => postCommand(`${path(no)}/loading-complete`, versioned(body))
+export const departDispatch = (no: string, body: VersionCommand & { remark: string | null }) => postCommand(`${path(no)}/depart`, versioned(body))
+export const getDispatchArrangement = (no: string) => get<ArrangementPreviewWire>(`${path(no)}/delivery-arrangement`).then(normalizeArrangementPreview)
+export const transferDispatchToDelivery = (no: string, body: ArrangeDelivery) => postCommand(`${path(no)}/transfer-delivery`, versioned(body))
+export const getDispatchBolPdf = (no: string) => http.get<Blob, Blob>(`${path(no)}/prints/bol`, { responseType: 'blob' })
 
-export async function getDispatch(dispatchNo: string) {
-  const response = await http.get<ApiEnvelope<DispatchSummaryDto>, ApiEnvelope<DispatchSummaryDto>>(
-    `/platform/v1/last-leg/dispatches/${encodeURIComponent(dispatchNo)}`,
-  )
-  return unwrapApiResponse(response)
+export async function listDispatchCandidates(query: CandidateQuery) {
+  return normalizeCandidateList(unwrapApiResponse(await http.get<ApiEnvelope<CandidateListWire>, ApiEnvelope<CandidateListWire>>(`${base}/candidates`, { params: query, paramsSerializer: { indexes: null } })))
 }
+export const listDispatchDrafts = () => get<DispatchDraftWire[]>(`${base}/drafts`).then(values => values.map(normalizeDispatchDraft))
+export const createDispatchDraft = (body: { idempotencyKey: string; warehouseId: string }) => postDraft(`${base}/drafts`, body)
+export const createDispatchDraftContainer = (body: VersionCommand & { draftToken: string; capacity: number }) => postDraft(`${base}/drafts/containers`, versioned(body))
+export const saveDispatchDraftSnapshot = (body: VersionCommand & { draftToken: string; planIds: string[]; containers: DraftContainer[] }) => postDraft(`${base}/drafts/snapshot`, versioned(body))
+export const lockDispatchDraftPallet = (body: DraftSelection) => postDraft(`${base}/draft-locks/lock`, versioned(body))
+export const unlockDispatchDraftPallet = (body: DraftSelection) => postDraft(`${base}/draft-locks/unlock`, versioned(body))
+export const releaseDispatchDraft = (body: VersionCommand & { draftToken: string }) => postDraft(`${base}/draft-locks/release`, versioned(body))
+export async function deleteDispatchDraftContainer(token: string, id: string, body: ReasonCommand) {
+  return normalizeDispatchDraft(unwrapApiResponse(await http.delete<ApiEnvelope<DispatchDraftWire>, ApiEnvelope<DispatchDraftWire>>(`${base}/drafts/${encodeURIComponent(token)}/containers/${encodeURIComponent(id)}`, { data: versioned(body) })))
+}
+export const convertDispatchDraft = (body: ConvertDraft) => { versioned(body); requireBatchVersions(body.groups.flatMap(group => group.dispatch.batchAllocations)); return post<ConvertedDraftWire>(`${base}/drafts/pre-arrange`, body).then(normalizeConvertedDraft) }
 
-export async function getDispatchBolPdf(dispatchNo: string) {
-  return http.get<Blob, Blob>(
-    `/platform/v1/last-leg/dispatches/${encodeURIComponent(dispatchNo)}/prints/bol`,
-    { responseType: 'blob' },
-  )
-}
-
-export async function updateDispatch(dispatchNo: string, payload: UpdateDispatchPayload) {
-  const response = await http.put<ApiEnvelope<DispatchSummaryDto>, ApiEnvelope<DispatchSummaryDto>>(
-    `/platform/v1/last-leg/dispatches/${encodeURIComponent(dispatchNo)}`, payload,
-  )
-  return unwrapApiResponse(response)
-}
-
-export async function cancelDispatch(dispatchNo: string) {
-  const response = await http.delete<ApiEnvelope<null>, ApiEnvelope<null>>(
-    `/platform/v1/last-leg/dispatches/${encodeURIComponent(dispatchNo)}`,
-  )
-  return unwrapApiResponse(response)
-}
-
-export async function removeDispatchItem(dispatchNo: string, itemId: string) {
-  const response = await http.delete<ApiEnvelope<DispatchSummaryDto>, ApiEnvelope<DispatchSummaryDto>>(
-    `/platform/v1/last-leg/dispatches/${encodeURIComponent(dispatchNo)}/items/${encodeURIComponent(itemId)}`,
-  )
-  return unwrapApiResponse(response)
-}
-
-export async function listDispatchCandidates(query: DispatchCandidateQuery) {
-  const response = await http.get<ApiEnvelope<DispatchPalletCandidateDto[]>, ApiEnvelope<DispatchPalletCandidateDto[]>>(
-    '/platform/v1/last-leg/dispatches/candidates',
-    { params: query },
-  )
-  return unwrapApiResponse(response)
-}
-
-export async function preArrangeDispatch(payload: PreArrangeDispatchPayload) {
-  const response = await http.post<ApiEnvelope<DispatchSummaryDto>, ApiEnvelope<DispatchSummaryDto>>(
-    '/platform/v1/last-leg/dispatches/pre-arrange',
-    payload,
-  )
-  return unwrapApiResponse(response)
-}
-
-export async function preArrangeDraftDispatch(payload: PreArrangeDispatchDraftPayload) {
-  const response = await http.post<ApiEnvelope<PreArrangeDispatchDraftResult[]>, ApiEnvelope<PreArrangeDispatchDraftResult[]>>(
-    '/platform/v1/last-leg/dispatches/drafts/pre-arrange', payload,
-  )
-  return unwrapApiResponse(response)
-}
-
-function draftSource(selection: string) {
-  return selection.startsWith('RETURN:')
-    ? { sourceType: 'RETURN_RECEIPT', returnReceiptId: selection.slice(7) }
-    : { planPalletId: selection }
-}
-export async function lockDispatchDraftPallet(selection: string, draftToken: string, draftContainerId?: string) {
-  const response = await http.post<ApiEnvelope<null>, ApiEnvelope<null>>(
-    '/platform/v1/last-leg/dispatches/draft-locks/lock', { ...draftSource(selection), draftToken, ...(draftContainerId ? { draftContainerId } : {}) },
-  )
-  return unwrapApiResponse(response)
-}
-
-export async function listDispatchDrafts() {
-  const response = await http.get<ApiEnvelope<DispatchDraftDto[]>, ApiEnvelope<DispatchDraftDto[]>>('/platform/v1/last-leg/dispatches/drafts')
-  return unwrapApiResponse(response)
-}
-export async function createDispatchDraftContainer(draftToken: string, capacity: number) {
-  const response = await http.post<ApiEnvelope<DispatchDraftContainerDto>, ApiEnvelope<DispatchDraftContainerDto>>('/platform/v1/last-leg/dispatches/drafts/containers', { draftToken, capacity })
-  return unwrapApiResponse(response)
-}
-export async function deleteDispatchDraftContainer(draftToken: string, containerId: string) {
-  const response = await http.delete<ApiEnvelope<null>, ApiEnvelope<null>>(`/platform/v1/last-leg/dispatches/drafts/${encodeURIComponent(draftToken)}/containers/${encodeURIComponent(containerId)}`)
-  return unwrapApiResponse(response)
-}
-
-export async function unlockDispatchDraftPallet(selection: string, draftToken: string) {
-  const response = await http.post<ApiEnvelope<null>, ApiEnvelope<null>>(
-    '/platform/v1/last-leg/dispatches/draft-locks/unlock', { ...draftSource(selection), draftToken },
-  )
-  return unwrapApiResponse(response)
-}
-
-export async function releaseDispatchDraft(draftToken: string) {
-  const response = await http.post<ApiEnvelope<null>, ApiEnvelope<null>>(
-    '/platform/v1/last-leg/dispatches/draft-locks/release', { draftToken },
-  )
-  return unwrapApiResponse(response)
-}
-
-export interface TransferDeliveryItem { deliveryNo: string; deliveryStatus: string; destinationWarehouseId?: string | null; destinationWarehouseCode?: string | null; destinationWarehouseName?: string | null; palletCount: number; packageCount: number }
-export interface TransferDeliveryResult { dispatchNo: string; outboundNo: string; outboundStatus: string; palletCount: number; packageCount: number; deliveries: TransferDeliveryItem[]; replayed: boolean }
-export interface TransferDeliveryPayload {
-  feeCoverageCargoHash?: string
-  feeCoverage?: import('../feeCoverageTypes').FeeCoverageSelection[]
-  externalFreightHash?: string
-  idempotencyKey: string
-  plannedDeliveryAt: string
-  deliveryMethod: string
-  waybillNo?: string
-  carrierName?: string
-  pickupMethod: string
-  loadingType: string
-  vehicleType?: string
-  vehicleSize?: string
-  driverName?: string
-  driverPhone?: string
-  vehiclePlate?: string
-  appointmentAccount?: string
-  sellerName?: string
-  remark?: string
-  fees: Array<{ feeType: string; feeName: string; direction: 'RECEIVABLE' | 'PAYABLE'; currency: 'CNY' | 'USD'; amount: number
-    supplierId?: string; supplierName?: string; supplierCategory?: string; settlementMode?: 'ON_ACCOUNT' | 'DIRECT_PAID'
-    paidAt?: string; paymentMethod?: 'ONLINE' | 'BANK_TRANSFER' | 'CASH' | 'OTHER'; paymentReferenceNo?: string
-    paymentVoucherFileIds?: string[]; chargeableQuantity?: number; quantityUnit?: string; unitPrice?: number
-    periodStart?: string; periodEnd?: string; remark?: string }>
-}
-export async function transferDispatchToDelivery(dispatchNo: string, payload: TransferDeliveryPayload) {
-  const response = await http.post<ApiEnvelope<TransferDeliveryResult>, ApiEnvelope<TransferDeliveryResult>>(
-    `/platform/v1/last-leg/dispatches/${encodeURIComponent(dispatchNo)}/transfer-delivery`, payload,
-  )
-  return unwrapApiResponse(response)
-}
-
-export interface ExternalFreightPreview {
-  snapshotHash: string
-  requiresDeliveryFee: boolean
-  quotes: Array<{ bookingNo: string; recordVersion: string | number; incomingNo: string; inboundCode: string;
-    customerName: string; destinationKey: string; currency: string; amount: number; quantity: number; quantityUnit: string; unitPrice: number }>
-}
-export async function getDispatchExternalFreight(dispatchNo: string): Promise<ExternalFreightPreview> {
-  const response = await http.get<ApiEnvelope<ExternalFreightPreview>, ApiEnvelope<ExternalFreightPreview>>(
-    `/platform/v1/last-leg/dispatches/${encodeURIComponent(dispatchNo)}/external-freight`,
-  )
-  return unwrapApiResponse(response)
-}
-
-export async function getDispatchFeeCoverage(dispatchNo: string): Promise<import('../feeCoverageTypes').FeeCoveragePreview> {
-  const response = await http.get<ApiEnvelope<import('../feeCoverageTypes').FeeCoveragePreview>, ApiEnvelope<import('../feeCoverageTypes').FeeCoveragePreview>>(
-    `/platform/v1/last-leg/dispatches/${encodeURIComponent(dispatchNo)}/fee-coverage`,
-  )
-  const data = unwrapApiResponse(response)
-  return { ...data, cargo: data.cargo.map(row => ({ ...row, dispatchItemId: String(row.dispatchItemId), warehousePalletId: String(row.warehousePalletId), orderId: row.orderId == null ? null : String(row.orderId), sourceInboundId: row.sourceInboundId == null ? null : String(row.sourceInboundId), packages: Number(row.packages) })), feeSources: data.feeSources.map(row => ({ ...row, financeFeeId: String(row.financeFeeId), sourceFeeId: String(row.sourceFeeId), customerId: String(row.customerId), sourceInboundId: String(row.sourceInboundId), sourceVersion: Number(row.sourceVersion), amount: Number(row.amount) })) }
-}
+// Existing appointment-domain provider; its consumer handoff remains with the coordinator.
+export interface BatchDispatchCandidate { planPalletId: string; palletNo: string; planId: string; planNo: string; customerId: string; sourceStage: string; packageCount: number | null; allocations: DispatchBatchAllocation[]; blockReasons: string[] }
+export interface BatchDispatchCandidates { batchKey: string; version: number; candidates: BatchDispatchCandidate[]; blockReasons: string[] }
+export const getBatchDispatchCandidates = (key: string) => get<BatchDispatchCandidates>(`/platform/v1/last-leg/appointment-planning/batches/${encodeURIComponent(key)}/dispatch-candidates`).then(value => { requireBatchVersions(value.candidates.flatMap(row => row.allocations)); return value })

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

@@ -0,0 +1,35 @@
+import ElementPlus from 'element-plus'
+import { mount } from '@vue/test-utils'
+import { expect, it } from 'vitest'
+import DispatchArrangeFields from './DispatchArrangeFields.vue'
+import type { ArrangeGroup, CargoLine, PreviewGroup } from '../dispatchContracts'
+import { destination } from '../dispatchTestFixtures'
+const cargo = (sourceKey: string, customerId = 'C1'): CargoLine => ({ sourceKey, customerId, inboundCode: `IN-${sourceKey}` }) as CargoLine
+function values() {
+  const preview: PreviewGroup = { groupKey: 'group-1', customerId: 'C1', customerName: '客户甲', destination: destination(), groupCargoHash: 'group-cargo', cargo: [cargo('A'), cargo('B')], externalFreightHash: 'external-hash', externalQuotes: [], feeCoverageCargoHash: 'coverage-hash', feeSources: [{ financeFeeId: 'fee-1', customerId: 'C1', currency: 'USD', amount: 100, sourceVersion: 2, sourceHash: 'fee-hash', status: 'ACTIVE', services: ['DELIVERY_FEE', 'LOADING_FEE'], sourceKeys: ['A'] }], requiredServices: ['DELIVERY_FEE'], blockReasons: [] }
+  const group: ArrangeGroup = { groupKey: 'group-1', groupCargoHash: 'group-cargo', plannedDeliveryAt: '', deliveryMethod: '', waybillNo: null, carrierName: null, pickupMethod: '', loadingType: 'PALLET', vehicleType: null, vehicleSize: null, appointmentAccount: null, sellerName: null, remark: null, externalFreightHash: 'external-hash', feeCoverageCargoHash: 'coverage-hash', feeCoverage: [], fees: ['DELIVERY_FEE', 'LOADING_FEE', 'APPOINTMENT_FEE'].map(feeType => ({ feeType, feeName: feeType, direction: 'RECEIVABLE', currency: 'USD', amount: null })) }
+  return { preview, group }
+}
+it('requires explicit per-service coverage and preserves uncovered cargo instead of treating a partial fee as full coverage', async () => {
+  const { preview, group } = values()
+  const wrapper = mount(DispatchArrangeFields, { props: { modelValue: [group], preview: [preview], disabled: false }, global: { plugins: [ElementPlus] } })
+  const covered = (wrapper.vm as unknown as { covered(index: number, preview: PreviewGroup, service: string): boolean }).covered
+  expect(covered(0, preview, 'DELIVERY_FEE')).toBe(false)
+  await wrapper.get('input[type="checkbox"]').setValue(true)
+  expect(group.feeCoverage).toEqual([{ financeFeeId: 'fee-1', sourceVersion: 2, sourceHash: 'fee-hash', services: ['DELIVERY_FEE'] }])
+  expect(covered(0, preview, 'DELIVERY_FEE')).toBe(false)
+  preview.feeSources[0]!.sourceKeys.push('B'); expect(covered(0, preview, 'DELIVERY_FEE')).toBe(true)
+  expect(covered(0, preview, 'LOADING_FEE')).toBe(false)
+  preview.feeSources[0]!.customerId = 'C2'; expect(covered(0, preview, 'DELIVERY_FEE')).toBe(false); wrapper.unmount()
+})
+it('matches external quotes to the original customer and inbound source and shows only applicable additional fees', async () => {
+  const { preview, group } = values(); preview.cargo = [cargo('A')]
+  preview.externalQuotes = [{ customerId: 'C2', groupKey: 'group-1', bookingNo: 'BOOK-1', inboundCode: 'IN-A', currency: 'USD', amount: 100, sourceHash: 'external-source' }]
+  const wrapper = mount(DispatchArrangeFields, { props: { modelValue: [group], preview: [preview], disabled: false }, global: { plugins: [ElementPlus] } })
+  const state = wrapper.vm as unknown as { covered(index: number, preview: PreviewGroup, service: string): boolean }
+  expect(state.covered(0, preview, 'DELIVERY_FEE')).toBe(false)
+  expect(wrapper.findAll('.el-input-number')).toHaveLength(1)
+  preview.externalQuotes[0]!.customerId = 'C1'; expect(state.covered(0, preview, 'DELIVERY_FEE')).toBe(true)
+  group.loadingType = 'FLOOR'; group.appointmentAccount = 'BUY_APPOINTMENT'; await wrapper.setProps({ modelValue: [{ ...group }] })
+  expect(wrapper.findAll('.el-input-number')).toHaveLength(2); expect(wrapper.text()).toContain('卖家姓名'); wrapper.unmount()
+})

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

@@ -0,0 +1,54 @@
+<script setup lang="ts">
+import type { ArrangeGroup, PreviewGroup } from '../dispatchContracts'
+const groups = defineModel<ArrangeGroup[]>({ required: true })
+defineProps<{ preview: PreviewGroup[]; disabled: boolean }>()
+const serviceLabels: Record<string, string> = { DELIVERY_FEE: '派送费', LOADING_FEE: '装车费', APPOINTMENT_FEE: '买约费' }
+function setCoverage(index: number, fee: PreviewGroup['feeSources'][number], service: string, checked: unknown) {
+  const group = groups.value[index]; if (!group) return
+  let selection = group.feeCoverage.find(row => row.financeFeeId === fee.financeFeeId)
+  if (!selection && checked === true) { selection = { financeFeeId: fee.financeFeeId, sourceVersion: fee.sourceVersion, sourceHash: fee.sourceHash, services: [] }; group.feeCoverage.push(selection) }
+  if (!selection) return
+  selection.services = checked === true ? [...new Set([...selection.services, service])] : selection.services.filter(value => value !== service)
+  group.feeCoverage = group.feeCoverage.filter(row => row.services.length)
+}
+function covered(index: number, preview: PreviewGroup, service: string) {
+  if (!preview.cargo.length) return false
+  const selections = groups.value[index]?.feeCoverage || []
+  return preview.cargo.every(cargo => service === 'DELIVERY_FEE' && preview.externalQuotes.some(quote => quote.customerId === cargo.customerId && quote.inboundCode === cargo.inboundCode)
+    || preview.feeSources.some(fee => fee.customerId === cargo.customerId && fee.sourceKeys.includes(cargo.sourceKey) && selections.some(selection => selection.financeFeeId === fee.financeFeeId && selection.services.includes(service))))
+}
+function required(index: number, preview: PreviewGroup, service: string) {
+  const group = groups.value[index]
+  return preview.requiredServices.includes(service)
+    || service === 'LOADING_FEE' && ['FLOOR', 'MIXED'].includes(group?.loadingType || '')
+    || service === 'APPOINTMENT_FEE' && group?.appointmentAccount === 'BUY_APPOINTMENT'
+}
+defineExpose({ covered })
+</script>
+<template>
+  <section v-for="(previewGroup, index) in preview" :key="previewGroup.groupKey" class="arrange-group">
+    <template v-if="groups[index]">
+      <h3>{{ previewGroup.customerName || '—' }} · {{ previewGroup.destination.warehouseCode || previewGroup.destination.warehouseName || previewGroup.destination.address || '—' }}</h3>
+      <p v-for="reason in previewGroup.blockReasons" :key="reason" role="alert">{{ reason }}</p>
+      <div class="arrange-grid">
+        <el-form-item label="预计派送时间" required><el-date-picker v-model="groups[index]!.plannedDeliveryAt" :disabled="disabled" type="datetime" value-format="YYYY-MM-DDTHH:mm:ssZ" placeholder="请选择派送时间" /></el-form-item>
+        <el-form-item label="派送方式" required><el-select v-model="groups[index]!.deliveryMethod" :disabled="disabled" placeholder="请选择"><el-option label="卡派打托" value="TRUCK_PALLET" /><el-option label="卡派地板" value="TRUCK_FLOOR" /><el-option label="FBA自提" value="FBA_PICKUP" /><el-option label="客户自提" value="CUSTOMER_PICKUP" /><el-option label="快递" value="EXPRESS" /><el-option label="外配" value="OUTSOURCED" /><el-option label="专车直送" value="DEDICATED_TRUCK" /><el-option label="零担派送" value="LTL" /></el-select></el-form-item>
+        <el-form-item label="提货方式" required><el-select v-model="groups[index]!.pickupMethod" :disabled="disabled" placeholder="请选择"><el-option label="一提一卸" value="ONE_PICKUP_ONE_DROP" /><el-option label="一提多卸" value="ONE_PICKUP_MULTI_DROP" /><el-option label="多提一卸" value="MULTI_PICKUP_ONE_DROP" /><el-option label="多提多卸" value="MULTI_PICKUP_MULTI_DROP" /><el-option label="仓库自提" value="WAREHOUSE_PICKUP" /></el-select></el-form-item>
+        <el-form-item label="装车类型" required><el-select v-model="groups[index]!.loadingType" :disabled="disabled" placeholder="请选择"><el-option label="托盘" value="PALLET" /><el-option label="地板" value="FLOOR" /><el-option label="混装" value="MIXED" /></el-select></el-form-item>
+        <el-form-item label="承运商"><el-input v-model="groups[index]!.carrierName" :disabled="disabled" placeholder="请输入承运商（选填）" /></el-form-item><el-form-item label="运单号"><el-input v-model="groups[index]!.waybillNo" :disabled="disabled" placeholder="请输入运单号（选填）" /></el-form-item>
+        <el-form-item label="车型"><el-input v-model="groups[index]!.vehicleType" :disabled="disabled" placeholder="请输入本组派送车型（选填）" /></el-form-item><el-form-item label="车辆尺寸"><el-input v-model="groups[index]!.vehicleSize" :disabled="disabled" placeholder="请输入车辆尺寸（选填）" /></el-form-item>
+        <el-form-item label="预约账号"><el-select v-model="groups[index]!.appointmentAccount" :disabled="disabled" clearable placeholder="请选择"><el-option label="自有账号" value="SELF" /><el-option label="买约" value="BUY_APPOINTMENT" /></el-select></el-form-item><el-form-item v-if="groups[index]!.appointmentAccount === 'BUY_APPOINTMENT'" label="卖家姓名" required><el-input v-model="groups[index]!.sellerName" :disabled="disabled" placeholder="请输入卖家姓名" /></el-form-item><el-form-item label="备注"><el-input v-model="groups[index]!.remark" :disabled="disabled" placeholder="请输入本组派送备注（选填）" /></el-form-item>
+      </div>
+      <el-table :data="previewGroup.cargo" border max-height="240"><el-table-column prop="orderNo" label="来源订单" min-width="150" /><el-table-column prop="inboundCode" label="入仓码" min-width="150" /><el-table-column prop="palletNo" label="实物托盘码" min-width="150" /><el-table-column prop="cartonMark" label="来源箱唛" min-width="150" /><el-table-column prop="packages" label="本次箱数" width="100" /></el-table>
+      <p v-for="quote in previewGroup.externalQuotes" :key="quote.bookingNo">{{ quote.bookingNo }} · {{ quote.inboundCode }}：{{ quote.currency }} {{ quote.amount }}（外接约定运费）</p>
+      <h4>原费用覆盖</h4><p v-if="!previewGroup.feeSources.length">暂无可引用原费用。</p>
+      <div v-for="fee in previewGroup.feeSources" :key="fee.financeFeeId"><span>{{ fee.currency }} {{ fee.amount }} · {{ fee.status }}</span><el-checkbox v-for="service in fee.services" :key="service" :disabled="disabled" :model-value="groups[index]!.feeCoverage.some(row => row.financeFeeId === fee.financeFeeId && row.services.includes(service))" @update:model-value="setCoverage(index, fee, service, $event)">已包含{{ serviceLabels[service] || '服务费用' }}</el-checkbox></div>
+      <h4>本组新增费用</h4><div class="arrange-grid"><template v-for="fee in groups[index]!.fees.filter(item => required(index, previewGroup, item.feeType))" :key="fee.feeType"><el-form-item v-if="!covered(index, previewGroup, fee.feeType)" :label="`${serviceLabels[fee.feeType] || fee.feeName}（未覆盖部分）`" required><el-input-number v-model="fee.amount" :disabled="disabled" :min="0.01" :precision="2" placeholder="请输入实际新增应收" /><el-select v-model="fee.currency" :disabled="disabled" placeholder="币种"><el-option label="USD" value="USD" /><el-option label="CNY" value="CNY" /></el-select></el-form-item><p v-else>本组{{ serviceLabels[fee.feeType] || fee.feeName }}已全部覆盖，不重复登记。</p></template></div>
+    </template>
+  </section>
+</template>
+<style scoped>
+.arrange-group { padding-bottom: var(--admin-space-5); border-bottom: 1px solid var(--cc-border); }
+.arrange-grid { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 0 var(--admin-space-5); }
+.arrange-grid :deep(.el-select), .arrange-grid :deep(.el-date-editor), .arrange-grid :deep(.el-input-number) { width: 100%; }
+</style>

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

@@ -0,0 +1,70 @@
+import { flushPromises, mount } from '@vue/test-utils'
+import { beforeEach, expect, it, vi } from 'vitest'
+import { ApiResponseError, http } from '@/shared/api/http'
+import { parseApiJsonResponse } from '@chongchong/shared'
+import ApiErrorMeta from '@/shared/components/ApiErrorMeta.vue'
+import DispatchEvidenceFiles from './DispatchEvidenceFiles.vue'
+import * as api from '../api/dispatches'
+import type { DispatchEvidenceFile } from '../dispatchContracts'
+vi.mock('../api/dispatches', () => ({ getDispatchEvidence: vi.fn(), getDispatchEvidenceContent: vi.fn(), uploadDispatchEvidence: vi.fn() }))
+const metadata = (fileId = '301', contentType = 'image/png'): DispatchEvidenceFile => ({ fileId, fileName: contentType === 'application/pdf' ? '本车证照.pdf' : '本车证据.png', contentType, sizeBytes: 3 })
+const options = { props: { modelValue: ['301'], dispatchNo: 'PC/1', kind: 'VEHICLE' as const }, global: { stubs: { ElButton: { props: ['disabled'], template: '<button :disabled="disabled"><slot /></button>' }, AppDialog: { name: 'AppDialog', props: ['modelValue', 'title'], template: '<section v-if="modelValue" role="dialog"><slot /><button @click="$emit(\'update:modelValue\', false)">关闭预览</button></section>' } } } }
+const button = (wrapper: ReturnType<typeof mount>, label: string) => wrapper.findAll('button').find(value => value.text() === label)!
+async function selectFile(wrapper: ReturnType<typeof mount>, file: File) { const input = wrapper.get('input[type="file"]'); Object.defineProperty(input.element, 'files', { configurable: true, value: [file] }); await input.trigger('change'); await flushPromises() }
+beforeEach(() => { vi.resetAllMocks(); vi.mocked(api.getDispatchEvidence).mockResolvedValue(metadata()); vi.mocked(api.uploadDispatchEvidence).mockResolvedValue(metadata('302')); vi.mocked(api.getDispatchEvidenceContent).mockResolvedValue(new Blob(['png'], { type: 'image/png' })); URL.createObjectURL = vi.fn().mockReturnValue('blob:authenticated'); URL.revokeObjectURL = vi.fn() })
+it('previews and replaces real string-size metadata through the JSON parser and API boundary', async () => {
+  const actual = await vi.importActual<typeof import('../api/dispatches')>('../api/dispatches')
+  const envelope = (fileId: string) => parseApiJsonResponse(JSON.stringify({ code: '200', data: { ...metadata(fileId), sizeBytes: '3' } }))
+  const get = vi.spyOn(http, 'get').mockResolvedValue(envelope('9007199254740993'))
+  const post = vi.spyOn(http, 'post').mockResolvedValue(envelope('9007199254740994'))
+  vi.mocked(api.getDispatchEvidence).mockImplementation(actual.getDispatchEvidence); vi.mocked(api.uploadDispatchEvidence).mockImplementation(actual.uploadDispatchEvidence)
+  const wrapper = mount(DispatchEvidenceFiles, { ...options, props: { ...options.props, modelValue: ['9007199254740993'] } })
+  try {
+    await flushPromises(); expect(wrapper.text()).toContain('本车证据.png')
+    await button(wrapper, '预览').trigger('click'); await flushPromises(); expect(wrapper.get('img').attributes('src')).toBe('blob:authenticated')
+    await button(wrapper, '关闭预览').trigger('click'); await button(wrapper, '替换').trigger('click'); await selectFile(wrapper, new File(['png'], 'new.png', { type: 'image/png' }))
+    expect(wrapper.emitted('update:modelValue')?.at(-1)).toEqual([['9007199254740994']]); expect(post).toHaveBeenCalledOnce()
+  } finally { wrapper.unmount(); get.mockRestore(); post.mockRestore() }
+})
+it('reads owned metadata without displaying IDs or downloading content until explicitly previewed, including read-only mode', async () => {
+  const wrapper = mount(DispatchEvidenceFiles, { ...options, props: { ...options.props, readonly: true } }); await flushPromises()
+  expect(api.getDispatchEvidence).toHaveBeenCalledWith('PC/1', 'VEHICLE', '301'); expect(api.getDispatchEvidenceContent).not.toHaveBeenCalled(); expect(wrapper.text()).toContain('本车证据.png'); expect(wrapper.text()).not.toContain('301'); expect(wrapper.find('input').exists()).toBe(false)
+  await button(wrapper, '预览').trigger('click'); await flushPromises(); expect(api.getDispatchEvidenceContent).toHaveBeenCalledWith('PC/1', 'VEHICLE', '301'); expect(wrapper.get('img').attributes('src')).toBe('blob:authenticated')
+  await button(wrapper, '关闭预览').trigger('click'); expect(URL.revokeObjectURL).toHaveBeenCalledWith('blob:authenticated'); wrapper.unmount()
+})
+it('retains original references when metadata or replacement upload fails and preserves request diagnostics', async () => {
+  vi.mocked(api.getDispatchEvidence).mockRejectedValueOnce(new ApiResponseError('Forbidden', 'A0403', 403, undefined, 'request-1', 'trace-1'))
+  const failed = mount(DispatchEvidenceFiles, options); await flushPromises(); expect(failed.emitted('update:modelValue')).toBeUndefined(); expect(failed.getComponent(ApiErrorMeta).props('details')).toMatchObject({ requestId: 'request-1', traceId: 'trace-1' }); failed.unmount()
+  const wrapper = mount(DispatchEvidenceFiles, options); await flushPromises(); vi.mocked(api.uploadDispatchEvidence).mockRejectedValueOnce(new Error('unknown upload'))
+  await button(wrapper, '替换').trigger('click'); await selectFile(wrapper, new File(['png'], 'new.png', { type: 'image/png' })); expect(wrapper.emitted('update:modelValue')).toBeUndefined(); expect(wrapper.text()).toContain('原附件引用保留'); wrapper.unmount()
+})
+it('replaces the selected reference only after a valid successful upload and rejects unsupported types locally', async () => {
+  const wrapper = mount(DispatchEvidenceFiles, options); await flushPromises(); await selectFile(wrapper, new File(['exe'], 'file.exe', { type: 'application/octet-stream' })); expect(api.uploadDispatchEvidence).not.toHaveBeenCalled(); expect(wrapper.text()).toContain('10MiB以内')
+  await button(wrapper, '替换').trigger('click'); const file = new File(['png'], 'new.png', { type: 'image/png' }); await selectFile(wrapper, file)
+  expect(api.uploadDispatchEvidence).toHaveBeenCalledWith('PC/1', 'VEHICLE', file); expect(wrapper.emitted('update:modelValue')?.at(-1)).toEqual([['302']]); expect(wrapper.emitted('busy')?.slice(-2)).toEqual([[true], [false]]); wrapper.unmount()
+})
+it('ignores a late upload after switching dispatches instead of binding the file to the new vehicle', async () => {
+  let resolve!: (value: DispatchEvidenceFile) => void; vi.mocked(api.uploadDispatchEvidence).mockImplementationOnce(() => new Promise(done => { resolve = done }))
+  const wrapper = mount(DispatchEvidenceFiles, options); await flushPromises(); await button(wrapper, '替换').trigger('click'); await selectFile(wrapper, new File(['png'], 'new.png', { type: 'image/png' }))
+  await wrapper.setProps({ dispatchNo: 'PC/2' }); resolve(metadata('302')); await flushPromises(); expect(wrapper.emitted('update:modelValue')).toBeUndefined(); wrapper.unmount()
+})
+it('does not turn business-error JSON into an image and retains diagnostic evidence', async () => {
+  vi.mocked(api.getDispatchEvidenceContent).mockResolvedValueOnce({ type: 'application/json', size: 100, text: async () => JSON.stringify({ code: 'A0403', message: 'Forbidden', requestId: 'request-content', traceId: 'trace-content' }) } as Blob)
+  const wrapper = mount(DispatchEvidenceFiles, options); await flushPromises(); await button(wrapper, '预览').trigger('click'); await flushPromises(); expect(URL.createObjectURL).not.toHaveBeenCalled(); expect(wrapper.find('img').exists()).toBe(false); expect(wrapper.getComponent(ApiErrorMeta).props('details')).toMatchObject({ requestId: 'request-content', traceId: 'trace-content' }); wrapper.unmount()
+})
+it('ignores content arriving after preview close and cleans up object URLs on unmount', async () => {
+  let resolve!: (value: Blob) => void; vi.mocked(api.getDispatchEvidenceContent).mockImplementationOnce(() => new Promise(done => { resolve = done }))
+  const wrapper = mount(DispatchEvidenceFiles, options); await flushPromises(); await button(wrapper, '预览').trigger('click'); await button(wrapper, '关闭预览').trigger('click'); resolve(new Blob(['png'], { type: 'image/png' })); await flushPromises(); expect(URL.createObjectURL).not.toHaveBeenCalled()
+  await button(wrapper, '预览').trigger('click'); await flushPromises(); expect(URL.createObjectURL).toHaveBeenCalledTimes(1); wrapper.unmount(); expect(URL.revokeObjectURL).toHaveBeenCalledWith('blob:authenticated')
+})
+it('opens PDF in a user-requested window using owned blob content and never an anonymous URL', async () => {
+  vi.mocked(api.getDispatchEvidence).mockResolvedValueOnce(metadata('301', 'application/pdf')); vi.mocked(api.getDispatchEvidenceContent).mockResolvedValueOnce(new Blob(['pdf'], { type: 'application/pdf' }))
+  const popup = { location: { href: '' }, close: vi.fn() }; const open = vi.spyOn(window, 'open').mockReturnValueOnce(popup as unknown as Window)
+  const wrapper = mount(DispatchEvidenceFiles, options); await flushPromises(); await button(wrapper, '预览').trigger('click'); await flushPromises(); expect(open).toHaveBeenCalledWith('', '_blank'); expect(popup.location.href).toBe('blob:authenticated'); expect(wrapper.find('img').exists()).toBe(false); wrapper.unmount(); expect(URL.revokeObjectURL).toHaveBeenCalledWith('blob:authenticated'); open.mockRestore()
+})
+it('rejects mismatched file identity and a blocked PDF popup without fetching content', async () => {
+  vi.mocked(api.getDispatchEvidence).mockResolvedValueOnce(metadata('wrong-file'))
+  const mismatch = mount(DispatchEvidenceFiles, options); await flushPromises(); expect(button(mismatch, '预览').attributes('disabled')).toBeDefined(); expect(api.getDispatchEvidenceContent).not.toHaveBeenCalled(); mismatch.unmount()
+  vi.mocked(api.getDispatchEvidence).mockResolvedValueOnce(metadata('301', 'application/pdf')); const open = vi.spyOn(window, 'open').mockReturnValueOnce(null)
+  const blocked = mount(DispatchEvidenceFiles, options); await flushPromises(); await button(blocked, '预览').trigger('click'); await flushPromises(); expect(blocked.text()).toContain('请允许本站打开PDF预览窗口'); expect(api.getDispatchEvidenceContent).not.toHaveBeenCalled(); blocked.unmount(); open.mockRestore()
+})

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

@@ -0,0 +1,85 @@
+<script setup lang="ts">
+import { computed, onBeforeUnmount, ref, watch } from 'vue'
+import AppDialog from '@/shared/components/AppDialog.vue'
+import ApiErrorMeta from '@/shared/components/ApiErrorMeta.vue'
+import { ApiResponseError, getApiErrorDetails, type ApiErrorDetails } from '@/shared/api/http'
+import { getDispatchEvidence, getDispatchEvidenceContent, uploadDispatchEvidence } from '../api/dispatches'
+import { DispatchInputError, type DispatchEvidenceFile, type DispatchEvidenceKind } from '../dispatchContracts'
+const props = defineProps<{ dispatchNo: string; kind: DispatchEvidenceKind; disabled?: boolean; readonly?: boolean }>()
+const ids = defineModel<string[]>({ required: true })
+const emit = defineEmits<{ busy: [value: boolean] }>()
+const metadata = ref<Record<string, DispatchEvidenceFile>>({}), error = ref<ApiErrorDetails | null>(null), uploading = ref(false), input = ref<HTMLInputElement | null>(null)
+const imageOpen = ref(false), imageUrl = ref(''), imageName = ref(''), previewLoading = ref(false)
+const label = computed(() => props.kind === 'VEHICLE' ? '本趟车辆证据' : '本趟司机证照')
+const types = ['application/pdf', 'image/jpeg', 'image/png'], maximum = 10 * 1024 * 1024, urls = new Set<string>()
+let generation = 0, previewGeneration = 0, replacing: string | null = null, pendingPopup: Window | null = null
+function valid(value: DispatchEvidenceFile, expected?: string) {
+  if (!value || !/^[1-9]\d*$/.test(String(value.fileId)) || typeof value.fileId === 'number' && !Number.isSafeInteger(value.fileId) || expected && String(value.fileId) !== expected || !value.fileName?.trim() || !types.includes(value.contentType) || !Number.isSafeInteger(value.sizeBytes) || value.sizeBytes <= 0 || value.sizeBytes > maximum) throw new DispatchInputError('附件元数据未确认本车有效文件，请重新读取')
+  return { ...value, fileId: String(value.fileId) }
+}
+function fail(cause: unknown, fallback: string) { error.value = getApiErrorDetails(cause, cause instanceof DispatchInputError ? cause.message : fallback) }
+function closePreview() { previewGeneration++; pendingPopup?.close(); pendingPopup = null; imageOpen.value = false; previewLoading.value = false; if (imageUrl.value) { URL.revokeObjectURL(imageUrl.value); urls.delete(imageUrl.value); imageUrl.value = '' } }
+async function load() {
+  const current = ++generation, no = props.dispatchNo, kind = props.kind, values = [...ids.value]
+  closePreview(); metadata.value = {}; error.value = null
+  if (!no) return
+  const results = await Promise.allSettled(values.map(async id => valid(await getDispatchEvidence(no, kind, id), id)))
+  if (current !== generation) return
+  results.forEach(result => { if (result.status === 'fulfilled') metadata.value[result.value.fileId] = result.value; else fail(result.reason, '附件资料读取失败，请重试；原引用已保留') })
+}
+function choose(id: string | null = null) { if (props.readonly || props.disabled || uploading.value || !props.dispatchNo) return; replacing = id; input.value?.click() }
+async function upload(event: Event) {
+  const element = event.target as HTMLInputElement, file = element.files?.[0]; element.value = ''
+  if (!file || props.readonly || props.disabled || uploading.value) return
+  error.value = null
+  if (!types.includes(file.type) || file.size <= 0 || file.size > maximum) { fail(new DispatchInputError('请选择10MiB以内的PDF、JPG或PNG文件'), '附件不符合要求'); return }
+  const current = generation, no = props.dispatchNo, kind = props.kind, replaceId = replacing
+  uploading.value = true; emit('busy', true)
+  try {
+    const value = valid(await uploadDispatchEvidence(no, kind, file))
+    if (current !== generation) return
+    if (replaceId && !ids.value.includes(replaceId)) throw new DispatchInputError('原附件选择已变化，请重新核对')
+    ids.value = [...new Set(replaceId ? ids.value.map(id => id === replaceId ? value.fileId : id) : [...ids.value, value.fileId])]
+  } catch (cause) { if (current === generation) fail(cause, '上传结果未确认，原附件引用保留，请核对后重试') }
+  finally { uploading.value = false; emit('busy', false) }
+}
+function remove(id: string) { if (!props.readonly && !props.disabled && !uploading.value) ids.value = ids.value.filter(value => value !== id) }
+async function preview(id: string) {
+  const file = metadata.value[id]; if (!file || previewLoading.value) return
+  closePreview(); const current = ++previewGeneration, scope = generation
+  error.value = null; previewLoading.value = true
+  if (file.contentType === 'application/pdf') { pendingPopup = window.open('', '_blank'); if (!pendingPopup) { previewLoading.value = false; fail(new DispatchInputError('请允许本站打开PDF预览窗口'), 'PDF预览未打开'); return } }
+  else { imageName.value = file.fileName; imageOpen.value = true }
+  try {
+    const blob = await getDispatchEvidenceContent(props.dispatchNo, props.kind, id)
+    if (current !== previewGeneration || scope !== generation) return
+    const type = blob.type.split(';')[0]?.toLowerCase()
+    if (type?.includes('json')) {
+      let body: Partial<{ code: string; message: string; requestId: string; traceId: string }>
+      try { body = JSON.parse(await blob.text()) as typeof body } catch { throw new DispatchInputError('附件内容返回错误信息，请重新读取') }
+      throw new ApiResponseError(body.message || '附件读取失败', body.code || 'INVALID_FILE_CONTENT', undefined, undefined, body.requestId, body.traceId)
+    }
+    if (type !== file.contentType || blob.size <= 0 || blob.size > maximum || blob.size !== file.sizeBytes) throw new DispatchInputError('附件内容类型或大小与本车元数据不一致')
+    const url = URL.createObjectURL(blob); urls.add(url)
+    if (file.contentType === 'application/pdf') { pendingPopup!.location.href = url; pendingPopup = null; window.setTimeout(() => { URL.revokeObjectURL(url); urls.delete(url) }, 60_000) }
+    else imageUrl.value = url
+  } catch (cause) { if (current === previewGeneration) { closePreview(); fail(cause, '本车附件预览失败，原引用已保留') } }
+  finally { if (current === previewGeneration) previewLoading.value = false }
+}
+watch(() => JSON.stringify([props.dispatchNo, props.kind, ids.value]), load, { immediate: true })
+onBeforeUnmount(() => { generation++; closePreview(); for (const url of urls) URL.revokeObjectURL(url); urls.clear(); emit('busy', false) })
+</script>
+<template>
+  <section class="dispatch-evidence" :aria-label="label"><h4>{{ label }}</h4>
+    <p v-if="error" role="alert">{{ error.message }} <el-button link @click="load">重新读取资料</el-button></p><ApiErrorMeta v-if="error" :details="error" />
+    <ul><li v-for="id in ids" :key="id"><span>{{ metadata[id]?.fileName || '附件资料待核实' }}</span> <el-button link :disabled="!metadata[id] || previewLoading" @click="preview(id)">预览</el-button><template v-if="!readonly"><el-button link :disabled="disabled || uploading" @click="choose(id)">替换</el-button><el-button link :disabled="disabled || uploading" @click="remove(id)">移除引用</el-button></template></li></ul>
+    <p v-if="!ids.length">暂无本趟附件。</p><template v-if="!readonly"><input ref="input" class="evidence-input" type="file" accept="application/pdf,image/jpeg,image/png" :aria-label="`上传${label}`" :disabled="disabled || uploading || !dispatchNo" @change="upload"><el-button :disabled="disabled || uploading || !dispatchNo" :loading="uploading" @click="choose()">上传{{ label }}</el-button><p>PDF、JPG、PNG，单文件最大10MiB；上传后保存车辆信息才完成本车引用。</p></template>
+    <AppDialog class="admin-density-dialog" :model-value="imageOpen" :title="imageName || '附件预览'" width="900px" :show-confirm="false" cancel-text="关闭" @update:model-value="closePreview"><p v-if="previewLoading">正在读取本车附件…</p><img v-if="imageUrl" class="evidence-image" :src="imageUrl" :alt="imageName"></AppDialog>
+  </section>
+</template>
+<style scoped>
+.dispatch-evidence { padding: var(--admin-space-4) 0; }
+.dispatch-evidence ul { margin: 0; padding-left: 20px; }
+.evidence-input { display: none; }
+.evidence-image { display: block; max-width: 100%; max-height: 72vh; margin: auto; object-fit: contain; }
+</style>

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

@@ -0,0 +1,28 @@
+import ElementPlus from 'element-plus'
+import { flushPromises, mount } from '@vue/test-utils'
+import { beforeEach, expect, it, vi } from 'vitest'
+import DispatchResourceFields from './DispatchResourceFields.vue'
+import { resources } from '../dispatchTestFixtures'
+import { listDrivers, listVehicles } from '@/modules/overseas-master-data'
+const can = vi.hoisted(() => vi.fn(() => true))
+vi.mock('@/core/access/accessPreview', () => ({ useAccessPreviewStore: () => ({ can }) }))
+vi.mock('@/modules/overseas-master-data', () => ({ listDrivers: vi.fn(), listVehicles: vi.fn(), overseasMasterDataPermissions: { vehicleList: 'vehicle:list', driverList: 'driver:list' } }))
+beforeEach(() => { vi.clearAllMocks(); can.mockReturnValue(true) })
+it('renders known business labels for existing master resources without falling back to their internal IDs', async () => {
+  const value = resources(); value.vehicle.mode = 'MASTER'; value.vehicle.vehicleId = '900719925474099301'; value.driver.mode = 'MASTER'; value.driver.driverId = '900719925474099302'
+  const wrapper = mount(DispatchResourceFields, { props: { vehicle: value.vehicle, driver: value.driver, disabled: false }, global: { plugins: [ElementPlus] } }); await flushPromises()
+  expect(wrapper.text()).toContain('CA-100'); expect(wrapper.text()).toContain('司机甲'); expect(wrapper.text()).not.toContain('90071992547409930'); wrapper.unmount()
+})
+it('resets only the resource being switched and keeps external resource choices independent', async () => {
+  const value = resources(); value.vehicle.mode = 'MASTER'; value.vehicle.vehicleId = 'vehicle-1'
+  const wrapper = mount(DispatchResourceFields, { props: { vehicle: value.vehicle, driver: value.driver, disabled: false }, global: { plugins: [ElementPlus] } })
+  const state = wrapper.vm as unknown as { changeDriver(): void }; state.changeDriver(); await flushPromises()
+  expect(wrapper.emitted('update:driver')![0]![0]).toMatchObject({ mode: 'EXTERNAL', driverId: null, name: null, evidence: { fileIds: [], licenseNo: null } })
+  expect(wrapper.emitted('update:vehicle')).toBeUndefined(); expect(value.vehicle.vehicleId).toBe('vehicle-1'); wrapper.unmount()
+})
+it('requires each real directory permission before reading candidates', async () => {
+  can.mockReturnValue(false); const value = resources()
+  const wrapper = mount(DispatchResourceFields, { props: { vehicle: value.vehicle, driver: value.driver, disabled: false }, global: { plugins: [ElementPlus] } })
+  const state = wrapper.vm as unknown as { searchVehicles(): Promise<void>; searchDrivers(): Promise<void> }; await state.searchVehicles(); await state.searchDrivers()
+  expect(listVehicles).not.toHaveBeenCalled(); expect(listDrivers).not.toHaveBeenCalled(); expect(wrapper.text()).toContain('缺少司机档案读取权限'); wrapper.unmount()
+})

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

@@ -0,0 +1,53 @@
+<script setup lang="ts">
+import { ref } from 'vue'
+import { listDrivers, listVehicles, overseasMasterDataPermissions as resourcePermission, type DriverDetail, type VehicleDetail } from '@/modules/overseas-master-data'
+import { useAccessPreviewStore } from '@/core/access/accessPreview'
+import type { Driver, Vehicle } from '../dispatchContracts'
+const vehicle = defineModel<Vehicle>('vehicle', { required: true })
+const driver = defineModel<Driver>('driver', { required: true })
+defineProps<{ disabled: boolean }>()
+const access = useAccessPreviewStore(), vehicles = ref<VehicleDetail[]>([]), drivers = ref<DriverDetail[]>([]), error = ref('')
+let vehicleSequence = 0, driverSequence = 0
+async function searchVehicles(keyword = '') {
+  if (!access.can(resourcePermission.vehicleList)) { error.value = '缺少车辆档案读取权限'; return }
+  const sequence = ++vehicleSequence
+  try { const result = await listVehicles({ page: 1, size: 100, keyword, region: 'OVERSEAS', status: 'IN_SERVICE' }); if (sequence === vehicleSequence) vehicles.value = result.records }
+  catch (cause) { if (sequence === vehicleSequence) error.value = cause instanceof Error ? cause.message : '车辆候选读取失败' }
+}
+async function searchDrivers(keyword = '') {
+  if (!access.can(resourcePermission.driverList)) { error.value = '缺少司机档案读取权限'; return }
+  const sequence = ++driverSequence
+  try { const result = await listDrivers({ page: 1, size: 100, keyword, region: 'OVERSEAS', active: true, reviewStatus: 'APPROVED', expectedEnd: driver.value.evidence?.expectedTaskEndAt || undefined }); if (sequence === driverSequence) drivers.value = result.records }
+  catch (cause) { if (sequence === driverSequence) error.value = cause instanceof Error ? cause.message : '司机候选读取失败' }
+}
+function changeVehicle() { vehicle.value = { mode: vehicle.value.mode, vehicleId: null, plate: null, carrierName: null, capacity: { palletSpaces: null, maxLoadKg: null, maxVolumeCbm: null }, evidenceFileIds: [] } }
+function changeDriver() { driver.value = { mode: driver.value.mode, driverId: null, name: null, phone: null, evidence: { licenseNo: null, licenseExpiresOn: null, fileIds: [], expectedTaskEndAt: null } } }
+function selectVehicle(id: string) {
+  const selected = vehicles.value.find(row => row.id === id)
+  vehicle.value = { mode: 'MASTER', vehicleId: id, plate: selected?.plateNumber || null, carrierName: null, capacity: null, evidenceFileIds: [] }
+}
+function selectDriver(id: string) {
+  const selected = drivers.value.find(row => row.id === id), end = driver.value.evidence?.expectedTaskEndAt || null
+  driver.value = { mode: 'MASTER', driverId: id, name: selected?.details.name || null, phone: selected?.details.phone || null, evidence: { licenseNo: null, licenseExpiresOn: null, fileIds: [], expectedTaskEndAt: end } }
+}
+</script>
+<template>
+  <p v-if="error" role="alert">{{ error }}</p>
+  <div class="resource-grid">
+    <el-form-item label="车辆来源"><el-select v-model="vehicle.mode" :disabled="disabled" @change="changeVehicle"><el-option label="车辆档案" value="MASTER" /><el-option label="临时外配车辆" value="EXTERNAL" /></el-select></el-form-item>
+    <el-form-item v-if="vehicle.mode === 'MASTER'" label="车辆"><el-select v-model="vehicle.vehicleId" filterable remote :remote-method="searchVehicles" :disabled="disabled" placeholder="按车牌搜索" @focus="searchVehicles()" @change="selectVehicle"><el-option v-if="vehicle.vehicleId && !vehicles.some(row => row.id === vehicle.vehicleId)" :value="vehicle.vehicleId" :label="vehicle.plate || '已关联车辆（待核实）'" /><el-option v-for="item in vehicles" :key="item.id" :value="item.id" :label="item.plateNumber" /></el-select></el-form-item>
+    <template v-else>
+      <el-form-item label="车牌号"><el-input v-model="vehicle.plate" :disabled="disabled" placeholder="请输入本趟车牌号" /></el-form-item><el-form-item label="拖车公司名称"><el-input v-model="vehicle.carrierName" :disabled="disabled" placeholder="请输入承运公司" /></el-form-item>
+      <template v-if="vehicle.capacity"><el-form-item label="实际托位容量"><el-input-number v-model="vehicle.capacity.palletSpaces" :disabled="disabled" :min="1" placeholder="审核前核实" /></el-form-item><el-form-item label="最大载重(kg)"><el-input-number v-model="vehicle.capacity.maxLoadKg" :disabled="disabled" :min="0.001" placeholder="审核前核实" /></el-form-item><el-form-item label="最大容积(m³)"><el-input-number v-model="vehicle.capacity.maxVolumeCbm" :disabled="disabled" :min="0.001" placeholder="审核前核实" /></el-form-item></template>
+    </template>
+    <el-form-item label="司机来源"><el-select v-model="driver.mode" :disabled="disabled" @change="changeDriver"><el-option label="司机档案" value="MASTER" /><el-option label="临时外配司机" value="EXTERNAL" /></el-select></el-form-item>
+    <el-form-item v-if="driver.mode === 'MASTER'" label="司机"><el-select v-model="driver.driverId" filterable remote :remote-method="searchDrivers" :disabled="disabled" placeholder="按姓名搜索" @focus="searchDrivers()" @change="selectDriver"><el-option v-if="driver.driverId && !drivers.some(row => row.id === driver.driverId)" :value="driver.driverId" :label="driver.name || '已关联司机（待核实）'" /><el-option v-for="item in drivers" :key="item.id" :value="item.id" :label="item.details.name" /></el-select></el-form-item>
+    <template v-else><el-form-item label="司机姓名"><el-input v-model="driver.name" :disabled="disabled" placeholder="请输入本趟司机姓名" /></el-form-item><el-form-item label="联系电话"><el-input v-model="driver.phone" :disabled="disabled" placeholder="请输入联系电话" /></el-form-item><el-form-item v-if="driver.evidence" label="驾驶证号"><el-input v-model="driver.evidence.licenseNo" :disabled="disabled" placeholder="审核前补齐证照资料" /></el-form-item><el-form-item v-if="driver.evidence" label="驾驶证到期日"><el-date-picker v-model="driver.evidence.licenseExpiresOn" :disabled="disabled" type="date" value-format="YYYY-MM-DD" placeholder="请选择证照到期日" /></el-form-item></template>
+    <el-form-item v-if="driver.evidence" label="预计任务结束"><el-date-picker v-model="driver.evidence.expectedTaskEndAt" :disabled="disabled" type="datetime" value-format="YYYY-MM-DDTHH:mm:ssZ" placeholder="包括返程或转场" /></el-form-item>
+  </div>
+  <p v-if="vehicle.mode === 'EXTERNAL' || driver.mode === 'EXTERNAL'" role="status">临时资料仅用于本趟，不创建档案。先保存排车单，再在本车维护中上传本趟证据；资料齐备后由调度核实审核。</p>
+</template>
+<style scoped>
+.resource-grid { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 0 var(--admin-space-5); }
+.resource-grid :deep(.el-select), .resource-grid :deep(.el-date-editor), .resource-grid :deep(.el-input-number) { width: 100%; }
+</style>

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

@@ -0,0 +1,141 @@
+import ElementPlus, { ElMessage } from 'element-plus'
+import { ApiResponseError, http } from '@/shared/api/http'
+import { parseApiJsonResponse } from '@chongchong/shared'
+import { flushPromises, mount } from '@vue/test-utils'
+import { beforeEach, expect, it, vi } from 'vitest'
+import DispatchWorkflowDialog from './DispatchWorkflowDialog.vue'
+import * as api from '../api/dispatches'
+import { candidate, command, detail, destination, loadingPreview, page } from '../dispatchTestFixtures'
+import type { ArrangeGroup, CargoLine, CommandResult, DispatchAction, DispatchDetail, PreviewGroup } from '../dispatchContracts'
+const identity = vi.hoisted(() => ({ id: '' }))
+vi.mock('@/core/auth/auth', () => ({ useAuthStore: () => ({ user: identity }) }))
+vi.mock('@/core/access/accessPreview', () => ({ useAccessPreviewStore: () => ({ can: () => true }) }))
+vi.mock('./DispatchResourceFields.vue', () => ({ default: { template: '<div />' } }))
+vi.mock('../api/dispatches', () => ({ getDispatch: vi.fn(), getDispatchItems: vi.fn(), getDispatchRoute: vi.fn(), reorderDispatchRoute: vi.fn(), removeDispatchItem: vi.fn(), getDispatchLoading: vi.fn(), getDispatchArrangement: vi.fn(), getDispatchCommand: vi.fn(), listDispatches: vi.fn(), listDispatchCandidates: vi.fn(), completeDispatchLoading: vi.fn(), departDispatch: vi.fn(), reviewDispatch: vi.fn(), reviewDispatchLoading: vi.fn(), returnDispatchToReview: vi.fn(), cancelDispatch: vi.fn(), updateDispatch: vi.fn(), addDispatchCargo: vi.fn(), submitDispatchReview: vi.fn(), transferDispatchToDelivery: vi.fn() }))
+interface State { submit(): Promise<void>; measurements: Array<{ weightKg: number | null; volumeCbm: number | null; deliveryIndex: number | null; palletSpaces: number | null }>; form: { reason: string; decision: string }; detail: DispatchDetail }
+it.each([0, '0', '9007199254740993'])('adds cargo with original batch version %s while keeping the parent dispatch version independent', async recordVersion => {
+  const value = candidate({ appointmentBatches: [{ batchKey: 'FBA_APPOINTMENT:1', batchNo: 'AP-1', customerId: 'C1', recordVersion, sources: [{ sourceKey: 'ORDER:1', destinationKey: 'FBA:ONT8', packageCount: 2 }] }] })
+  vi.mocked(api.listDispatches).mockResolvedValue(page()); vi.mocked(api.listDispatchCandidates).mockResolvedValue({ candidates: [value], complete: true, snapshotAt: '' })
+  const { wrapper, state } = await open('ADD_CARGO')
+  try {
+    (wrapper.vm as unknown as { selected: string[] }).selected = [value.sourceKey]
+    vi.mocked(api.addDispatchCargo).mockImplementation(async (_, request) => command('ADD_CARGO', request.idempotencyKey)); vi.mocked(api.getDispatch).mockResolvedValue(detail({ recordVersion: 1 }))
+    await state.submit()
+    expect(api.addDispatchCargo).toHaveBeenCalledWith('PC/1', expect.objectContaining({ recordVersion: 0, batchAllocations: [{ planPalletId: '11', batchKey: 'FBA_APPOINTMENT:1', customerId: 'C1', sourceKey: 'ORDER:1', destinationKey: 'FBA:ONT8', packageCount: 2, recordVersion }] }))
+  } finally { wrapper.unmount() }
+})
+it('blocks cargo addition when the authoritative batch version is absent', async () => {
+  const value = candidate({ appointmentBatches: [{ batchKey: 'FBA_APPOINTMENT:1', batchNo: 'AP-1', customerId: 'C1', recordVersion: undefined as unknown as number, sources: [] }] })
+  vi.mocked(api.listDispatches).mockResolvedValue(page()); vi.mocked(api.listDispatchCandidates).mockResolvedValue({ candidates: [value], complete: true, snapshotAt: '' })
+  const { wrapper, state } = await open('ADD_CARGO')
+  try {
+    (wrapper.vm as unknown as { selected: string[] }).selected = [value.sourceKey]; await state.submit()
+    expect(api.addDispatchCargo).not.toHaveBeenCalled(); expect(wrapper.text()).toContain('预约批次版本缺失或无效，请重新读取候选')
+  } finally { wrapper.unmount() }
+})
+it('removes an unpicked authoritative item after real JSON and API normalization of pickedPackages string zero', async () => {
+  const actual = await vi.importActual<typeof import('../api/dispatches')>('../api/dispatches')
+  const source = candidate()
+  const data = { dispatchNo: 'PC/1', recordVersion: '0', status: 'ACTIVE', stage: 'BEFORE_LOADING', items: [{ ...source.selection, dispatchItemId: '9007199254740993', sourceKey: source.sourceKey, sourceVersion: source.sourceVersion, customerId: 'C1', customerName: '客户甲', palletNo: 'PALLET-1', orderNo: 'LM-1', inboundCode: 'IN-1', destination: source.destination, scheduledPackages: '2', pickedPackages: '0', remove: { allowed: true, blockCode: null, blockReason: null } }] }
+  const get = vi.spyOn(http, 'get').mockResolvedValue(parseApiJsonResponse(JSON.stringify({ code: '200', data })))
+  vi.mocked(api.getDispatchItems).mockImplementation(actual.getDispatchItems)
+  const { wrapper, state } = await open('REMOVE_CARGO')
+  try {
+    (wrapper.vm as unknown as { itemId: string }).itemId = '9007199254740993'; state.form.reason = '本车计划调整'
+    vi.mocked(api.removeDispatchItem).mockImplementation(async (_, __, request) => command('REMOVE_CARGO', request.idempotencyKey)); vi.mocked(api.getDispatch).mockResolvedValue(detail({ recordVersion: 1 }))
+    await state.submit()
+    expect(api.removeDispatchItem).toHaveBeenCalledWith('PC/1', '9007199254740993', expect.objectContaining({ recordVersion: '0', reason: '本车计划调整' })); expect(wrapper.emitted('saved')).toHaveLength(1)
+  } finally { wrapper.unmount(); get.mockRestore() }
+})
+async function open(action: DispatchAction, allowed = true) {
+  vi.mocked(api.getDispatch).mockResolvedValue(detail({ actions: { [action]: { allowed, blockCode: null, blockReason: allowed ? null : '前置审核未通过' } } }))
+  const wrapper = mount(DispatchWorkflowDialog, { props: { modelValue: true, dispatchNo: 'PC/1', action }, global: { plugins: [ElementPlus] } }); await flushPromises()
+  return { wrapper, state: wrapper.vm as unknown as State }
+}
+beforeEach(() => { vi.clearAllMocks(); sessionStorage.clear(); identity.id = crypto.randomUUID(); vi.stubGlobal('ResizeObserver', class { observe() {} unobserve() {} disconnect() {} }); vi.mocked(api.getDispatchLoading).mockResolvedValue(loadingPreview()) })
+it('keeps order allocation references out of actual measurements and submits native version zero only after real input', async () => {
+  const value = loadingPreview(); value.pallets[0]!.weightKg = 100; value.pallets[0]!.volumeCbm = 2
+  vi.mocked(api.getDispatchLoading).mockResolvedValue(value)
+  const { wrapper, state } = await open('LOADING_COMPLETE')
+  expect(state.measurements[0]).toMatchObject({ weightKg: null, volumeCbm: null })
+  await state.submit(); expect(api.completeDispatchLoading).not.toHaveBeenCalled(); expect(wrapper.text()).toContain('真实托位')
+  state.measurements[0]!.weightKg = 92; state.measurements[0]!.volumeCbm = 1.5
+  vi.mocked(api.completeDispatchLoading).mockImplementation(async (_, body) => command('LOADING_COMPLETE', body.idempotencyKey))
+  vi.mocked(api.getDispatch).mockResolvedValue(detail({ stage: 'AFTER_LOADING', recordVersion: 1 }))
+  await state.submit()
+  expect(api.completeDispatchLoading).toHaveBeenCalledWith('PC/1', expect.objectContaining({ recordVersion: 0, manifestHash: 'manifest', measurements: [{ warehousePalletId: '21', palletSpaces: 1, weightKg: 92, volumeCbm: 1.5, deliveryIndex: 1 }] }))
+  expect(api.departDispatch).not.toHaveBeenCalled(); expect(wrapper.emitted('saved')).toHaveLength(1); wrapper.unmount()
+})
+it('accepts actual evidence and a matching confirmed manifest while refusing an unknown unloading index', async () => {
+  const value = loadingPreview(); value.pallets[0]!.weightKg = 92; value.pallets[0]!.volumeCbm = 1.5; value.pallets[0]!.deliveryIndex = null
+  value.pallets[0]!.evidence.push({ field: 'weightKg', actual: true, value: 92, sourceType: 'MEASURED', sourceBusinessNo: 'PALLET-1', observedAt: null })
+  value.confirmedLoad = { manifestHash: 'manifest', operatorId: 'operator', confirmedAt: '2026-10-19T00:00:00Z', pallets: [{ warehousePalletId: '21', palletSpaces: 1, weightKg: 92, volumeCbm: 1.5, deliveryIndex: 1 }] }
+  vi.mocked(api.getDispatchLoading).mockResolvedValue(value)
+  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('requires a rejection reason and retains the full original command after an unknown review result', async () => {
+  const { wrapper, state } = await open('DISPATCH_REVIEW'); state.form.decision = 'REJECTED'
+  await state.submit(); expect(api.reviewDispatch).not.toHaveBeenCalled()
+  state.form.reason = '预约未核实'; vi.mocked(api.reviewDispatch).mockRejectedValue(new Error('unknown result'))
+  await state.submit(); state.form.reason = 'later changed'
+  vi.mocked(api.getDispatchCommand).mockImplementation(async (_, key) => command('DISPATCH_REVIEW', key))
+  vi.mocked(api.getDispatch).mockResolvedValue(detail({ recordVersion: 1 }))
+  await state.submit(); expect(api.reviewDispatch).toHaveBeenCalledTimes(1)
+  expect(vi.mocked(api.reviewDispatch).mock.calls[0]![1]).toMatchObject({ recordVersion: 0, decision: 'REJECTED', reason: '预约未核实' })
+  expect(wrapper.emitted('saved')).toHaveLength(1); wrapper.unmount()
+})
+it('blocks an action without a literal service allowance', async () => {
+  const { wrapper, state } = await open('DEPART', false); await state.submit(); expect(api.departDispatch).not.toHaveBeenCalled(); expect(wrapper.text()).toContain('前置审核未通过'); wrapper.unmount()
+})
+it('submits every customer destination group in one arrangement and does not waive another customer fee', async () => {
+  const previews: PreviewGroup[] = ['A', 'B'].map(customerId => ({ groupKey: `group-${customerId}`, customerId, customerName: `客户${customerId}`, destination: destination(), groupCargoHash: `cargo-${customerId}`, cargo: [{ customerId, sourceKey: `source-${customerId}`, inboundCode: `IN-${customerId}`, orderNo: `LM-${customerId}`, packages: 2 } as CargoLine], externalFreightHash: `external-${customerId}`, externalQuotes: customerId === 'A' ? [{ customerId: 'A', groupKey: 'group-A', bookingNo: 'BOOK-A', inboundCode: 'IN-A', currency: 'USD', amount: 100, sourceHash: 'quote-A' }] : [], feeCoverageCargoHash: `coverage-${customerId}`, feeSources: [], requiredServices: ['DELIVERY_FEE'], blockReasons: [] }))
+  vi.mocked(api.getDispatchArrangement).mockResolvedValue({ dispatchNo: 'PC/1', recordVersion: 0, status: 'ACTIVE', stage: 'AFTER_LOADING', cargoHash: 'whole-cargo', loadingCompletionHash: 'load-hash', arrange: { allowed: true, blockCode: null, blockReason: null }, groups: previews, arrangement: null })
+  const { wrapper, state } = await open('ARRANGE_DELIVERY')
+  const groups = (wrapper.vm as unknown as { groups: ArrangeGroup[] }).groups
+  groups.forEach(group => Object.assign(group, { plannedDeliveryAt: '2026-10-20T00:00:00Z', deliveryMethod: 'TRUCK_PALLET', pickupMethod: 'ONE_PICKUP_MULTI_DROP', loadingType: 'PALLET' }))
+  await state.submit(); expect(api.transferDispatchToDelivery).not.toHaveBeenCalled()
+  groups[1]!.fees.find(fee => fee.feeType === 'DELIVERY_FEE')!.amount = 77
+  vi.mocked(api.transferDispatchToDelivery).mockImplementation(async (_, body): Promise<CommandResult> => ({ ...command('ARRANGE_DELIVERY', body.idempotencyKey), action: 'ARRANGE_DELIVERY', result: { dispatchNo: 'PC/1', recordVersion: 1, arrangementKey: 'arrangement', cargoHash: 'whole-cargo', arrangedAt: '2026-10-19T00:00:00Z', outbounds: [], deliveries: [] } }))
+  vi.mocked(api.getDispatch).mockResolvedValue(detail({ recordVersion: 1, stage: 'AFTER_LOADING' })); await state.submit()
+  const sent = vi.mocked(api.transferDispatchToDelivery).mock.calls[0]![1]
+  expect(sent).toMatchObject({ recordVersion: 0, cargoHash: 'whole-cargo', loadingCompletionHash: 'load-hash' })
+  expect(sent.groups).toHaveLength(2); expect(sent.groups[0]!.fees).toEqual([]); expect(sent.groups[1]!.fees).toEqual([expect.objectContaining({ feeType: 'DELIVERY_FEE', amount: 77 })])
+  expect(api.getDispatchArrangement).toHaveBeenCalledTimes(1); expect(wrapper.emitted('saved')).toHaveLength(1); wrapper.unmount()
+})
+it('does not reuse another dispatch detail when the target changes while its dialog remains open', async () => {
+  const { wrapper, state } = await open('DEPART')
+  let resolve!: (value: DispatchDetail) => void
+  vi.mocked(api.getDispatch).mockImplementationOnce(() => new Promise(done => { resolve = done }))
+  await wrapper.setProps({ dispatchNo: 'PC/2' }); await state.submit(); expect(api.departDispatch).not.toHaveBeenCalled()
+  resolve(detail({ dispatchNo: 'PC/2', actions: { DEPART: { allowed: false, blockCode: 'NOT_READY', blockReason: '另一车尚未就绪' } } })); await flushPromises()
+  await state.submit(); expect(api.departDispatch).not.toHaveBeenCalled(); expect(wrapper.text()).toContain('另一车尚未就绪'); wrapper.unmount()
+})
+it('removes only the authoritative unpicked item using its item ID as path identity and retains that original target on recovery', async () => {
+  const source = candidate()
+  vi.mocked(api.getDispatchItems).mockResolvedValue({ dispatchNo: 'PC/1', recordVersion: 0, status: 'ACTIVE', stage: 'BEFORE_LOADING', items: [{ ...source.selection, dispatchItemId: '9007199254740993', sourceKey: source.sourceKey, sourceVersion: source.sourceVersion, customerId: 'C1', customerName: '客户甲', palletNo: 'PALLET-1', orderNo: 'LM-1', inboundCode: 'IN-1', destination: source.destination, scheduledPackages: 2, pickedPackages: 0, remove: { allowed: true, blockCode: null, blockReason: null } }] })
+  const { wrapper, state } = await open('REMOVE_CARGO'); const target = wrapper.vm as unknown as { itemId: string }; target.itemId = '9007199254740993'
+  await state.submit(); expect(api.removeDispatchItem).not.toHaveBeenCalled()
+  state.form.reason = '本车计划调整'; vi.mocked(api.removeDispatchItem).mockRejectedValueOnce(new Error('unknown')); await state.submit()
+  target.itemId = 'another-item'; state.form.reason = 'later changed'
+  vi.mocked(api.getDispatchCommand).mockImplementation(async (_, key) => command('REMOVE_CARGO', key)); vi.mocked(api.getDispatch).mockResolvedValue(detail({ recordVersion: 1 }))
+  await state.submit(); expect(api.removeDispatchItem).toHaveBeenCalledExactlyOnceWith('PC/1', '9007199254740993', expect.objectContaining({ recordVersion: 0, reason: '本车计划调整' })); expect(wrapper.emitted('saved')).toHaveLength(1); wrapper.unmount()
+})
+it('preserves external destinations and retries route EDIT through its original route endpoint instead of a resource update', async () => {
+  const toast = vi.spyOn(ElMessage, 'success')
+  vi.mocked(api.getDispatchRoute).mockResolvedValue({ dispatchNo: 'PC/1', recordVersion: 0, edit: { allowed: true, blockCode: null, blockReason: null }, stops: [{ index: 0, name: '起运仓', address: '实际起点', destinationKey: null }, { index: 1, name: 'ONT8', address: '实际地址A', destinationKey: 'CODE:ONT8' }, { index: 2, name: '外接卸货点', address: '实际地址B', destinationKey: 'PRIVATE:actual' }] })
+  const { wrapper, state } = await open('EDIT'); await wrapper.setProps({ operation: 'ROUTE' }); await flushPromises()
+  const routeState = wrapper.vm as unknown as { moveStop(index: number, offset: number): void }; routeState.moveStop(1, -1); state.form.reason = '按本车现场顺序卸货'
+  vi.mocked(api.reorderDispatchRoute).mockRejectedValueOnce(new Error('unknown route')).mockImplementationOnce(async (_, body) => command('EDIT', body.idempotencyKey))
+  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()
+})
+it('refuses already picked item removal and a route that drops an authoritative destination', async () => {
+  const source = candidate()
+  vi.mocked(api.getDispatchItems).mockResolvedValue({ dispatchNo: 'PC/1', recordVersion: 0, status: 'ACTIVE', stage: 'BEFORE_LOADING', items: [{ ...source.selection, dispatchItemId: 'item-picked', sourceKey: source.sourceKey, sourceVersion: source.sourceVersion, customerId: 'C1', customerName: '客户甲', palletNo: 'PALLET-1', orderNo: 'LM-1', inboundCode: 'IN-1', destination: source.destination, scheduledPackages: 2, pickedPackages: 1, remove: { allowed: false, blockCode: 'PICKED', blockReason: '本来源已经真实扫码' } }] })
+  const removed = await open('REMOVE_CARGO'); (removed.wrapper.vm as unknown as { itemId: string }).itemId = 'item-picked'; removed.state.form.reason = '调整'; await removed.state.submit(); expect(api.removeDispatchItem).not.toHaveBeenCalled(); expect(removed.wrapper.text()).toContain('已经真实扫码'); removed.wrapper.unmount()
+  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' }] })
+  const route = await open('EDIT'); await route.wrapper.setProps({ operation: 'ROUTE' }); await flushPromises(); (route.wrapper.vm as unknown as { stops: unknown[] }).stops.pop(); route.state.form.reason = '调整'; await route.state.submit(); expect(api.reorderDispatchRoute).not.toHaveBeenCalled(); expect(route.wrapper.text()).toContain('完整保留'); route.wrapper.unmount()
+})

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

@@ -0,0 +1,216 @@
+<script setup lang="ts">
+import { computed, reactive, ref, watch } from 'vue'
+import { ElMessage } from 'element-plus'
+import { useAuthStore } from '@/core/auth/auth'
+import { useAccessPreviewStore } from '@/core/access/accessPreview'
+import { getApiErrorDetails, type ApiErrorDetails } from '@/shared/api/http'
+import AppDialog from '@/shared/components/AppDialog.vue'
+import ApiErrorMeta from '@/shared/components/ApiErrorMeta.vue'
+import LoadErrorState from '@/shared/components/LoadErrorState.vue'
+import * as api from '../api/dispatches'
+import type { AddCargo, ArrangeDelivery, ArrangeGroup, ArrangementPreview, Candidate, CommandResult, DispatchAction, DispatchDetail, Driver, LoadingComplete, LoadingPreview, ReasonCommand, ReviewCommand, UpdateDispatch, Vehicle, VersionCommand } from '../dispatchContracts'
+import type { DispatchItems, DispatchRoute, DispatchRouteCommand, DispatchRouteStop } from '../dispatchContracts'
+import { DispatchInputError, requireVersion, requireBatchVersions } from '../dispatchContracts'
+import { canDispatchAction, dispatchActionLabels } from '../dispatchPresentation'
+import { useDispatchCommandRecovery, type PendingDispatchCommand } from '../dispatchCommandRecovery'
+import DispatchResourceFields from './DispatchResourceFields.vue'
+import DispatchArrangeFields from './DispatchArrangeFields.vue'
+import DispatchEvidenceFiles from './DispatchEvidenceFiles.vue'
+
+const open = defineModel<boolean>({ default: false })
+const props = defineProps<{ dispatchNo: string; action: DispatchAction; operation?: 'ROUTE' }>()
+const emit = defineEmits<{ saved: [] }>()
+const auth = useAuthStore(), access = useAccessPreviewStore()
+const recovery = useDispatchCommandRecovery(() => auth.user?.id || '')
+const { pending, busy } = recovery
+const currentAction = computed(() => pending.value?.action || props.action)
+const currentNo = computed(() => pending.value?.dispatchNo || props.dispatchNo)
+const currentOperation = computed(() => pending.value ? pending.value.operation : props.operation)
+const items = ref<DispatchItems | null>(null), itemId = ref(''), route = ref<DispatchRoute | null>(null), stops = ref<DispatchRouteStop[]>([])
+const detail = ref<DispatchDetail | null>(null), loading = ref(false), error = ref<ApiErrorDetails | null>(null)
+const preview = ref<LoadingPreview | null>(null), arrangement = ref<ArrangementPreview | null>(null), groups = ref<ArrangeGroup[]>([])
+const arrangeFields = ref<InstanceType<typeof DispatchArrangeFields> | null>(null)
+const candidates = ref<Candidate[]>([]), selected = ref<string[]>([]), candidateKeyword = ref('')
+const measurements = ref<Array<{ warehousePalletId: string; palletNo: string; palletSpaces: number | null; weightKg: number | null; volumeCbm: number | null; deliveryIndex: number | null }>>([])
+const blankVehicle = (): Vehicle => ({ mode: 'MASTER', vehicleId: null, plate: null, carrierName: null, capacity: { palletSpaces: null, maxLoadKg: null, maxVolumeCbm: null }, evidenceFileIds: [] })
+const blankDriver = (): Driver => ({ mode: 'MASTER', driverId: null, name: null, phone: null, evidence: { licenseNo: null, licenseExpiresOn: null, fileIds: [], expectedTaskEndAt: null } })
+const vehicle = ref<Vehicle>(blankVehicle()), driver = ref<Driver>(blankDriver())
+const form = reactive({ plannedDepartureAt: '', estimatedArrivalAt: '', remark: '', decision: 'APPROVED' as 'APPROVED' | 'REJECTED', reason: '' })
+let generation = 0
+const allowed = computed(() => !pending.value && canDispatchAction(detail.value?.actions, currentAction.value, access.can) && (currentOperation.value !== 'ROUTE' || route.value?.edit.allowed === true))
+const width = computed(() => ['EDIT', 'LOADING_COMPLETE', 'ARRANGE_DELIVERY', 'ADD_CARGO', 'REMOVE_CARGO'].includes(currentAction.value) ? '1120px' : ['DISPATCH_REVIEW', 'LOADING_REVIEW'].includes(currentAction.value) ? '760px' : '560px')
+const frozen = computed(() => busy.value || Boolean(pending.value))
+const evidenceBusy = reactive({ VEHICLE: false, DRIVER: false })
+const uploadingEvidence = computed(() => evidenceBusy.VEHICLE || evidenceBusy.DRIVER)
+
+async function load() {
+  const sequence = ++generation, no = currentNo.value, action = currentAction.value
+  loading.value = true; error.value = null; detail.value = null; preview.value = null; arrangement.value = null; selected.value = []
+  items.value = null; itemId.value = ''; route.value = null; stops.value = []
+  try {
+    if (action === 'CREATE') throw new DispatchInputError('请从排车列表的原请求入口恢复新建排车')
+    const value = await api.getDispatch(no)
+    if (sequence !== generation) return
+    if (value.dispatchNo !== no) throw new DispatchInputError('排车业务号不一致，请重新打开')
+    detail.value = value
+    const oldVehicle = value.vehicleInfo.vehicle
+    vehicle.value = oldVehicle ? { mode: oldVehicle.mode, vehicleId: oldVehicle.vehicleId, plate: oldVehicle.plate, carrierName: oldVehicle.carrierName, capacity: oldVehicle.capacity ? { ...oldVehicle.capacity } : null, evidenceFileIds: [...oldVehicle.evidenceFileIds] } : blankVehicle()
+    driver.value = value.vehicleInfo.driver ? structuredClone(value.vehicleInfo.driver) : blankDriver()
+    if (!driver.value.evidence) driver.value.evidence = blankDriver().evidence
+    Object.assign(form, { plannedDepartureAt: value.dispatchInfo.plannedDepartureAt || '', estimatedArrivalAt: value.dispatchInfo.estimatedArrivalAt || '', remark: value.documents.remark || '', reason: '', decision: 'APPROVED' })
+    if (currentOperation.value === 'ROUTE') {
+      const data = await api.getDispatchRoute(no)
+      if (sequence !== generation) return
+      if (data.dispatchNo !== no || !data.stops.length || data.stops[0]?.index !== 0) throw new DispatchInputError('本车真实起点及路线未完整返回')
+      route.value = data; stops.value = data.stops.slice(1).map(stop => ({ ...stop }))
+    }
+    if (action === 'REMOVE_CARGO') {
+      const data = await api.getDispatchItems(no)
+      if (sequence !== generation) return
+      if (data.dispatchNo !== no) throw new DispatchInputError('移货清单与原排车单不一致')
+      items.value = data
+    }
+    if (action === 'LOADING_COMPLETE') {
+      const data = await api.getDispatchLoading(no)
+      if (sequence !== generation) return
+      if (data.dispatchNo !== no) throw new DispatchInputError('实载预览与排车单不一致')
+      preview.value = data
+      measurements.value = data.pallets.map(row => {
+        const confirmed = data.confirmedLoad?.manifestHash === data.manifestHash ? data.confirmedLoad.pallets.find(item => item.warehousePalletId === row.warehousePalletId) : null
+        const actual = (field: string) => row.evidence.some(item => item.field === field && item.actual === true)
+        return { warehousePalletId: row.warehousePalletId, palletNo: row.palletNo, palletSpaces: row.palletSpaces, deliveryIndex: row.deliveryIndex,
+          weightKg: confirmed?.weightKg ?? (actual('weightKg') ? row.weightKg : null), volumeCbm: confirmed?.volumeCbm ?? (actual('volumeCbm') ? row.volumeCbm : null) }
+      })
+    }
+    if (action === 'ARRANGE_DELIVERY') {
+      const data = await api.getDispatchArrangement(no)
+      if (sequence !== generation) return
+      if (data.dispatchNo !== no) throw new DispatchInputError('派送预览与排车单不一致')
+      arrangement.value = data
+      groups.value = data.groups.map(group => ({ groupKey: group.groupKey, groupCargoHash: group.groupCargoHash, plannedDeliveryAt: '', deliveryMethod: '', waybillNo: null, carrierName: null, pickupMethod: '', loadingType: '', vehicleType: null, vehicleSize: null, appointmentAccount: null, sellerName: null, remark: null, externalFreightHash: group.externalFreightHash, feeCoverageCargoHash: group.feeCoverageCargoHash, feeCoverage: [], fees: ['DELIVERY_FEE', 'LOADING_FEE', 'APPOINTMENT_FEE'].map(feeType => ({ feeType, feeName: ({ DELIVERY_FEE: '派送费', LOADING_FEE: '装车费', APPOINTMENT_FEE: '买约费' })[feeType] || '服务费用', direction: 'RECEIVABLE', currency: 'USD', amount: null })) }))
+    }
+    if (action === 'ADD_CARGO') await loadCandidates(sequence)
+  } catch (cause) { if (sequence === generation) error.value = getApiErrorDetails(cause, cause instanceof DispatchInputError ? cause.message : '排车操作资料读取失败') }
+  finally { if (sequence === generation) loading.value = false }
+}
+async function loadCandidates(sequence = generation) {
+  // Detail has no warehouse field: resolve the authoritative list row by this business number.
+  const page = await api.listDispatches({ page: 1, size: 1, dispatchNo: currentNo.value, status: 'ACTIVE' })
+  const row = page.records.find(item => item.dispatchNo === currentNo.value)
+  if (!row?.warehouseId) throw new DispatchInputError('当前排车起运仓未返回，请刷新核对')
+  const result = await api.listDispatchCandidates({ warehouseId: row.warehouseId, orderNo: candidateKeyword.value || undefined })
+  if (sequence !== generation) return
+  if (result.complete !== true) throw new DispatchInputError('候选来源未完整返回，请缩小范围重新查询')
+  if (result.candidates.some(source => source.warehouseId !== row.warehouseId || !source.sourceVersion || source.selection.sourceVersion !== source.sourceVersion)) throw new DispatchInputError('货物起运仓或来源版本不完整，请重新读取')
+  candidates.value = result.candidates
+}
+async function searchCargo() { if (frozen.value) return; loading.value = true; error.value = null; try { await loadCandidates() } catch (cause) { error.value = getApiErrorDetails(cause, cause instanceof DispatchInputError ? cause.message : '货物候选读取失败') } finally { loading.value = false } }
+
+function requirePlanPallet(row: Candidate): string {
+  if (!row.selection.planPalletId) throw new DispatchInputError('批次分配缺少真实计划来源，请核对')
+  return row.selection.planPalletId
+}
+function payload(): object {
+  if (!detail.value || !allowed.value) throw new DispatchInputError(detail.value?.actions[currentAction.value]?.blockReason || '当前操作未获得服务端允许，请刷新核对')
+  const common = { recordVersion: requireVersion(detail.value.recordVersion), idempotencyKey: crypto.randomUUID() }
+  if (currentOperation.value === 'ROUTE') {
+    const data = route.value, keys = stops.value.map(stop => stop.destinationKey)
+    if (!data || data.edit.allowed !== true || !form.reason.trim() || !keys.length || keys.some(key => !key) || new Set(keys).size !== keys.length || keys.length !== data.stops.length - 1 || data.stops.slice(1).some(stop => !keys.includes(stop.destinationKey))) throw new DispatchInputError('请完整保留本车既有卸货点并填写调整原因')
+    return { recordVersion: requireVersion(data.recordVersion), idempotencyKey: common.idempotencyKey, destinationKeys: keys as string[], reason: form.reason.trim() } satisfies DispatchRouteCommand
+  }
+  switch (currentAction.value) {
+    case 'REMOVE_CARGO': {
+      const row = items.value?.items.find(value => value.dispatchItemId === itemId.value)
+      if (!row || row.remove.allowed !== true || row.pickedPackages !== 0 || !form.reason.trim()) throw new DispatchInputError(row?.remove.blockReason || '请选择允许移除的未扫码货物并填写原因')
+      return { recordVersion: requireVersion(items.value!.recordVersion), idempotencyKey: common.idempotencyKey, reason: form.reason.trim() } satisfies ReasonCommand
+    }
+    case 'EDIT': return { ...common, vehicle: vehicle.value, driver: driver.value, plannedDepartureAt: form.plannedDepartureAt || null, estimatedArrivalAt: form.estimatedArrivalAt || null, remark: form.remark || null } satisfies UpdateDispatch
+    case 'ADD_CARGO': {
+      const chosen = candidates.value.filter(row => selected.value.includes(row.sourceKey))
+      requireBatchVersions(chosen.flatMap(row => row.appointmentBatches))
+      if (!chosen.length || chosen.some(row => row.blockReasons.length || !row.sourceVersion || row.sourceVersion !== row.selection.sourceVersion || row.appointmentBatches.some(batch => batch.customerId !== row.customerId))) throw new DispatchInputError('请选择来源完整、预约客户一致且可排的货物')
+      return { ...common, cargo: chosen.map(row => row.selection), batchAllocations: chosen.flatMap(row => row.appointmentBatches.flatMap(batch => batch.sources.map(source => ({ planPalletId: requirePlanPallet(row), batchKey: batch.batchKey, customerId: batch.customerId, ...source, recordVersion: batch.recordVersion })))) } satisfies AddCargo
+    }
+    case 'DISPATCH_REVIEW': case 'LOADING_REVIEW':
+      if (form.decision === 'REJECTED' && !form.reason.trim()) throw new DispatchInputError('驳回时必须填写原因')
+      return { ...common, decision: form.decision, reason: form.reason.trim() || null } satisfies ReviewCommand
+    case 'CANCEL': case 'RETURN_TO_REVIEW':
+      if (!form.reason.trim()) throw new DispatchInputError('请填写操作原因')
+      return { ...common, reason: form.reason.trim() } satisfies ReasonCommand
+    case 'LOADING_COMPLETE': {
+      if (!preview.value || preview.value.pickingReconciled !== true || preview.value.loadingComplete.allowed !== true) throw new DispatchInputError(preview.value?.loadingComplete.blockReason || 'PDA真实拣货尚未核平')
+      if (!measurements.value.length || measurements.value.some(row => row.weightKg == null || row.volumeCbm == null || row.palletSpaces == null || row.deliveryIndex == null || row.weightKg <= 0 || row.volumeCbm <= 0 || row.palletSpaces <= 0 || !Number.isInteger(row.palletSpaces) || !Number.isInteger(row.deliveryIndex) || row.deliveryIndex < 0)) throw new DispatchInputError('请核对每托真实托位、重量、体积和卸货站；不能以参考值代替实测')
+      return { recordVersion: requireVersion(preview.value.recordVersion), idempotencyKey: common.idempotencyKey, manifestHash: preview.value.manifestHash, measurements: measurements.value.map(row => ({ warehousePalletId: row.warehousePalletId, palletSpaces: row.palletSpaces!, weightKg: row.weightKg!, volumeCbm: row.volumeCbm!, deliveryIndex: row.deliveryIndex! })), remark: form.remark || null } satisfies LoadingComplete
+    }
+    case 'ARRANGE_DELIVERY': {
+      const data = arrangement.value
+      if (!data || data.arrange.allowed !== true || !data.groups.length || data.groups.some(row => row.blockReasons.length)) throw new DispatchInputError(data?.arrange.blockReason || '本车派送资料未就绪')
+      const prepared = groups.value.map((group, index) => {
+        if (!group.plannedDeliveryAt || !group.deliveryMethod || !group.pickupMethod || !group.loadingType) throw new DispatchInputError('请完整填写每个客户及目的仓的派送信息')
+        if (group.appointmentAccount === 'BUY_APPOINTMENT' && !group.sellerName?.trim()) throw new DispatchInputError('买约时卖家姓名必填')
+        const required = [...new Set([...(data.groups[index]?.requiredServices || []), ...(['FLOOR', 'MIXED'].includes(group.loadingType) ? ['LOADING_FEE'] : []), ...(group.appointmentAccount === 'BUY_APPOINTMENT' ? ['APPOINTMENT_FEE'] : [])])]
+        const fees = group.fees.filter(fee => required.includes(fee.feeType) && !arrangeFields.value?.covered(index, data.groups[index]!, fee.feeType))
+        if (fees.some(fee => fee.amount == null || !Number.isFinite(fee.amount) || fee.amount <= 0)) throw new DispatchInputError('请填写本组未覆盖服务的正数新增费用')
+        return { ...group, fees }
+      })
+      return { recordVersion: requireVersion(data.recordVersion), idempotencyKey: common.idempotencyKey, cargoHash: data.cargoHash, loadingCompletionHash: data.loadingCompletionHash, groups: prepared } satisfies ArrangeDelivery
+    }
+    default: return { ...common, remark: form.remark || null }
+  }
+}
+async function send(command: PendingDispatchCommand): Promise<CommandResult> {
+  const no = command.dispatchNo, body = command.body
+  if (command.operation === 'ROUTE') return api.reorderDispatchRoute(no, body as unknown as DispatchRouteCommand)
+  switch (command.action) {
+    case 'REMOVE_CARGO': if (!command.itemId) throw new DispatchInputError('原移货请求缺少真实明细，请保留现场核对'); return api.removeDispatchItem(no, command.itemId, body as unknown as ReasonCommand)
+    case 'EDIT': return api.updateDispatch(no, body as unknown as UpdateDispatch)
+    case 'ADD_CARGO': return api.addDispatchCargo(no, body as unknown as AddCargo)
+    case 'DISPATCH_REVIEW': return api.reviewDispatch(no, body as unknown as ReviewCommand)
+    case 'LOADING_REVIEW': return api.reviewDispatchLoading(no, body as unknown as ReviewCommand)
+    case 'RETURN_TO_REVIEW': return api.returnDispatchToReview(no, body as unknown as ReasonCommand)
+    case 'CANCEL': return api.cancelDispatch(no, body as unknown as ReasonCommand)
+    case 'LOADING_COMPLETE': return api.completeDispatchLoading(no, body as unknown as LoadingComplete)
+    case 'ARRANGE_DELIVERY': return api.transferDispatchToDelivery(no, body as unknown as ArrangeDelivery)
+    case 'SUBMIT_REVIEW': return api.submitDispatchReview(no, body as unknown as VersionCommand & { remark: string | null })
+    case 'DEPART': return api.departDispatch(no, body as unknown as VersionCommand & { remark: string | null })
+    default: throw new DispatchInputError('此操作不属于当前后台作业入口')
+  }
+}
+async function submit() {
+  if (busy.value || loading.value || uploadingEvidence.value) return
+  error.value = null
+  try {
+    if (pending.value?.action === 'CREATE') throw new DispatchInputError('请从排车列表的原请求入口恢复新建排车')
+    if (!pending.value) recovery.begin(props.dispatchNo, props.action, payload(), { operation: currentOperation.value, ...(props.action === 'REMOVE_CARGO' ? { itemId: itemId.value } : {}) })
+    const routeCommand = pending.value?.operation === 'ROUTE'
+    const result = await recovery.execute(send, api.getDispatch, api.getDispatchCommand)
+    if (!result) return
+    ElMessage.success(routeCommand ? '卸货顺序调整已确认，请重新核对两级审核' : result.alreadyArranged ? '已引用本车原派送安排，未重复生成单据和费用' : result.replayed ? '原操作结果已核对' : `${dispatchActionLabels[result.action]}已确认`)
+    emit('saved'); open.value = false
+  } catch (cause) { error.value = getApiErrorDetails(cause, cause instanceof DispatchInputError ? cause.message : '操作结果尚未确认，请保留原请求核对') }
+}
+function moveStop(index: number, offset: number) { const target = index + offset; if (frozen.value || target < 0 || target >= stops.value.length) return; [stops.value[index], stops.value[target]] = [stops.value[target]!, stops.value[index]!] }
+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" :title="currentOperation === 'ROUTE' ? '调整卸货顺序' : dispatchActionLabels[currentAction]" :width="width" :confirm-loading="busy" :confirm-disabled="loading || uploadingEvidence || !pending && !allowed" :confirm-text="pending ? '核对并重试原请求' : '确认提交'" @confirm="submit">
+    <p>排车单号 {{ currentNo || '—' }}</p><p v-if="pending" role="status">原操作结果尚待核对，当前使用原版本和原请求内容。</p>
+    <LoadErrorState v-if="error" title="排车操作未完成" :message="error.message" :loading="loading" @retry="pending ? submit() : load()"><template #details><ApiErrorMeta :details="error" /></template></LoadErrorState>
+    <el-button v-if="pending?.rejected" :disabled="busy" @click="recovery.discardRejected(); load()">按明确驳回结果重新核对</el-button>
+    <p v-if="detail?.actions[currentAction]?.allowed !== true && !pending">{{ detail?.actions[currentAction]?.blockReason || '当前操作资格未返回，请刷新核对' }}</p>
+    <el-form v-if="detail" class="density-form" label-position="top">
+      <template v-if="currentOperation === 'ROUTE' && route"><p>起运仓：{{ route.stops[0]?.name || '—' }} · {{ route.stops[0]?.address || '—' }}</p><p>{{ route.edit.blockReason || '仅调整本车既有卸货点，外接卸货点一并保留。调整后须重新审核。' }}</p><ol><li v-for="(stop, index) in stops" :key="stop.destinationKey || stop.index">{{ stop.name }} · {{ stop.address || '—' }} <el-button :disabled="frozen || index === 0" @click="moveStop(index, -1)">上移</el-button><el-button :disabled="frozen || index === stops.length - 1" @click="moveStop(index, 1)">下移</el-button></li></ol></template><template v-else-if="currentAction === 'REMOVE_CARGO' && items"><el-table :data="items.items" border max-height="420"><el-table-column label="操作" width="140" fixed="left"><template #default="{ row }"><el-radio v-model="itemId" :value="row.dispatchItemId" :disabled="frozen || row.remove.allowed !== true || row.pickedPackages > 0">移除此项</el-radio></template></el-table-column><el-table-column prop="customerName" label="客户" /><el-table-column prop="orderNo" label="来源订单" /><el-table-column prop="inboundCode" label="入仓码" /><el-table-column prop="palletNo" label="托盘码" /><el-table-column prop="scheduledPackages" label="本次箱数" /><el-table-column prop="pickedPackages" label="真实已拣" /><el-table-column label="移货资格"><template #default="{ row }">{{ row.remove.blockReason || '可移除' }}</template></el-table-column></el-table></template><template v-else-if="currentAction === 'EDIT'"><DispatchResourceFields v-model:vehicle="vehicle" v-model:driver="driver" :disabled="frozen" /><div class="form-grid"><el-form-item label="计划发车时间"><el-date-picker v-model="form.plannedDepartureAt" :disabled="frozen" type="datetime" value-format="YYYY-MM-DDTHH:mm:ssZ" placeholder="请选择计划发车时间" /></el-form-item><el-form-item label="预计到达时间"><el-date-picker v-model="form.estimatedArrivalAt" :disabled="frozen" type="datetime" value-format="YYYY-MM-DDTHH:mm:ssZ" placeholder="请选择预计到达时间" /></el-form-item></div></template>
+      <template v-else-if="currentAction === 'DISPATCH_REVIEW' || currentAction === 'LOADING_REVIEW'"><p>{{ detail.vehicleInfo.vehicle?.plate || '—' }} · {{ detail.vehicleInfo.driver?.name || '—' }} · {{ detail.counts.palletCount }}托／{{ detail.counts.packageCount }}箱</p><p v-for="appointment in detail.dispatchInfo.fbaAppointments" :key="appointment.batchKey">{{ appointment.destinationWarehouseCode }} · {{ appointment.appointmentNo || '—' }} · {{ appointment.status }}</p><p>请核对本车资源与本趟证据；审核通过不代替后续现场扫码。</p><el-form-item label="审核结果"><el-radio-group v-model="form.decision" :disabled="frozen"><el-radio value="APPROVED">审核通过</el-radio><el-radio value="REJECTED">驳回</el-radio></el-radio-group></el-form-item></template>
+      <template v-else-if="currentAction === 'ADD_CARGO'"><div class="density-actions"><el-input v-model="candidateKeyword" :disabled="frozen" placeholder="订单号／入仓码" /><el-button :disabled="frozen" @click="searchCargo">查询</el-button></div><el-table :data="candidates" border max-height="380"><el-table-column label="选择" width="70"><template #default="{ row }"><el-checkbox :model-value="selected.includes(row.sourceKey)" @change="selected = $event === true ? [...selected, row.sourceKey] : selected.filter(key => key !== row.sourceKey)" :disabled="frozen || row.blockReasons.length > 0" :aria-label="`选择货物 ${row.palletNo || row.orderNo || '待核实'}`" /></template></el-table-column><el-table-column prop="customerName" label="客户" /><el-table-column prop="orderNo" label="订单号" /><el-table-column prop="palletNo" label="托盘码" /><el-table-column prop="availablePackages" label="可排箱数" /><el-table-column label="目的仓"><template #default="{ row }">{{ row.destination.warehouseCode || row.destination.address || '—' }}</template></el-table-column></el-table></template>
+      <template v-else-if="currentAction === 'LOADING_COMPLETE' && preview"><p>{{ preview.loadingComplete.blockReason || 'PDA真实拣货已核平，请核对每托实际装载。' }}</p><el-table :data="measurements" border><el-table-column prop="palletNo" label="实物托盘码" min-width="170" /><el-table-column label="实际托位"><template #default="{ row }"><el-input-number v-model="row.palletSpaces" :disabled="frozen" :min="1" placeholder="请确认" /></template></el-table-column><el-table-column label="实测重量(kg)"><template #default="{ row }"><el-input-number v-model="row.weightKg" :disabled="frozen" :min="0.001" placeholder="请核对真实实测" /></template></el-table-column><el-table-column label="实测体积(m³)"><template #default="{ row }"><el-input-number v-model="row.volumeCbm" :disabled="frozen" :min="0.001" placeholder="请核对真实实测" /></template></el-table-column><el-table-column label="已匹配卸货顺序"><template #default="{ row }">{{ row.deliveryIndex ?? '尚未匹配，请调度核对' }}</template></el-table-column></el-table><p v-for="pallet in preview.pallets" :key="pallet.warehousePalletId">{{ pallet.palletNo }}：<span v-for="evidence in pallet.evidence" :key="evidence.field + evidence.sourceType">{{ evidence.actual ? '实测依据' : '仅供参考' }} {{ evidence.sourceBusinessNo || '—' }} {{ evidence.value ?? '—' }}；</span></p></template>
+      <DispatchArrangeFields v-else-if="currentAction === 'ARRANGE_DELIVERY' && arrangement" ref="arrangeFields" v-model="groups" :preview="arrangement.groups" :disabled="frozen" />
+      <p v-else-if="currentAction === 'DEPART'">确认本车实际发车。装车完成及全部客户派送安排由服务端再次核验。</p><p v-else-if="currentAction === 'RETURN_TO_REVIEW'">仅零真实扫码允许退回装车前，保留原排车号，修改后两级审核重新提交。</p><p v-else-if="currentAction === 'CANCEL'">确认取消本排车单；服务端将核对真实作业和来源占用，不自动回库。</p>
+      <template v-if="currentOperation !== 'ROUTE' && ['EDIT', 'DISPATCH_REVIEW', 'LOADING_REVIEW'].includes(currentAction)"><DispatchEvidenceFiles v-model="vehicle.evidenceFileIds" :dispatch-no="currentNo" kind="VEHICLE" :readonly="currentAction !== 'EDIT'" :disabled="frozen" @busy="evidenceBusy.VEHICLE = $event" /><DispatchEvidenceFiles v-if="driver.evidence" v-model="driver.evidence.fileIds" :dispatch-no="currentNo" kind="DRIVER" :readonly="currentAction !== 'EDIT'" :disabled="frozen" @busy="evidenceBusy.DRIVER = $event" /></template><el-form-item v-if="currentOperation === 'ROUTE' || ['REMOVE_CARGO', 'CANCEL', 'RETURN_TO_REVIEW', 'DISPATCH_REVIEW', 'LOADING_REVIEW'].includes(currentAction)" :label="currentOperation === 'ROUTE' || form.decision === 'REJECTED' || ['REMOVE_CARGO', 'CANCEL', 'RETURN_TO_REVIEW'].includes(currentAction) ? '原因（必填）' : '审核意见（选填）'"><el-input v-model="form.reason" :disabled="frozen" type="textarea" :rows="3" placeholder="请输入操作原因或审核意见" /></el-form-item>
+      <el-form-item v-else-if="currentAction !== 'ARRANGE_DELIVERY' && currentAction !== 'ADD_CARGO'" label="备注"><el-input v-model="form.remark" :disabled="frozen" type="textarea" :rows="3" placeholder="请输入本次备注（选填）" /></el-form-item>
+    </el-form>
+  </AppDialog>
+</template>
+<style scoped>
+.form-grid { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 0 var(--admin-space-5); }
+.form-grid :deep(.el-date-editor) { width: 100%; }
+</style>

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

@@ -1,338 +1,107 @@
-import { flushPromises, shallowMount } from '@vue/test-utils'
-import { defineComponent, h } from 'vue'
+import ElementPlus from 'element-plus'
+import { flushPromises, mount } from '@vue/test-utils'
 import { beforeEach, expect, it, vi } from 'vitest'
-import { ElMessage, ElMessageBox } from 'element-plus'
 import SmartDispatchDialog from './SmartDispatchDialog.vue'
-import { listDispatchCandidates, listDispatchDrafts, preArrangeDispatch, preArrangeDraftDispatch, lockDispatchDraftPallet, unlockDispatchDraftPallet, releaseDispatchDraft, deleteDispatchDraftContainer, type DispatchPalletCandidateDto, type DispatchDraftDto } from '../api/dispatches'
-
-vi.mock('vue-router', () => ({ useRouter: () => ({ push: vi.fn() }) }))
-vi.mock('element-plus', () => ({ ElMessage: { warning: vi.fn(), success: vi.fn(), error: vi.fn() }, ElMessageBox: { confirm: vi.fn() } }))
-vi.mock('../api/dispatches', () => ({
-  listDispatchCandidates: vi.fn(), listDispatchDrafts: vi.fn(), preArrangeDispatch: vi.fn(), preArrangeDraftDispatch: vi.fn(),
-  createDispatchDraftContainer: vi.fn(), deleteDispatchDraftContainer: vi.fn(),
-  lockDispatchDraftPallet: vi.fn(), unlockDispatchDraftPallet: vi.fn(),
-  releaseDispatchDraft: vi.fn(),
-}))
-
-const shell = defineComponent({ setup(_, { slots }) { return () => h('section', [slots.default?.(), slots.footer?.()]) } })
-const button = defineComponent({ props: { disabled: Boolean }, emits: ['click'], setup(props, { slots, emit }) {
-  return () => h('button', { disabled: props.disabled, onClick: () => emit('click') }, slots.default?.())
-} })
-const retry = defineComponent({ emits: ['retry'], setup(_, { emit }) {
-  return () => h('button', { 'data-test': 'retry', onClick: () => emit('retry') }, '重试加载')
-} })
-const plan: DispatchPalletCandidateDto = { orderId: '1', orderNo: 'LM-A', planPalletId: '11', sourceType: 'INBOUND_PLAN',
-  warehousePalletId: '101', overseasWarehouseId: '92', customerId: 'A', palletNo: 'PAL-A', packageCount: 2, sourceStage: 'RECEIVED' }
-const returned: DispatchPalletCandidateDto = { orderId: '2', orderNo: 'LM-B', returnReceiptId: '22', returnReceiptNo: 'RSR-B', sourceType: 'RETURN_RECEIPT',
-  warehousePalletId: '102', overseasWarehouseId: '92', customerId: 'A', palletNo: 'PAL-B', packageCount: 2, sourceStage: 'RECEIVED' }
-
-beforeEach(() => vi.resetAllMocks())
-
-function mountDraft() {
-  return shallowMount(SmartDispatchDialog, { props: { modelValue: true, orders: [] }, global: {
-    stubs: { AppDialog: shell, ElButton: button, LoadErrorState: retry, ElDialog: true,
-      ElInput: true, ElOption: true, ElSelect: true, ElTable: true, ElTableColumn: true,
-      ElTag: shell, ElDropdown: true, ElDropdownMenu: true, ElDropdownItem: true,
-      ElEmpty: true, ElRadio: true, ElRadioGroup: true },
-  } })
-}
-const secondPlan = { ...plan, orderId: '3', orderNo: 'LM-C', planPalletId: '13', warehousePalletId: '103', palletNo: 'PAL-C' }
-const thirdPlan = { ...plan, orderId: '4', orderNo: 'LM-D', planPalletId: '14', warehousePalletId: '104', palletNo: 'PAL-D' }
-const twoGroups: DispatchDraftDto = { draftToken: 'original-draft', containers: [
-  { id: 'container-1', capacity: 30, palletIds: ['11', '13'] },
-  { id: 'container-2', capacity: 30, palletIds: ['14', 'RETURN:22'] },
-  { id: 'empty-container', capacity: 15, palletIds: [] },
-] }
-const expectedBatch = { draftToken: 'original-draft', groups: [
-  { draftContainerId: 'container-1', planPalletIds: ['11', '13'], returnReceiptIds: [] },
-  { draftContainerId: 'container-2', planPalletIds: ['14'], returnReceiptIds: ['22'] },
-] }
-const goodResult = [{ draftContainerId: 'container-2', dispatch: { id: '102', dispatchNo: 'DS-2', appointmentBatches: [] } },
-  { draftContainerId: 'container-1', dispatch: { id: '101', dispatchNo: 'DS-1', appointmentBatches: [] } }]
-async function submitDraft(wrapper: ReturnType<typeof mountDraft>) {
-  await wrapper.findAll('button').find(node => node.text() === '预排车')!.trigger('click')
-  await flushPromises()
-}
-
-it('keeps two explicit groups in one atomic request, omits empty containers and accepts reordered matching results', async () => {
-  vi.mocked(listDispatchDrafts).mockResolvedValue([twoGroups])
-  vi.mocked(listDispatchCandidates).mockResolvedValue([plan, secondPlan, thirdPlan, returned])
-  vi.mocked(preArrangeDraftDispatch).mockResolvedValue(goodResult)
-  const wrapper = mountDraft(); await flushPromises(); await submitDraft(wrapper)
-  expect(preArrangeDraftDispatch).toHaveBeenCalledExactlyOnceWith(expectedBatch)
-  expect(preArrangeDispatch).not.toHaveBeenCalled()
-  expect(wrapper.emitted('created')).toHaveLength(1)
-  expect(wrapper.emitted('update:modelValue')).toEqual([[false]])
-  wrapper.unmount()
+import AppDialog from '@/shared/components/AppDialog.vue'
+import { listAllPlatformWarehouses } from '@/modules/warehouses'
+import * as api from '../api/dispatches'
+import { candidate, command, detail } 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 }) }))
+vi.mock('@/core/access/accessPreview', () => ({ useAccessPreviewStore: () => ({ can: () => true }) }))
+vi.mock('vue-router', () => ({ useRouter: () => ({ push }) }))
+vi.mock('@/modules/warehouses', () => ({ listAllPlatformWarehouses: vi.fn() }))
+vi.mock('./DispatchResourceFields.vue', () => ({ default: { template: '<div />' } }))
+vi.mock('../api/dispatches', () => ({ listDispatchDrafts: vi.fn(), listDispatchCandidates: vi.fn(), createDispatchDraft: vi.fn(), createDispatchDraftContainer: vi.fn(), lockDispatchDraftPallet: vi.fn(), unlockDispatchDraftPallet: vi.fn(), deleteDispatchDraftContainer: vi.fn(), releaseDispatchDraft: vi.fn(), convertDispatchDraft: vi.fn(), createDispatch: vi.fn(), getDispatch: vi.fn(), getDispatchCommand: vi.fn() }))
+const source = () => candidate(), draft = (): DispatchDraft => ({ draftToken: 'server-token', recordVersion: 0, status: 'ACTIVE', warehouseId: '321', containers: [{ draftContainerId: '100000000000000001', sequenceNo: 1, capacity: 30, sourceKeys: ['source-1'] }], sources: [source()], expiresAt: '2026-12-01T00:00:00Z' })
+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({ 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 => {
+  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])
+  vi.mocked(api.convertDispatchDraft).mockRejectedValueOnce(new Error('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)
+  try {
+    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()
+    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)
+  } finally { wrapper.unmount() }
 })
-
-it.each([
-  ['one collapsed result', goodResult.slice(0, 1)],
-  ['foreign container', [{ ...goodResult[0], draftContainerId: 'foreign' }, goodResult[1]]],
-  ['duplicate container', [goodResult[0], goodResult[0]]],
-  ['duplicate dispatch', [goodResult[0], { ...goodResult[1], dispatch: goodResult[0].dispatch }]],
-  ['missing business number', [goodResult[0], { ...goodResult[1], dispatch: { id: '101', dispatchNo: '', appointmentBatches: [] } }]],
-])('retains the original groups and token after %s', async (_label, result) => {
-  vi.mocked(listDispatchDrafts).mockResolvedValue([twoGroups])
-  vi.mocked(listDispatchCandidates).mockResolvedValue([plan, secondPlan, thirdPlan, returned])
-  vi.mocked(preArrangeDraftDispatch).mockResolvedValue(result)
-  const wrapper = mountDraft(); await flushPromises(); await submitDraft(wrapper)
-  expect(wrapper.emitted('created')).toBeUndefined()
-  expect(wrapper.emitted('update:modelValue')).toBeUndefined()
-  expect(wrapper.text()).toContain('托盘 4 · 箱数 8')
-  await submitDraft(wrapper)
-  expect(preArrangeDraftDispatch).toHaveBeenNthCalledWith(2, expectedBatch)
-  expect(preArrangeDispatch).not.toHaveBeenCalled()
-  wrapper.unmount()
+it.each([undefined, null, 'bad', 9007199254740992])('requires rereading a restored candidate with missing or invalid batch version %s', async recordVersion => {
+  const original = draft()
+  original.sources[0]!.appointmentBatches = [{ batchKey: 'FBA_APPOINTMENT:1', batchNo: 'AP-1', customerId: 'C1', recordVersion: recordVersion as Version, sources: [] }]
+  vi.mocked(api.listDispatchDrafts).mockResolvedValue([original])
+  const wrapper = mount(SmartDispatchDialog, options)
+  try {
+    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()
+    expect(api.convertDispatchDraft).not.toHaveBeenCalled(); expect(wrapper.text()).toContain('预约批次版本缺失或无效，请重新读取候选')
+  } finally { wrapper.unmount() }
 })
-
-it('retains all groups on batch rejection without issuing a flat request', async () => {
-  vi.mocked(listDispatchDrafts).mockResolvedValue([twoGroups])
-  vi.mocked(listDispatchCandidates).mockResolvedValue([plan, secondPlan, thirdPlan, returned])
-  vi.mocked(preArrangeDraftDispatch).mockRejectedValue(new Error('草稿来源已变化'))
-  const wrapper = mountDraft(); await flushPromises(); await submitDraft(wrapper)
-  expect(preArrangeDraftDispatch).toHaveBeenCalledTimes(1)
-  expect(preArrangeDispatch).not.toHaveBeenCalled()
-  expect(wrapper.emitted('created')).toBeUndefined()
-  expect(wrapper.text()).toContain('托盘 4 · 箱数 8')
-  wrapper.unmount()
+it('requires an explicit warehouse and allows saving a true empty dispatch with no fake cargo', async () => {
+  const wrapper = mount(SmartDispatchDialog, options); await flushPromises()
+  const state = wrapper.vm as unknown as { mode: string; warehouseId: string; submit: () => Promise<void> }
+  state.mode = 'empty'; await wrapper.getComponent(AppDialog).vm.$emit('confirm'); await flushPromises(); expect(api.createDispatch).not.toHaveBeenCalled()
+  state.warehouseId = '321'; vi.mocked(api.createDispatch).mockImplementation(async body => command('CREATE', body.idempotencyKey))
+  await state.submit(); await flushPromises()
+  expect(api.createDispatch).toHaveBeenCalledWith(expect.objectContaining({ warehouseId: '321', cargo: [], vehicle: null, driver: null }))
+  expect(wrapper.emitted('created')).toHaveLength(1); wrapper.unmount()
 })
-
-it('does not submit a physical pallet fallback when its actual plan source identity is missing', async () => {
-  vi.mocked(listDispatchDrafts).mockResolvedValue([{ draftToken: 'original-draft', containers: [
-    { id: 'container', capacity: 30, palletIds: ['101'] },
-  ] }])
-  vi.mocked(listDispatchCandidates).mockResolvedValue([{ ...plan, planPalletId: undefined }])
-  const wrapper = mountDraft(); await flushPromises(); await submitDraft(wrapper)
-  expect(preArrangeDraftDispatch).not.toHaveBeenCalled()
-  expect(preArrangeDispatch).not.toHaveBeenCalled()
-  expect(ElMessage.warning).toHaveBeenCalledWith(expect.stringContaining('来源标识缺失'))
-  expect(wrapper.emitted('update:modelValue')).toBeUndefined()
-  wrapper.unmount()
+it('restores an explicit draft and submits complete server source versions in each container', async () => {
+  const original = draft(); original.sources.push(candidate({ sourceKey: 'source-B', customerId: 'B', customerName: '客户乙' })); original.containers[0]!.sourceKeys.push('source-B')
+  vi.mocked(api.listDispatchDrafts).mockResolvedValue([original])
+  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, 'PC/1') })) }))
+  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 flushPromises()
+  expect(api.convertDispatchDraft).toHaveBeenCalledWith(expect.objectContaining({ recordVersion: 0, draftToken: 'server-token', groups: [expect.objectContaining({ draftContainerId: '100000000000000001', dispatch: expect.objectContaining({ cargo: [source().selection, source().selection] }) })] }))
+  expect(wrapper.emitted('created')).toHaveLength(1); wrapper.unmount()
 })
-
-it('submits relabel physical pallet identity without requiring an inbound plan pallet', async () => {
-  vi.mocked(listDispatchDrafts).mockResolvedValue([{ draftToken: 'relabel-draft', containers: [
-    { id: 'container', capacity: 30, palletIds: ['101'] },
-  ] }])
-  vi.mocked(listDispatchCandidates).mockResolvedValue([{ ...plan, planPalletId: null, sourceStage: 'RELABEL', orderRefs: 'RL-1' }])
-  vi.mocked(preArrangeDispatch).mockResolvedValue({ id: '1', dispatchNo: 'DS-1', appointmentBatches: [] })
-  const wrapper = mountDraft(); await flushPromises(); await submitDraft(wrapper)
-  expect(preArrangeDispatch).toHaveBeenCalledExactlyOnceWith({ planPalletIds: ['101'], returnReceiptIds: [], relabelNo: 'RL-1' })
-  expect(preArrangeDraftDispatch).not.toHaveBeenCalled()
-  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 () => {
+  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()
 })
-
-it('does not send a second batch while the original command is pending', async () => {
-  vi.mocked(listDispatchDrafts).mockResolvedValue([twoGroups])
-  vi.mocked(listDispatchCandidates).mockResolvedValue([plan, secondPlan, thirdPlan, returned])
-  let resolveCommand!: (result: typeof goodResult) => void
-  vi.mocked(preArrangeDraftDispatch).mockReturnValue(new Promise(resolve => { resolveCommand = resolve }))
-  const wrapper = mountDraft(); await flushPromises(); await submitDraft(wrapper); await submitDraft(wrapper)
-  expect(preArrangeDraftDispatch).toHaveBeenCalledExactlyOnceWith(expectedBatch)
-  expect(wrapper.emitted('created')).toBeUndefined()
-  resolveCommand(goodResult); await flushPromises()
-  expect(wrapper.emitted('created')).toHaveLength(1)
-  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'))
+  const wrapper = mount(SmartDispatchDialog, options); await flushPromises(); expect(wrapper.text()).toContain('排车候选或草稿恢复失败'); expect(api.convertDispatchDraft).not.toHaveBeenCalled(); wrapper.unmount()
 })
-
-it('keeps group membership frozen while the submitted batch is awaiting its response', async () => {
-  vi.mocked(listDispatchDrafts).mockResolvedValue([twoGroups])
-  vi.mocked(listDispatchCandidates).mockResolvedValue([plan, secondPlan, thirdPlan, returned])
-  let resolveCommand!: (result: typeof goodResult) => void
-  vi.mocked(preArrangeDraftDispatch).mockReturnValue(new Promise(resolve => { resolveCommand = resolve }))
-  const wrapper = mountDraft(); await flushPromises(); await submitDraft(wrapper)
-  await wrapper.findAll('button').find(node => node.text() === '移除')!.trigger('click')
-  await wrapper.findAll('button').find(node => node.attributes('aria-label') === '删除装车车型1')!.trigger('click')
-  await flushPromises()
-  expect(unlockDispatchDraftPallet).not.toHaveBeenCalled()
-  expect(deleteDispatchDraftContainer).not.toHaveBeenCalled()
-  expect(wrapper.text()).toContain('托盘 4 · 箱数 8')
-  resolveCommand(goodResult); await flushPromises()
-  expect(wrapper.emitted('created')).toHaveLength(1)
-  wrapper.unmount()
+it('refuses an incomplete candidate page without pretending its filtered rows are all available cargo', async () => {
+  vi.mocked(api.listDispatchCandidates).mockResolvedValue({ candidates: [], 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.text()).toContain('尚未完整返回'); wrapper.unmount()
 })
-
-it('retains unresolved sources when retry hydration still cannot recover the complete original draft', async () => {
-  vi.mocked(listDispatchDrafts).mockResolvedValue([twoGroups])
-  vi.mocked(listDispatchCandidates).mockResolvedValue([plan, returned])
-  const wrapper = mountDraft(); await flushPromises(); await submitDraft(wrapper)
-  expect(preArrangeDraftDispatch).not.toHaveBeenCalled()
-  expect(preArrangeDispatch).not.toHaveBeenCalled()
-  expect(ElMessage.warning).toHaveBeenCalledWith(expect.stringContaining('原选择已保留'))
-  expect(wrapper.emitted('update:modelValue')).toBeUndefined()
-  wrapper.unmount()
+it('keeps vehicle assignments independent between containers and reuses a proven conversion after a detail read fails', 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; vehicle: { vehicleId: string | null }; form: { remark: string } }
+  state.restoreDraft('server-token'); await flushPromises(); state.vehicle.vehicleId = 'vehicle-A'; state.form.remark = '车甲'
+  state.activeContainerId = 'container-B'; state.vehicle.vehicleId = 'vehicle-B'; state.form.remark = '车乙'
+  await state.submit(); expect(wrapper.emitted('created')).toBeUndefined()
+  await state.submit(); expect(api.convertDispatchDraft).toHaveBeenCalledTimes(1)
+  const groups = vi.mocked(api.convertDispatchDraft).mock.calls[0]![0].groups
+  expect(groups.map(group => [group.dispatch.vehicle?.vehicleId, group.dispatch.remark])).toEqual([['vehicle-A', '车甲'], ['vehicle-B', '车乙']])
+  expect(wrapper.emitted('created')).toHaveLength(1); wrapper.unmount()
 })
-
-it.each([
-  { ...twoGroups, containers: [{ id: 'c1', capacity: 30, palletIds: ['11'] }, { id: 'c2', capacity: 30, palletIds: ['11'] }] },
-  { ...twoGroups, containers: [{ id: 'c1', capacity: 30, palletIds: ['11'] }, { id: 'c1', capacity: 30, palletIds: ['13'] }] },
-  { ...twoGroups, containers: [{ id: '', capacity: 30, palletIds: ['11'] }] },
-])('rejects duplicate sources or invalid container identities before writing', async draft => {
-  vi.mocked(listDispatchDrafts).mockResolvedValue([draft])
-  vi.mocked(listDispatchCandidates).mockResolvedValue([plan, secondPlan])
-  const wrapper = mountDraft(); await flushPromises(); await submitDraft(wrapper)
-  expect(preArrangeDraftDispatch).not.toHaveBeenCalled()
-  expect(preArrangeDispatch).not.toHaveBeenCalled()
-  expect(wrapper.emitted('update:modelValue')).toBeUndefined()
-  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.text()).toContain('从列表的原请求恢复入口'); wrapper.unmount()
 })
-
-it('rejects a relabel order split across multiple containers before either API command', async () => {
-  const relabel: DispatchPalletCandidateDto = { ...plan, sourceStage: 'RELABEL', orderRefs: 'RL-1' }
-  vi.mocked(listDispatchDrafts).mockResolvedValue([{ draftToken: 'original-draft', containers: [
-    { id: 'c1', capacity: 30, palletIds: ['101'] }, { id: 'c2', capacity: 30, palletIds: ['103'] },
-  ] }])
-  vi.mocked(listDispatchCandidates).mockResolvedValue([relabel, { ...secondPlan, sourceStage: 'RELABEL', orderRefs: 'RL-1' }])
-  const wrapper = mountDraft(); await flushPromises(); await submitDraft(wrapper)
-  expect(preArrangeDispatch).not.toHaveBeenCalled()
-  expect(preArrangeDraftDispatch).not.toHaveBeenCalled()
-  expect(ElMessage.warning).toHaveBeenCalledWith(expect.stringContaining('一组排车'))
-  expect(wrapper.emitted('update:modelValue')).toBeUndefined()
-  wrapper.unmount()
-})
-
-it('keeps one complete relabel order on the single-dispatch endpoint', async () => {
-  vi.mocked(listDispatchDrafts).mockResolvedValue([{ draftToken: 'original-draft', containers: [
-    { id: 'c1', capacity: 30, palletIds: ['101', '103'] },
-  ] }])
-  vi.mocked(listDispatchCandidates).mockResolvedValue([plan, secondPlan].map(p => ({ ...p, sourceStage: 'RELABEL', orderRefs: 'RL-1' })))
-  vi.mocked(preArrangeDispatch).mockResolvedValue({ id: '1', dispatchNo: 'DS-RL', appointmentBatches: [] })
-  const wrapper = mountDraft(); await flushPromises(); await submitDraft(wrapper)
-  expect(preArrangeDispatch).toHaveBeenCalledExactlyOnceWith({ planPalletIds: ['101', '103'], returnReceiptIds: [], relabelNo: 'RL-1' })
-  expect(preArrangeDraftDispatch).not.toHaveBeenCalled()
-  expect(wrapper.emitted('created')).toHaveLength(1)
-  wrapper.unmount()
-})
-
-it('retains every restored selection on candidate failure and submits both sources only after retry hydration', async () => {
-  vi.mocked(preArrangeDraftDispatch).mockResolvedValue([{ draftContainerId: 'container', dispatch: { id: '1', dispatchNo: 'DS-1', appointmentBatches: [] } }])
-  vi.mocked(listDispatchDrafts).mockResolvedValue([{ draftToken: 'original-draft', containers: [{ id: 'container', capacity: 30, palletIds: ['11', 'RETURN:22'] }] }])
-  vi.mocked(listDispatchCandidates)
-    .mockResolvedValueOnce([plan])
-    .mockRejectedValueOnce(new Error('恢复来源失败'))
-    .mockResolvedValueOnce([plan])
-    .mockResolvedValueOnce([plan, returned])
-  const wrapper = shallowMount(SmartDispatchDialog, { props: { modelValue: true, orders: [] }, global: {
-    stubs: { AppDialog: shell, ElButton: button, LoadErrorState: retry, ElDialog: true,
-      ElInput: true, ElOption: true, ElSelect: true, ElTable: true, ElTableColumn: true,
-      ElTag: true, ElDropdown: true, ElDropdownMenu: true, ElDropdownItem: true,
-      ElEmpty: true, ElRadio: true, ElRadioGroup: true },
-  } })
-  await flushPromises()
-  const submit = () => wrapper.findAll('button').find(node => node.text() === '预排车')!
-  await submit().trigger('click')
-  await flushPromises()
-  expect(preArrangeDispatch).not.toHaveBeenCalled()
-  expect(preArrangeDraftDispatch).not.toHaveBeenCalled()
-  expect(ElMessage.warning).toHaveBeenCalledWith(expect.stringContaining('原选择已保留'))
-  expect(wrapper.emitted('update:modelValue')).toBeUndefined()
-  await wrapper.get('[data-test="retry"]').trigger('click')
-  await flushPromises()
-  await submit().trigger('click')
-  await flushPromises()
-  expect(preArrangeDraftDispatch).toHaveBeenCalledExactlyOnceWith({ draftToken: 'original-draft', groups: [{ draftContainerId: 'container', planPalletIds: ['11'], returnReceiptIds: ['22'] }] })
-  expect(preArrangeDispatch).not.toHaveBeenCalled()
-  expect(listDispatchCandidates).toHaveBeenLastCalledWith({ draftToken: 'original-draft' })
-  expect(wrapper.emitted('created')).toHaveLength(1)
-  wrapper.unmount()
-})
-
-it('shows a draft recovery error and only loads candidates after a successful retry with the original token', async () => {
-  vi.mocked(listDispatchDrafts).mockRejectedValueOnce(new Error('草稿查询超时')).mockResolvedValueOnce([twoGroups])
-  vi.mocked(listDispatchCandidates).mockResolvedValue([plan, secondPlan, thirdPlan, returned])
-  vi.mocked(preArrangeDraftDispatch).mockResolvedValue(goodResult)
-  const wrapper = mountDraft(); await flushPromises()
-  expect(wrapper.get('[data-test="retry"]').attributes('title')).toBe('排车草稿恢复失败')
-  expect(listDispatchCandidates).not.toHaveBeenCalled()
-  expect(preArrangeDraftDispatch).not.toHaveBeenCalled()
-  await wrapper.get('[data-test="retry"]').trigger('click'); await flushPromises()
-  expect(wrapper.text()).toContain('托盘 4 · 箱数 8')
-  await submitDraft(wrapper)
-  expect(preArrangeDraftDispatch).toHaveBeenCalledExactlyOnceWith(expectedBatch)
-  wrapper.unmount()
-})
-
-it('keeps local relabel choices on close and reopen while describing their actual unlocked state', async () => {
-  const relabel: DispatchPalletCandidateDto = { ...plan, sourceStage: 'RELABEL', orderRefs: 'RL-1' }
-  vi.mocked(listDispatchDrafts).mockResolvedValue([{ draftToken: 'local-relabel', containers: [{ id: 'c1', capacity: 30, palletIds: [] }] }])
-  vi.mocked(listDispatchCandidates).mockResolvedValue([relabel])
-  const wrapper = mountDraft(); await flushPromises()
-  wrapper.getComponent({ name: 'ElDropdown' }).vm.$emit('command', 'c1'); await flushPromises()
-  expect(lockDispatchDraftPallet).not.toHaveBeenCalled()
-  expect(wrapper.text()).toContain('已选择，尚未锁定')
-  await wrapper.setProps({ modelValue: false }); await wrapper.setProps({ modelValue: true }); await flushPromises()
-  expect(wrapper.text()).toContain('托盘 1 · 箱数 2')
-  expect(wrapper.text()).toContain('已选择，尚未锁定')
-  expect(listDispatchDrafts).toHaveBeenCalledTimes(2)
-  await wrapper.findAll('button').find(node => node.text() === '移除')!.trigger('click'); await flushPromises()
-  expect(unlockDispatchDraftPallet).not.toHaveBeenCalled()
-  expect(wrapper.text()).toContain('托盘 0 · 箱数 0')
-  wrapper.unmount()
-})
-
-it.each(['RELABEL_APPLICATION', 'RETURN_RELABEL'])('rejects a partial %s application after refreshing its complete candidate set', async orderType => {
-  const relabel = { ...plan, sourceStage: 'RELABEL' as const, orderRefs: 'RL-1', orderType }
-  vi.mocked(listDispatchDrafts).mockResolvedValue([{ draftToken: 'local-relabel', containers: [{ id: 'c1', capacity: 30, palletIds: ['101'] }] }])
-  vi.mocked(listDispatchCandidates).mockResolvedValue([relabel, { ...relabel, planPalletId: '13', warehousePalletId: '103' }])
-  const wrapper = mountDraft(); await flushPromises(); await submitDraft(wrapper)
-  expect(listDispatchCandidates).toHaveBeenLastCalledWith({ sourceStage: 'RELABEL', orderNo: 'RL-1', draftToken: 'local-relabel' })
-  expect(preArrangeDispatch).not.toHaveBeenCalled()
-  expect(preArrangeDraftDispatch).not.toHaveBeenCalled()
-  expect(wrapper.getComponent({ name: 'OperationErrorToast' }).props('details')?.message).toContain('全部应排托盘')
-  expect(wrapper.text()).toContain('托盘 1 · 箱数 2')
-  expect(wrapper.emitted('created')).toBeUndefined()
-  wrapper.unmount()
-})
-
-it('preserves all previous selections when reopening fails to read drafts, then recovers the same groups on retry', async () => {
-  vi.mocked(listDispatchDrafts).mockResolvedValueOnce([twoGroups]).mockRejectedValueOnce(new Error('查询超时')).mockResolvedValueOnce([twoGroups])
-  vi.mocked(listDispatchCandidates).mockResolvedValue([plan, secondPlan, thirdPlan, returned])
-  vi.mocked(preArrangeDraftDispatch).mockResolvedValue(goodResult)
-  const wrapper = mountDraft(); await flushPromises()
-  await wrapper.setProps({ modelValue: false }); await wrapper.setProps({ modelValue: true }); await flushPromises()
-  expect(wrapper.get('[data-test="retry"]').attributes('title')).toBe('排车草稿恢复失败')
-  expect(listDispatchCandidates).toHaveBeenCalledTimes(1)
-  expect(wrapper.findAll('button').find(button => button.text() === '预排车')!.attributes('disabled')).toBeDefined()
-  await wrapper.get('[data-test="retry"]').trigger('click'); await flushPromises()
-  expect(wrapper.text()).toContain('托盘 4 · 箱数 8')
-  await submitDraft(wrapper)
-  expect(preArrangeDraftDispatch).toHaveBeenCalledExactlyOnceWith(expectedBatch)
-  wrapper.unmount()
-})
-
-it('requires explicit release to restart an expired draft and keeps choices when release fails', async () => {
-  vi.mocked(listDispatchDrafts).mockResolvedValueOnce([twoGroups]).mockResolvedValue([])
-  vi.mocked(listDispatchCandidates).mockResolvedValue([plan, secondPlan, thirdPlan, returned])
-  vi.mocked(ElMessageBox.confirm).mockResolvedValue('confirm' as Awaited<ReturnType<typeof ElMessageBox.confirm>>)
-  vi.mocked(releaseDispatchDraft).mockRejectedValueOnce(new Error('释放超时')).mockResolvedValueOnce(null)
-  const wrapper = mountDraft(); await flushPromises()
-  await wrapper.setProps({ modelValue: false }); await wrapper.setProps({ modelValue: true }); await flushPromises()
-  expect(wrapper.get('[data-test="retry"]').attributes('message')).toContain('原草稿已失效')
-  expect(releaseDispatchDraft).not.toHaveBeenCalled()
-  const restart = () => wrapper.findAll('button').find(button => button.text() === '释放草稿并重新选择')!
-  await restart().trigger('click'); await flushPromises()
-  expect(releaseDispatchDraft).toHaveBeenLastCalledWith('original-draft')
-  expect(wrapper.get('[data-test="retry"]').attributes('message')).toContain('原选择已保留')
-  await restart().trigger('click'); await flushPromises()
-  expect(releaseDispatchDraft).toHaveBeenNthCalledWith(2, 'original-draft')
-  expect(wrapper.find('[data-test="retry"]').exists()).toBe(false)
-  expect(wrapper.text()).toContain('托盘 0 · 箱数 0')
-  wrapper.unmount()
-})
-
-it.each([plan, returned])('does not claim a failed source lock succeeded for $sourceType', async candidate => {
-  vi.mocked(listDispatchDrafts).mockResolvedValue([{ draftToken: 'lock-draft', containers: [{ id: 'c1', capacity: 30, palletIds: [] }] }])
-  vi.mocked(listDispatchCandidates).mockResolvedValue([candidate])
-  vi.mocked(lockDispatchDraftPallet).mockRejectedValueOnce({ isAxiosError: true, response: { status: 409, data: { code: 'A0409', message: '来源已被其他草稿锁定', requestId: 'lock-request', traceId: 'lock-trace' } } }).mockResolvedValueOnce(null)
-  const wrapper = mountDraft(); await flushPromises()
-  wrapper.getComponent({ name: 'ElDropdown' }).vm.$emit('command', 'c1'); await flushPromises()
-  expect(wrapper.text()).toContain('托盘 0 · 箱数 0')
-  expect(wrapper.getComponent({ name: 'OperationErrorToast' }).props('details')).toMatchObject({ message: '来源已被其他草稿锁定', requestId: 'lock-request', traceId: 'lock-trace' })
-  wrapper.getComponent({ name: 'ElDropdown' }).vm.$emit('command', 'c1'); await flushPromises()
-  expect(wrapper.text()).toContain('托盘 1 · 箱数 2')
-  expect(wrapper.text()).toContain('已锁定')
-  expect(lockDispatchDraftPallet).toHaveBeenLastCalledWith(candidate.sourceType === 'RETURN_RECEIPT' ? 'RETURN:22' : '11', 'lock-draft', 'c1')
-  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 }] }]
+  vi.mocked(api.listDispatchDrafts).mockResolvedValue([original])
+  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()
+  expect(api.convertDispatchDraft).not.toHaveBeenCalled(); expect(wrapper.text()).toContain('预约客户不一致'); wrapper.unmount()
 })

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

@@ -0,0 +1,63 @@
+import { beforeEach, expect, it, vi } from 'vitest'
+import { ApiResponseError } from '@/shared/api/http'
+import { useDispatchCommandRecovery } from './dispatchCommandRecovery'
+import { command } from './dispatchTestFixtures'
+beforeEach(() => sessionStorage.clear())
+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', 'DEPART', { recordVersion: 0, idempotencyKey: 'key', remark: 'original' })
+  const send = vi.fn().mockRejectedValueOnce(new Error('network unknown')).mockResolvedValueOnce(command('DEPART'))
+  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('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')
+  await recovery.execute(send, read, find)
+  expect(send).toHaveBeenCalledTimes(1); expect(find).not.toHaveBeenCalled()
+})
+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('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()
+})
+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', 'DEPART', { recordVersion: 0, idempotencyKey: 'key' })
+  const read = vi.fn()
+  await expect(recovery.execute(vi.fn().mockResolvedValue(command('DEPART', 'different')), read, vi.fn())).rejects.toThrow('不一致')
+  expect(read).not.toHaveBeenCalled(); expect(recovery.pending.value).not.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', 'DEPART', { recordVersion: '9007199254740992', idempotencyKey: 'key' })
+  const send = vi.fn().mockResolvedValue({ ...command('DEPART'), 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)
+})

src/modules/overseas-warehouse/dispatchCommandRecovery.ts

@@ -0,0 +1,82 @@
+import { ref } from 'vue'
+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 }
+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>> }>()
+export function isDefiniteDispatchRejection(error: unknown) {
+  return error instanceof ApiResponseError && /^(?:A0|HTTP_)?(?:400|401|403|404|409|410|422)$/.test(String(error.code))
+}
+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('操作结果与原排车请求不一致，请保留原请求核对')
+  requireVersion(result.recordVersion)
+  if (pending.action === 'DEPART' && result.stage !== 'DELIVERING') throw new Error('发车结果未确认派送中，请核对原请求')
+  if (pending.action === 'LOADING_COMPLETE' && result.stage !== 'AFTER_LOADING') 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('详情版本早于已确认操作，请保留原请求重读')
+}
+
+/** 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
+  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 (!existing) sessions.set(owner, { pending, busy })
+  function persist() {
+    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'> = {}) {
+    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()
+  }
+  async function execute(send: (command: PendingDispatchCommand) => Promise<CommandResult>, read: (dispatchNo: string) => Promise<unknown>, find: (dispatchNo: string, key: string) => Promise<CommandResult>) {
+    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)) command.rejected = true
+          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 }
+  }
+  function discardRejected() {
+    if (busy.value || !pending.value?.rejected) return
+    pending.value = null; persist()
+  }
+  return { pending, busy, begin, execute, discardRejected }
+}

src/modules/overseas-warehouse/dispatchContracts.ts

@@ -0,0 +1,100 @@
+// Models after the dispatch API boundary: Long quantities are validated safe numbers.
+// dispatchWire.ts declares their HTTP string/number representation; IDs/versions remain lossless.
+export type Version = string | number
+export class DispatchInputError extends Error {}
+export type DispatchStatus = 'ACTIVE' | 'CANCELLED'
+export type DispatchStage = 'BEFORE_LOADING' | 'LOADING' | 'AFTER_LOADING' | 'DELIVERING' | 'DELIVERED'
+export type DispatchAction = 'CREATE' | 'EDIT' | 'ADD_CARGO' | 'REMOVE_CARGO' | 'CANCEL' | 'SUBMIT_REVIEW' | 'DISPATCH_REVIEW' | 'LOADING_REVIEW' | 'RETURN_TO_REVIEW' | 'PICK' | 'LOADING_COMPLETE' | 'ARRANGE_DELIVERY' | 'DEPART'
+export type ReviewStatus = 'NOT_SUBMITTED' | 'PENDING' | 'APPROVED' | 'REJECTED'
+export type BeforeLoadingSection = 'VEHICLE_INFO' | 'DISPATCH_REVIEW' | 'LOADING_REVIEW'
+export interface Gate { allowed: boolean; blockCode: string | null; blockReason: string | null }
+export type DispatchActions = Partial<Record<DispatchAction, Gate>>
+export interface Counts { itemCount: number; palletCount: number; packageCount: number; pickedPackageCount: number; shippedPackageCount: number }
+export interface Capacity { palletSpaces: number | null; maxLoadKg: number | null; maxVolumeCbm: number | null }
+export interface DriverEvidence { licenseNo: string | null; licenseExpiresOn: string | null; fileIds: string[]; expectedTaskEndAt: string | null }
+export interface Vehicle { mode: 'MASTER' | 'EXTERNAL'; vehicleId: string | null; plate: string | null; carrierName: string | null; capacity: Capacity | null; evidenceFileIds: string[] }
+export interface Driver { mode: 'MASTER' | 'EXTERNAL'; driverId: string | null; name: string | null; phone: string | null; evidence: DriverEvidence | null }
+export interface VehicleSnapshot extends Vehicle { vehicleStatus: string | null }
+export interface Resources { vehicle: VehicleSnapshot | null; driver: Driver | null }
+export interface Destination { key: string; type: string; warehouseId: string | null; warehouseCode: string | null; warehouseName: string | null; address: string | null; postalCode: string | null; contactName: string | null; contactPhone: string | null }
+export interface Review { status: ReviewStatus; reason: string | null; reviewerId: string | null; reviewedAt: string | null; reviewRound: Version; basisHash: string | null; invalidatedReason: string | null }
+export interface Reviews { dispatchReview: Review; loadingReview: Review }
+export interface DispatchBatchReference { batchKey: string; batchNo: string | null; customerId: string; sources: Array<{ sourceKey: string; destinationKey: string; packageCount: number }>; recordVersion: Version }
+export interface DispatchBatchAllocation { planPalletId: string; batchKey: string; customerId: string; sourceKey: string; destinationKey: string; packageCount: number; recordVersion: Version }
+export interface DispatchQuery { page: number; size: number; dispatchNo?: string; vehiclePlate?: string; warehouseId?: string; customerId?: string; fbaAppointmentNo?: string; status?: DispatchStatus | 'ALL'; stage?: DispatchStage; beforeLoadingSection?: BeforeLoadingSection; reviewStatus?: ReviewStatus }
+export interface ReviewCounts { notSubmitted: number; pending: number; approved: number; rejected: number }
+export interface DispatchStatistics { matchedTotal: number; activeTotal: number; cancelledTotal: number; stageCounts: Record<DispatchStage, number>; beforeLoadingReviewCounts: { vehicleInfoTotal: number; dispatchReview: ReviewCounts; loadingReview: ReviewCounts } }
+export interface DispatchListRow { dispatchNo: string; status: DispatchStatus; stage: DispatchStage; recordVersion: Version; reviewState: string; reviews: Reviews; resources: Resources; warehouseId: string; warehouseCode: string; warehouseName: string; plannedDepartureAt: string | null; departedAt: string | null; counts: Counts; pickingReconciled: boolean; arranged: boolean; actions: DispatchActions }
+export interface DispatchPage { records: DispatchListRow[]; total: number; page: number; size: number; pages: number; statistics: DispatchStatistics; snapshotAt: string }
+export interface OutboundReference { customerId: string; customerName: string; outboundNo: string; status: string; packageCount: number; palletCount: number }
+export interface DeliveryReference { groupKey: string; customerId: string; customerName: string; outboundNo: string; deliveryNo: string; destination: Destination; status: string; packageCount: number; palletCount: number }
+export interface VehicleAppointment { referenceNo: string; status: string; appointmentAt: string | null }
+export interface FbaAppointment { batchKey: string; batchNo: string | null; appointmentNo: string | null; destinationKey: string; destinationWarehouseCode: string | null; status: string; confirmedAt: string | null; blockReason: string | null }
+export interface OrderDetail { customerId: string; customerName: string; orderNo: string; inboundCode: string | null; grossWeightKg: number | null; palletCount: number | null; destinationFbaWarehouse: string | null; volumeCbm: number | null; containerNo: string | null; sourceKey: string }
+export interface DispatchDetail { dispatchNo: string; status: DispatchStatus; stage: DispatchStage; recordVersion: Version; reviewState: string; reviews: Reviews; counts: Counts; pickingReconciled: boolean; actions: DispatchActions; vehicleInfo: Resources; dispatchInfo: { route: string | null; plannedDepartureAt: string | null; departedAt: string | null; estimatedArrivalAt: string | null; fbaAppointments: FbaAppointment[]; vehicleAppointment: VehicleAppointment | null; appointmentBatches: DispatchBatchReference[] }; documents: { dispatchNo: string; outbounds: OutboundReference[]; deliveries: DeliveryReference[]; createdAt: string; updatedAt: string; remark: string | null }; orderDetails: OrderDetail[] }
+export interface CargoSelection { sourceType: 'INBOUND_PLAN' | 'RETURN_RECEIPT' | 'RELABEL'; planPalletId: string | null; returnReceiptId: string | null; relabelNo: string | null; warehousePalletId: string | null; sourceVersion: string }
+export interface CreateDispatch { idempotencyKey: string; warehouseId: string; vehicle: Vehicle | null; driver: Driver | null; plannedDepartureAt: string | null; estimatedArrivalAt: string | null; remark: string | null; cargo: CargoSelection[]; batchAllocations: DispatchBatchAllocation[] }
+export interface VersionCommand { recordVersion: Version; idempotencyKey: string }
+export interface UpdateDispatch extends VersionCommand { vehicle: Vehicle | null; driver: Driver | null; plannedDepartureAt: string | null; estimatedArrivalAt: string | null; vehicleAppointment?: { referenceNo: string; recordVersion: Version } | null; remark: string | null }
+export interface AddCargo extends VersionCommand { cargo: CargoSelection[]; batchAllocations: DispatchBatchAllocation[] }
+export interface ReasonCommand extends VersionCommand { reason: string }
+export interface ReviewCommand extends VersionCommand { decision: 'APPROVED' | 'REJECTED'; reason: string | null }
+export interface LoadingMeasurement { warehousePalletId: string; palletSpaces: number; weightKg: number; volumeCbm: number; deliveryIndex: number }
+export interface ConfirmedLoad { manifestHash: string; pallets: LoadingMeasurement[]; operatorId: string; confirmedAt: string }
+export interface LoadingComplete extends VersionCommand { manifestHash: string; measurements: LoadingMeasurement[]; remark: string | null }
+export interface LoadingPreview { dispatchNo: string; recordVersion: Version; status: DispatchStatus; stage: DispatchStage; manifestHash: string; pickingReconciled: boolean; resources: Resources; pallets: Array<{ warehousePalletId: string; palletNo: string; scheduledPackages: number; pickedPackages: number; palletSpaces: number | null; weightKg: number | null; volumeCbm: number | null; deliveryIndex: number | null; missingFields: string[]; evidence: Array<{ field: string; sourceType: string; sourceBusinessNo: string | null; observedAt: string | null; value: number | null; actual: boolean }> }>; confirmedLoad: ConfirmedLoad | null; loadingComplete: Gate; missingFields: string[] }
+export interface Candidate { selection: CargoSelection; sourceKey: string; sourceVersion: string; customerId: string; customerName: string; warehouseId: string; warehouseCode: string; warehouseName: string; orderNo: string | null; inboundCode: string | null; planNo: string | null; palletNo: string | null; containerNo: string | null; destination: Destination; availablePackages: number; suggestedWeightKg: number | null; suggestedVolumeCbm: number | null; measurementSource: string | null; appointmentBatches: DispatchBatchReference[]; blockReasons: string[] }
+export interface CandidateQuery { warehouseId?: string; planIds?: string[]; orderNo?: string; destinationWarehouseCode?: string; sourceStage?: string; draftToken?: string }
+export interface DispatchCargoItem { dispatchItemId: string; customerId: string; customerName: string; sourceKey: string; sourceVersion: string; sourceType: CargoSelection['sourceType']; planPalletId: string | null; returnReceiptId: string | null; relabelNo: string | null; warehousePalletId: string | null; palletNo: string | null; orderNo: string | null; inboundCode: string | null; destination: Destination; scheduledPackages: number; pickedPackages: number; remove: Gate }
+export interface DispatchItems { dispatchNo: string; recordVersion: Version; status: DispatchStatus; stage: DispatchStage; items: DispatchCargoItem[] }
+export interface DispatchRouteStop { index: number; name: string; address: string | null; destinationKey: string | null }
+export interface DispatchRoute { dispatchNo: string; recordVersion: Version; stops: DispatchRouteStop[]; edit: Gate }
+export interface DispatchRouteCommand extends VersionCommand { destinationKeys: string[]; reason: string }
+export type DispatchEvidenceKind = 'VEHICLE' | 'DRIVER'
+export interface DispatchEvidenceFile { fileId: string; fileName: string; contentType: string; sizeBytes: number }
+export interface CandidateList { candidates: Candidate[]; snapshotAt: string; complete: boolean }
+export interface DraftContainer { draftContainerId: string; sequenceNo: number; capacity: number; sourceKeys: string[] }
+export interface DispatchDraft { draftToken: string; recordVersion: Version; status: string; warehouseId: string; containers: DraftContainer[]; sources: Candidate[]; expiresAt: string }
+export interface DraftSelection extends VersionCommand { draftToken: string; draftContainerId: string; source: CargoSelection }
+export interface ConvertDraft extends VersionCommand { draftToken: string; groups: Array<{ draftContainerId: string; dispatch: CreateDispatch }> }
+export interface ConvertedDraft { draftToken: string; vehicles: Array<{ draftContainerId: string; dispatch: CommandResult }>; replayed: boolean }
+export interface CoverageSelection { financeFeeId: string; sourceVersion: number; sourceHash: string; services: string[] }
+export interface FeeItem { feeType: string; feeName: string; direction: string; currency: string; amount: number | null; supplierId?: string | null; supplierName?: string | null; supplierCategory?: string | null; settlementMode?: string | null; paidAt?: string | null; paymentMethod?: string | null; paymentReferenceNo?: string | null; paymentVoucherFileIds?: string[]; chargeableQuantity?: number | null; quantityUnit?: string | null; unitPrice?: number | null; periodStart?: string | null; periodEnd?: string | null; remark?: string | null }
+export interface ArrangeGroup { groupKey: string; groupCargoHash: string; plannedDeliveryAt: string; deliveryMethod: string; waybillNo: string | null; carrierName: string | null; pickupMethod: string; loadingType: string; vehicleType: string | null; vehicleSize: string | null; appointmentAccount: string | null; sellerName: string | null; remark: string | null; externalFreightHash: string; feeCoverageCargoHash: string; feeCoverage: CoverageSelection[]; fees: FeeItem[] }
+export interface ArrangeDelivery extends VersionCommand { cargoHash: string; loadingCompletionHash: string; groups: ArrangeGroup[] }
+export interface ArrangementResult { dispatchNo: string; recordVersion: Version; arrangementKey: string; cargoHash: string; arrangedAt: string; outbounds: OutboundReference[]; deliveries: DeliveryReference[] }
+export interface CargoLine { dispatchItemId: string; customerId: string; customerName: string; orderId: string | null; orderNo: string | null; sourceKey: string; sourceStage: string; sourceRegion: string | null; sourceInboundId: string | null; inboundCode: string | null; planPalletId: string | null; warehousePalletId: string | null; palletNo: string | null; pickId: string | null; attributionId: string | null; inventoryPositionId: string | null; receiptId: string | null; returnReceiptId: string | null; returnCartonId: string | null; cartonMark: string | null; relabelNo: string | null; destination: Destination; packages: number; productQuantity: number; grossWeightKg: number | null; volumeCbm: number | null; batchAllocations: DispatchBatchAllocation[] }
+export interface PreviewGroup { groupKey: string; customerId: string; customerName: string; destination: Destination; groupCargoHash: string; cargo: CargoLine[]; externalFreightHash: string; externalQuotes: Array<{ customerId: string; groupKey: string; bookingNo: string; inboundCode: string; currency: string; amount: number; sourceHash: string }>; feeCoverageCargoHash: string; feeSources: Array<{ financeFeeId: string; customerId: string; currency: string; amount: number; sourceVersion: number; sourceHash: string; status: string; services: string[]; sourceKeys: string[] }>; requiredServices: string[]; blockReasons: string[] }
+export interface ArrangementPreview { dispatchNo: string; recordVersion: Version; status: DispatchStatus; stage: DispatchStage; cargoHash: string; loadingCompletionHash: string; arrange: Gate; groups: PreviewGroup[]; arrangement: ArrangementResult | null }
+interface CommandBase { dispatchNo: string; idempotencyKey: string; recordVersion: Version; status: DispatchStatus; stage: DispatchStage; occurredAt: string; effect: 'APPLIED' | 'EXISTING'; counts: Counts; replayed: boolean; alreadyArranged: boolean }
+export type CommandResult = CommandBase & (
+  { action: 'PICK'; result: { dispatchItemId: string; positionId: string | null; returnCartonId: string | null; packages: number; pickedPackages: number; pickingReconciled: boolean } }
+  | { action: 'LOADING_COMPLETE'; result: { loadingCompletionHash: string; loadingCompletedAt: string; confirmedLoad: ConfirmedLoad } }
+  | { action: 'DEPART'; result: { departedAt: string; shippedPackages: number; outbounds: OutboundReference[]; deliveries: DeliveryReference[] } }
+  | { action: 'ARRANGE_DELIVERY'; result: ArrangementResult }
+  | { action: Exclude<DispatchAction, 'PICK' | 'LOADING_COMPLETE' | 'DEPART' | 'ARRANGE_DELIVERY'>; result: { dispatchNo: string; changedItemIds: string[] } }
+)
+
+export const dispatchStages: Array<{ value: DispatchStage; label: string }> = [
+  { value: 'BEFORE_LOADING', label: '装车前' }, { value: 'LOADING', label: '装车中' },
+  { value: 'AFTER_LOADING', label: '装车后' }, { value: 'DELIVERING', label: '派送中' }, { value: 'DELIVERED', label: '派送完成' },
+]
+export const stageLabel = (stage: DispatchStage) => dispatchStages.find(row => row.value === stage)?.label || '—'
+export const reviewLabels: Record<ReviewStatus, string> = { NOT_SUBMITTED: '未提交', PENDING: '待审核', APPROVED: '已通过', REJECTED: '已驳回' }
+export function requireVersion(value: unknown): Version {
+  if (typeof value === 'number' && Number.isSafeInteger(value) && value >= 0) return value
+  if (typeof value === 'string' && /^\d+$/.test(value)) return value
+  throw new DispatchInputError('操作版本缺失或无效，请刷新单据')
+}
+
+export function requireBatchVersions(values: readonly { batchKey: string; recordVersion: Version }[]): void {
+  const versions = new Map<string, string>()
+  for (const value of values) {
+    let version: Version
+    try { version = requireVersion(value.recordVersion) }
+    catch { throw new DispatchInputError('预约批次版本缺失或无效，请重新读取候选') }
+    const canonical = String(version).replace(/^0+(?=\d)/, '')
+    if (versions.has(value.batchKey) && versions.get(value.batchKey) !== canonical) throw new DispatchInputError('同一预约批次的版本不一致，请重新读取候选')
+    versions.set(value.batchKey, canonical)
+  }
+}

src/modules/overseas-warehouse/dispatchPresentation.ts

@@ -0,0 +1,16 @@
+import type { DispatchAction, DispatchActions } from './dispatchContracts'
+export const dispatchActionLabels: Record<DispatchAction, string> = {
+  CREATE: '新建排车', EDIT: '维护车辆信息', ADD_CARGO: '添加货物', REMOVE_CARGO: '移除货物', CANCEL: '取消排车',
+  SUBMIT_REVIEW: '提交调度审核', DISPATCH_REVIEW: '调度审核', LOADING_REVIEW: '理货员审核',
+  RETURN_TO_REVIEW: '退回装车前重审', PICK: '拣货', LOADING_COMPLETE: '确认装车完成', ARRANGE_DELIVERY: '安排派送', DEPART: '确认发车',
+}
+export const dispatchActionPermissions: Record<DispatchAction, string> = {
+  CREATE: 'platform:overseas-warehouse:dispatch:create', EDIT: 'platform:overseas-warehouse:dispatch:edit',
+  ADD_CARGO: 'platform:overseas-warehouse:dispatch:edit', REMOVE_CARGO: 'platform:overseas-warehouse:dispatch:edit',
+  CANCEL: 'platform:overseas-warehouse:dispatch:cancel', SUBMIT_REVIEW: 'platform:overseas-warehouse:dispatch:edit',
+  DISPATCH_REVIEW: 'platform:fleet:trip:dispatch-review', LOADING_REVIEW: 'platform:fleet:trip:loading-review',
+  RETURN_TO_REVIEW: 'platform:overseas-warehouse:dispatch:edit', PICK: 'lastleg:pda:operate',
+  LOADING_COMPLETE: 'platform:overseas-warehouse:dispatch:loading-complete', ARRANGE_DELIVERY: 'platform:overseas-warehouse:dispatch:transfer-delivery', DEPART: 'platform:overseas-warehouse:dispatch:depart',
+}
+export const canDispatchAction = (actions: DispatchActions | undefined, action: DispatchAction, can: (code: string) => boolean) => actions?.[action]?.allowed === true && can(dispatchActionPermissions[action])
+export const displayDispatchValue = (value: unknown) => value === null || value === undefined || value === '' ? '—' : String(value)

src/modules/overseas-warehouse/dispatchTestFixtures.ts

@@ -0,0 +1,14 @@
+import type { Candidate, CommandResult, DispatchDetail, DispatchListRow, DispatchPage, Driver, LoadingPreview, VehicleSnapshot } from './dispatchContracts'
+export const counts = () => ({ itemCount: 1, palletCount: 1, packageCount: 2, pickedPackageCount: 0, shippedPackageCount: 0 })
+export const reviews = () => ({ dispatchReview: { status: 'NOT_SUBMITTED' as const, reason: null, reviewerId: null, reviewedAt: null, reviewRound: 0, basisHash: null, invalidatedReason: null }, loadingReview: { status: 'NOT_SUBMITTED' as const, reason: null, reviewerId: null, reviewedAt: null, reviewRound: 0, basisHash: null, invalidatedReason: null } })
+export const resources = (): { vehicle: VehicleSnapshot; driver: Driver } => ({ vehicle: { mode: 'EXTERNAL', vehicleId: null, plate: 'CA-100', carrierName: 'Carrier', capacity: { palletSpaces: 30, maxLoadKg: 18000, maxVolumeCbm: 70 }, evidenceFileIds: [], vehicleStatus: null }, driver: { mode: 'EXTERNAL', driverId: null, name: '司机甲', phone: '555-0100', evidence: { licenseNo: 'TEST-LICENSE', licenseExpiresOn: '2030-01-01', fileIds: [], expectedTaskEndAt: '2026-11-01T10:00:00Z' } } })
+export const destination = () => ({ key: 'CODE:ONT8', type: 'FBA', warehouseId: null, warehouseCode: 'ONT8', warehouseName: 'ONT8', address: null, postalCode: null, contactName: null, contactPhone: null })
+export function detail(overrides: Partial<DispatchDetail> = {}): DispatchDetail { return { dispatchNo: 'PC/1', status: 'ACTIVE', stage: 'BEFORE_LOADING', recordVersion: 0, reviewState: 'DRAFT', reviews: reviews(), counts: counts(), pickingReconciled: false, actions: {}, vehicleInfo: resources(), dispatchInfo: { route: 'LAX → ONT8', plannedDepartureAt: null, departedAt: null, estimatedArrivalAt: null, fbaAppointments: [], vehicleAppointment: null, appointmentBatches: [] }, documents: { dispatchNo: 'PC/1', createdAt: '2026-10-19T10:00:00Z', updatedAt: '2026-10-19T11:00:00Z', remark: '真实备注', outbounds: [], deliveries: [] }, orderDetails: [{ customerId: 'C1', customerName: '客户甲', orderNo: 'LM-1', inboundCode: 'IN-1', grossWeightKg: null, palletCount: 1, destinationFbaWarehouse: 'ONT8', volumeCbm: null, containerNo: 'CSLU1234567', sourceKey: 'source-1' }], ...overrides } }
+export function listRow(overrides: Partial<DispatchListRow> = {}): DispatchListRow { return { dispatchNo: 'PC/1', status: 'ACTIVE', stage: 'BEFORE_LOADING', recordVersion: 0, reviewState: 'DRAFT', reviews: reviews(), resources: resources(), warehouseId: '321', warehouseCode: 'LAX', warehouseName: '洛杉矶仓', plannedDepartureAt: null, departedAt: null, counts: counts(), pickingReconciled: false, arranged: false, actions: {}, ...overrides } }
+export function page(records = [listRow()]): DispatchPage { return { records, total: records.length, page: 1, size: 10, pages: 1, snapshotAt: '2026-10-19T10:00:00Z', statistics: { matchedTotal: 8, activeTotal: 7, cancelledTotal: 1, stageCounts: { BEFORE_LOADING: 3, LOADING: 1, AFTER_LOADING: 1, DELIVERING: 1, DELIVERED: 1 }, beforeLoadingReviewCounts: { vehicleInfoTotal: 3, dispatchReview: { notSubmitted: 1, pending: 1, approved: 1, rejected: 0 }, loadingReview: { notSubmitted: 2, pending: 0, approved: 1, rejected: 0 } } } } }
+export function candidate(overrides: Partial<Candidate> = {}): Candidate { return { selection: { sourceType: 'INBOUND_PLAN', planPalletId: '11', returnReceiptId: null, relabelNo: null, warehousePalletId: '21', sourceVersion: 'source-hash' }, sourceKey: 'source-1', sourceVersion: 'source-hash', customerId: 'C1', customerName: '客户甲', warehouseId: '321', warehouseCode: 'LAX', warehouseName: '洛杉矶仓', orderNo: 'LM-1', inboundCode: 'IN-1', planNo: 'PLAN-1', palletNo: 'PALLET-1', containerNo: 'CSLU1234567', destination: destination(), availablePackages: 2, suggestedWeightKg: 100, suggestedVolumeCbm: 1, measurementSource: 'ORDER_SNAPSHOT_ALLOCATION', appointmentBatches: [], blockReasons: [], ...overrides } }
+export function command(action: CommandResult['action'], key = 'key', no = 'PC/1'): CommandResult {
+  const base = { dispatchNo: no, action, idempotencyKey: key, recordVersion: 1, status: 'ACTIVE' as const, stage: action === 'DEPART' ? 'DELIVERING' as const : action === 'LOADING_COMPLETE' ? 'AFTER_LOADING' as const : 'BEFORE_LOADING' as const, occurredAt: '2026-10-19T10:00:00Z', effect: 'APPLIED' as const, counts: counts(), replayed: false, alreadyArranged: false }
+  return { ...base, result: action === 'DEPART' ? { departedAt: '2026-10-19T10:00:00Z', shippedPackages: 2, outbounds: [], deliveries: [] } : action === 'LOADING_COMPLETE' ? { loadingCompletionHash: 'load-hash', loadingCompletedAt: '2026-10-19T10:00:00Z', confirmedLoad: { manifestHash: 'manifest', pallets: [], operatorId: 'operator', confirmedAt: '2026-10-19T10:00:00Z' } } : { dispatchNo: no, changedItemIds: [] } } as CommandResult
+}
+export function loadingPreview(): LoadingPreview { return { dispatchNo: 'PC/1', recordVersion: 0, status: 'ACTIVE', stage: 'LOADING', manifestHash: 'manifest', pickingReconciled: true, resources: resources(), pallets: [{ warehousePalletId: '21', palletNo: 'PALLET-1', scheduledPackages: 2, pickedPackages: 2, palletSpaces: 1, weightKg: null, volumeCbm: null, deliveryIndex: 1, missingFields: ['weightKg', 'volumeCbm'], evidence: [{ field: 'weightKg', sourceType: 'ORDER_SNAPSHOT_ALLOCATION', sourceBusinessNo: 'IN-1', observedAt: null, value: 100, actual: false }] }], confirmedLoad: null, loadingComplete: { allowed: true, blockCode: null, blockReason: null }, missingFields: ['weightKg', 'volumeCbm'] } }

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

@@ -0,0 +1,89 @@
+import { describe, expect, it } from 'vitest'
+import { parseApiJsonResponse } from '@chongchong/shared'
+import { candidate, command, detail, destination, loadingPreview, page } from './dispatchTestFixtures'
+import * as wire from './dispatchWire'
+
+// Exercise the same JSON parser as Axios; quoted Long values must reach the boundary intact.
+const parsed = <T>(value: T): T => parseApiJsonResponse(JSON.stringify(value)) as T
+const id = '9007199254740993'
+const counts = { itemCount: '1', palletCount: '2', packageCount: '12', pickedPackageCount: '0', shippedPackageCount: '0' }
+const gate = { allowed: true, blockCode: null, blockReason: null }
+const source = () => ({ ...candidate(), customerId: id, availablePackages: '12' })
+const draft = (): wire.DispatchDraftWire => ({ draftToken: 'draft', recordVersion: id, warehouseId: id, status: 'ACTIVE', sources: [source()], containers: [{ draftContainerId: id, sequenceNo: 1, capacity: 30, sourceKeys: ['source-1'] }], expiresAt: '' })
+const references = () => ({ outbounds: [{ customerId: id, customerName: '客户甲', outboundNo: 'OUT-1', status: 'WAIT_OUTBOUND', packageCount: '12', palletCount: '2' }], deliveries: [{ groupKey: 'group-1', customerId: id, customerName: '客户甲', outboundNo: 'OUT-1', deliveryNo: 'DEL-1', destination: destination(), status: 'WAIT_DELIVERY', packageCount: '12', palletCount: '2' }] })
+const arrangement = () => ({ dispatchNo: 'PC/1', recordVersion: id, arrangementKey: 'key', cargoHash: 'hash', arrangedAt: '', ...references() })
+
+describe('native dispatch Long quantity boundary', () => {
+  it.each([0, '0', id])('keeps actual batch recordVersion %s lossless in candidates, drafts and existing dispatch references', version => {
+    const reference = { batchKey: 'FBA_APPOINTMENT:1', batchNo: 'AP-1', customerId: id, recordVersion: version, sources: [{ sourceKey: 'ORDER:1', destinationKey: 'FBA:ONT8', packageCount: 12 }] }
+    const value = { ...source(), appointmentBatches: [reference] }
+    expect(wire.normalizeCandidateList(parsed({ candidates: [value], complete: true, snapshotAt: '' })).candidates[0]!.appointmentBatches[0]!.recordVersion).toBe(version)
+    expect(wire.normalizeDispatchDraft(parsed({ ...draft(), sources: [value] })).sources[0]!.appointmentBatches[0]!.recordVersion).toBe(version)
+    const existing = detail()
+    expect(wire.normalizeDispatchDetail(parsed({ ...existing, dispatchInfo: { ...existing.dispatchInfo, appointmentBatches: [reference] } })).dispatchInfo.appointmentBatches[0]!.recordVersion).toBe(version)
+  })
+  it.each([undefined, null, -1, '', 'bad'])('rejects missing or invalid authoritative candidate batch version %s', version => {
+    const reference = { batchKey: 'FBA_APPOINTMENT:1', batchNo: 'AP-1', customerId: id, recordVersion: version, sources: [] }
+    const value = { ...source(), appointmentBatches: [reference] } as unknown as wire.CandidateWire
+    expect(() => wire.normalizeCandidateList(parsed({ candidates: [value], complete: true, snapshotAt: '' }))).toThrow('预约批次版本缺失或无效，请重新读取候选')
+  })
+  it('preserves a raw large JSON integer that the shared parser safely converts into a version string', () => {
+    const value = { ...source(), appointmentBatches: [{ batchKey: 'FBA_APPOINTMENT:1', batchNo: 'AP-1', customerId: id, recordVersion: 9007199254740992, sources: [] }] }
+    expect(wire.normalizeCandidateList(parsed({ candidates: [value], complete: true, snapshotAt: '' })).candidates[0]!.appointmentBatches[0]!.recordVersion).toBe('9007199254740992')
+  })
+  it.each([undefined, null, true, false, '', ' ', ' 1', '1 ', '01', '+1', '-1', '1.0', '1e2', -1, 1.5, NaN, Infinity, '9007199254740992', 9007199254740992])('rejects invalid or unsafe quantity %s instead of silently changing it', value => {
+    expect(() => wire.dispatchQuantity(value, '箱数')).toThrow('排车响应')
+  })
+  it('accepts zero and the safe integer limit in numeric and string form', () => {
+    for (const value of [0, '0', Number.MAX_SAFE_INTEGER, String(Number.MAX_SAFE_INTEGER)]) expect(wire.dispatchQuantity(value, '箱数')).toBe(Number(value))
+  })
+  it('normalizes all list, statistics and review counts while preserving versions and IDs', () => {
+    const value = page()
+    const result = wire.normalizeDispatchPage(parsed({ ...value, total: '8', page: '1', size: '10', pages: '1', records: [{ ...value.records[0]!, warehouseId: id, recordVersion: id, counts, reviews: { ...value.records[0]!.reviews, dispatchReview: { ...value.records[0]!.reviews.dispatchReview, reviewRound: id } } }], statistics: { matchedTotal: '8', activeTotal: '7', cancelledTotal: '1', stageCounts: { BEFORE_LOADING: '3', LOADING: '1', AFTER_LOADING: '1', DELIVERING: '1', DELIVERED: '1' }, beforeLoadingReviewCounts: { vehicleInfoTotal: '3', dispatchReview: { notSubmitted: '1', pending: '1', approved: '1', rejected: '0' }, loadingReview: { notSubmitted: '2', pending: '0', approved: '1', rejected: '0' } } } }))
+    expect(result).toMatchObject({ total: 8, page: 1, size: 10, pages: 1, statistics: { matchedTotal: 8, activeTotal: 7, cancelledTotal: 1, stageCounts: value.statistics.stageCounts, beforeLoadingReviewCounts: value.statistics.beforeLoadingReviewCounts } })
+    expect(result.records[0]).toMatchObject({ warehouseId: id, recordVersion: id, counts: { itemCount: 1, palletCount: 2, packageCount: 12, pickedPackageCount: 0, shippedPackageCount: 0 }, reviews: { dispatchReview: { reviewRound: id } } })
+  })
+  it('normalizes detail document quantities without changing nullable Integer measurements or versions', () => {
+    const value = detail()
+    const result = wire.normalizeDispatchDetail(parsed({ ...value, recordVersion: id, counts, documents: { ...value.documents, ...references() }, orderDetails: [{ ...value.orderDetails[0]!, palletCount: null }] }))
+    expect(result.recordVersion).toBe(id); expect(result.counts.packageCount).toBe(12); expect(result.orderDetails[0]!.palletCount).toBeNull()
+    expect(result.documents.outbounds[0]).toMatchObject({ customerId: id, packageCount: 12, palletCount: 2 }); expect(result.documents.deliveries[0]!.packageCount).toBe(12)
+  })
+  it('normalizes candidates and draft sources and keeps source versions and container IDs', () => {
+    const candidates = wire.normalizeCandidateList(parsed({ candidates: [source()], snapshotAt: '', complete: true }))
+    expect(candidates.candidates[0]).toMatchObject({ availablePackages: 12, customerId: id, sourceVersion: 'source-hash' })
+    const result = wire.normalizeDispatchDraft(parsed(draft()))
+    expect(result.sources[0]!.availablePackages).toBe(12); expect(result.recordVersion).toBe(id); expect(result.containers[0]).toMatchObject({ draftContainerId: id, sequenceNo: 1, capacity: 30 })
+  })
+  it('normalizes actual item and loading quantities while keeping decimal measurements and integer positions', () => {
+    const value = source()
+    const items = wire.normalizeDispatchItems(parsed({ dispatchNo: 'PC/1', recordVersion: id, status: 'ACTIVE', stage: 'BEFORE_LOADING', items: [{ ...value.selection, dispatchItemId: id, sourceKey: value.sourceKey, sourceVersion: value.sourceVersion, customerId: id, customerName: value.customerName, palletNo: value.palletNo, orderNo: value.orderNo, inboundCode: value.inboundCode, destination: value.destination, scheduledPackages: '12', pickedPackages: '0', remove: gate }] } satisfies wire.DispatchItemsWire))
+    expect(items.items[0]).toMatchObject({ dispatchItemId: id, scheduledPackages: 12, pickedPackages: 0 }); expect(items.recordVersion).toBe(id)
+    const preview = loadingPreview()
+    const loading = wire.normalizeLoadingPreview(parsed({ ...preview, recordVersion: id, pallets: [{ ...preview.pallets[0]!, warehousePalletId: id, scheduledPackages: '12', pickedPackages: '12', weightKg: 12.25, volumeCbm: 0.5, deliveryIndex: 1, palletSpaces: 2 }] }))
+    expect(loading.pallets[0]).toMatchObject({ warehousePalletId: id, scheduledPackages: 12, pickedPackages: 12, weightKg: 12.25, volumeCbm: 0.5, deliveryIndex: 1, palletSpaces: 2 })
+  })
+  it('normalizes file size before metadata and Blob validation without rounding file identity', () => {
+    const result = wire.normalizeEvidenceFile(parsed({ fileId: id, fileName: '证据.png', contentType: 'image/png', sizeBytes: '3' }))
+    expect(result).toMatchObject({ fileId: id, sizeBytes: 3 }); expect(Number.isSafeInteger(result.sizeBytes)).toBe(true); expect(new Blob(['png']).size).toBe(result.sizeBytes)
+  })
+  it('normalizes every arrangement cargo and existing outbound/delivery quantity', () => {
+    const result = wire.normalizeArrangementPreview(parsed({ dispatchNo: 'PC/1', recordVersion: id, status: 'ACTIVE', stage: 'AFTER_LOADING', cargoHash: 'hash', loadingCompletionHash: 'loaded', arrange: gate, groups: [{ groupKey: 'group-1', customerId: id, customerName: '客户甲', destination: destination(), groupCargoHash: 'group-hash', cargo: [{ dispatchItemId: id, customerId: id, customerName: '客户甲', orderId: id, orderNo: 'LM-1', sourceKey: 'source-1', sourceStage: 'RECEIVED', sourceRegion: null, sourceInboundId: id, inboundCode: 'IN-1', planPalletId: id, warehousePalletId: id, palletNo: 'PALLET-1', pickId: id, attributionId: id, inventoryPositionId: id, receiptId: id, returnReceiptId: null, returnCartonId: null, cartonMark: null, relabelNo: null, destination: destination(), packages: '12', productQuantity: '24', grossWeightKg: 12.25, volumeCbm: null, batchAllocations: [] }], externalFreightHash: '', externalQuotes: [], feeCoverageCargoHash: '', feeSources: [], requiredServices: [], blockReasons: [] }], arrangement: arrangement() } satisfies wire.ArrangementPreviewWire))
+    expect(result.groups[0]!.cargo[0]).toMatchObject({ dispatchItemId: id, packages: 12, productQuantity: 24, grossWeightKg: 12.25 }); expect(result.arrangement).toMatchObject({ recordVersion: id, outbounds: [{ packageCount: 12, palletCount: 2 }], deliveries: [{ packageCount: 12, palletCount: 2 }] })
+  })
+  it('normalizes typed command payloads and converted drafts and preserves immutable proof versions', () => {
+    const base = { ...command('EDIT'), counts, recordVersion: id }
+    const pick = wire.normalizeDispatchCommand(parsed({ ...base, action: 'PICK', result: { dispatchItemId: id, positionId: id, returnCartonId: null, packages: '2', pickedPackages: '12', pickingReconciled: true } } satisfies wire.CommandResultWire))
+    expect(pick).toMatchObject({ recordVersion: id, counts: { packageCount: 12 }, result: { dispatchItemId: id, packages: 2, pickedPackages: 12 } })
+    const depart: wire.CommandResultWire = { ...base, action: 'DEPART', result: { departedAt: '', shippedPackages: '12', ...references() } }
+    expect(wire.normalizeDispatchCommand(parsed(depart))).toMatchObject({ result: { shippedPackages: 12, outbounds: [{ packageCount: 12 }], deliveries: [{ palletCount: 2 }] } })
+    const arranged: wire.CommandResultWire = { ...base, action: 'ARRANGE_DELIVERY', result: arrangement() }
+    expect(wire.normalizeDispatchCommand(parsed(arranged))).toMatchObject({ result: { recordVersion: id, deliveries: [{ packageCount: 12 }] } })
+    expect(wire.normalizeConvertedDraft(parsed({ draftToken: 'draft', vehicles: [{ draftContainerId: id, dispatch: depart }], replayed: true }))).toMatchObject({ vehicles: [{ draftContainerId: id, dispatch: { recordVersion: id, counts: { pickedPackageCount: 0 }, result: { shippedPackages: 12 } } }] })
+  })
+  it('rejects malformed nested quantities at the boundary', () => {
+    expect(() => wire.normalizeDispatchDraft(parsed({ ...draft(), sources: [{ ...source(), availablePackages: '9007199254740992' }] }))).toThrow('安全整数')
+    expect(() => wire.normalizeEvidenceFile({ fileId: id, fileName: '', contentType: '', sizeBytes: null } as unknown as wire.DispatchEvidenceFileWire)).toThrow('有效非负整数')
+    expect(() => wire.normalizeDispatchCommand({ ...command('EDIT'), counts: { ...counts, pickedPackageCount: undefined } } as unknown as wire.CommandResultWire)).toThrow('有效非负整数')
+  })
+})

src/modules/overseas-warehouse/dispatchWire.ts

@@ -0,0 +1,71 @@
+import { DispatchInputError, requireBatchVersions, type ArrangementPreview, type ArrangementResult, type Candidate, type CandidateList, type CargoLine, type CommandResult, type ConvertedDraft, type Counts, type DeliveryReference, type DispatchDetail, type DispatchDraft, type DispatchEvidenceFile, type DispatchItems, type DispatchListRow, type DispatchPage, type DispatchStage, type DispatchStatistics, type LoadingPreview, type OutboundReference, type PreviewGroup, type ReviewCounts } from './dispatchContracts'
+
+// common-web serializes both Long and long as decimal strings. Only quantity
+// fields are normalized here; IDs, recordVersion and reviewRound stay lossless.
+export type LongQuantityWire = string | number
+type LongFields<T, K extends keyof T> = Omit<T, K> & { [P in K]: LongQuantityWire }
+type CountsWire = LongFields<Counts, keyof Counts>
+type ReviewCountsWire = LongFields<ReviewCounts, keyof ReviewCounts>
+type OutboundWire = LongFields<OutboundReference, 'packageCount' | 'palletCount'>
+type DeliveryWire = LongFields<DeliveryReference, 'packageCount' | 'palletCount'>
+type ReferencesWire = { outbounds: OutboundWire[]; deliveries: DeliveryWire[] }
+type StatisticsWire = Omit<DispatchStatistics, 'matchedTotal' | 'activeTotal' | 'cancelledTotal' | 'stageCounts' | 'beforeLoadingReviewCounts'> & {
+  matchedTotal: LongQuantityWire; activeTotal: LongQuantityWire; cancelledTotal: LongQuantityWire
+  stageCounts: Record<DispatchStage, LongQuantityWire>
+  beforeLoadingReviewCounts: { vehicleInfoTotal: LongQuantityWire; dispatchReview: ReviewCountsWire; loadingReview: ReviewCountsWire }
+}
+type ListRowWire = Omit<DispatchListRow, 'counts'> & { counts: CountsWire }
+export type DispatchPageWire = Omit<DispatchPage, 'records' | 'total' | 'page' | 'size' | 'pages' | 'statistics'> & { records: ListRowWire[]; total: LongQuantityWire; page: LongQuantityWire; size: LongQuantityWire; pages: LongQuantityWire; statistics: StatisticsWire }
+export type DispatchDetailWire = Omit<DispatchDetail, 'counts' | 'documents'> & { counts: CountsWire; documents: Omit<DispatchDetail['documents'], keyof ReferencesWire> & ReferencesWire }
+export type CandidateWire = LongFields<Candidate, 'availablePackages'>
+export type CandidateListWire = Omit<CandidateList, 'candidates'> & { candidates: CandidateWire[] }
+export type DispatchDraftWire = Omit<DispatchDraft, 'sources'> & { sources: CandidateWire[] }
+export type DispatchItemsWire = Omit<DispatchItems, 'items'> & { items: Array<LongFields<DispatchItems['items'][number], 'scheduledPackages' | 'pickedPackages'>> }
+export type LoadingPreviewWire = Omit<LoadingPreview, 'pallets'> & { pallets: Array<LongFields<LoadingPreview['pallets'][number], 'scheduledPackages' | 'pickedPackages'>> }
+export type DispatchEvidenceFileWire = LongFields<DispatchEvidenceFile, 'sizeBytes'>
+type ArrangementResultWire = Omit<ArrangementResult, keyof ReferencesWire> & ReferencesWire
+type PreviewGroupWire = Omit<PreviewGroup, 'cargo'> & { cargo: Array<LongFields<CargoLine, 'packages' | 'productQuantity'>> }
+export type ArrangementPreviewWire = Omit<ArrangementPreview, 'groups' | 'arrangement'> & { groups: PreviewGroupWire[]; arrangement: ArrangementResultWire | null }
+type PickedWire = LongFields<Extract<CommandResult, { action: 'PICK' }>['result'], 'packages' | 'pickedPackages'>
+type DepartedWire = Omit<Extract<CommandResult, { action: 'DEPART' }>['result'], 'shippedPackages' | keyof ReferencesWire> & ReferencesWire & { shippedPackages: LongQuantityWire }
+type WireCommand<C extends CommandResult> = C extends CommandResult ? Omit<C, 'counts' | 'result'> & { counts: CountsWire; result: C extends { action: 'PICK' } ? PickedWire : C extends { action: 'DEPART' } ? DepartedWire : C extends { action: 'ARRANGE_DELIVERY' } ? ArrangementResultWire : C['result'] } : never
+export type CommandResultWire = WireCommand<CommandResult>
+export type ConvertedDraftWire = Omit<ConvertedDraft, 'vehicles'> & { vehicles: Array<{ draftContainerId: string; dispatch: CommandResultWire }> }
+
+export function dispatchQuantity(value: unknown, field: string): number {
+  if (typeof value !== 'number' && (typeof value !== 'string' || !/^(?:0|[1-9]\d*)$/.test(value))) throw new DispatchInputError(`排车响应${field}不是有效非负整数，请重新读取`)
+  const number = typeof value === 'number' ? value : Number(value)
+  if (!Number.isSafeInteger(number) || number < 0) throw new DispatchInputError(`排车响应${field}超出安全整数范围或无效，请重新读取`)
+  return number
+}
+function numbers<T, K extends keyof T>(value: LongFields<T, K>, fields: readonly K[]): T {
+  const result = { ...value }
+  for (const field of fields) Object.assign(result, { [field]: dispatchQuantity(value[field], String(field)) })
+  return result as T
+}
+const counts = (value: CountsWire) => numbers<Counts, keyof Counts>(value, ['itemCount', 'palletCount', 'packageCount', 'pickedPackageCount', 'shippedPackageCount'])
+const reviewCounts = (value: ReviewCountsWire) => numbers<ReviewCounts, keyof ReviewCounts>(value, ['notSubmitted', 'pending', 'approved', 'rejected'])
+const references = (value: ReferencesWire) => ({ outbounds: value.outbounds.map(row => numbers<OutboundReference, 'packageCount' | 'palletCount'>(row, ['packageCount', 'palletCount'])), deliveries: value.deliveries.map(row => numbers<DeliveryReference, 'packageCount' | 'palletCount'>(row, ['packageCount', 'palletCount'])) })
+const candidate = (value: CandidateWire): Candidate => { requireBatchVersions(value.appointmentBatches); return { ...value, availablePackages: dispatchQuantity(value.availablePackages, 'availablePackages') } }
+function statistics(value: StatisticsWire): DispatchStatistics {
+  return { ...value, matchedTotal: dispatchQuantity(value.matchedTotal, 'matchedTotal'), activeTotal: dispatchQuantity(value.activeTotal, 'activeTotal'), cancelledTotal: dispatchQuantity(value.cancelledTotal, 'cancelledTotal'), stageCounts: Object.fromEntries(Object.entries(value.stageCounts).map(([stage, count]) => [stage, dispatchQuantity(count, `stageCounts.${stage}`)])) as Record<DispatchStage, number>, beforeLoadingReviewCounts: { vehicleInfoTotal: dispatchQuantity(value.beforeLoadingReviewCounts.vehicleInfoTotal, 'vehicleInfoTotal'), dispatchReview: reviewCounts(value.beforeLoadingReviewCounts.dispatchReview), loadingReview: reviewCounts(value.beforeLoadingReviewCounts.loadingReview) } }
+}
+export function normalizeDispatchPage(value: DispatchPageWire): DispatchPage { return { ...value, total: dispatchQuantity(value.total, 'total'), page: dispatchQuantity(value.page, 'page'), size: dispatchQuantity(value.size, 'size'), pages: dispatchQuantity(value.pages, 'pages'), records: value.records.map(row => ({ ...row, counts: counts(row.counts) })), statistics: statistics(value.statistics) } }
+export function normalizeDispatchDetail(value: DispatchDetailWire): DispatchDetail { requireBatchVersions(value.dispatchInfo.appointmentBatches); return { ...value, counts: counts(value.counts), documents: { ...value.documents, ...references(value.documents) } } }
+export function normalizeCandidateList(value: CandidateListWire): CandidateList { return { ...value, candidates: value.candidates.map(candidate) } }
+export function normalizeDispatchDraft(value: DispatchDraftWire): DispatchDraft { return { ...value, sources: value.sources.map(candidate) } }
+export function normalizeDispatchItems(value: DispatchItemsWire): DispatchItems { return { ...value, items: value.items.map(row => ({ ...row, scheduledPackages: dispatchQuantity(row.scheduledPackages, 'scheduledPackages'), pickedPackages: dispatchQuantity(row.pickedPackages, 'pickedPackages') })) } }
+export function normalizeLoadingPreview(value: LoadingPreviewWire): LoadingPreview { return { ...value, pallets: value.pallets.map(row => ({ ...row, scheduledPackages: dispatchQuantity(row.scheduledPackages, 'scheduledPackages'), pickedPackages: dispatchQuantity(row.pickedPackages, 'pickedPackages') })) } }
+export function normalizeEvidenceFile(value: DispatchEvidenceFileWire): DispatchEvidenceFile { return { ...value, sizeBytes: dispatchQuantity(value.sizeBytes, 'sizeBytes') } }
+function arrangementResult(value: ArrangementResultWire): ArrangementResult { return { ...value, ...references(value) } }
+export function normalizeArrangementPreview(value: ArrangementPreviewWire): ArrangementPreview { return { ...value, groups: value.groups.map(group => ({ ...group, cargo: group.cargo.map(row => ({ ...row, packages: dispatchQuantity(row.packages, 'packages'), productQuantity: dispatchQuantity(row.productQuantity, 'productQuantity') })) })), arrangement: value.arrangement ? arrangementResult(value.arrangement) : null } }
+export function normalizeDispatchCommand(value: CommandResultWire): CommandResult {
+  const normalizedCounts = counts(value.counts)
+  switch (value.action) {
+    case 'PICK': return { ...value, counts: normalizedCounts, result: { ...value.result, packages: dispatchQuantity(value.result.packages, 'packages'), pickedPackages: dispatchQuantity(value.result.pickedPackages, 'pickedPackages') } }
+    case 'DEPART': return { ...value, counts: normalizedCounts, result: { ...value.result, shippedPackages: dispatchQuantity(value.result.shippedPackages, 'shippedPackages'), ...references(value.result) } }
+    case 'ARRANGE_DELIVERY': return { ...value, counts: normalizedCounts, result: arrangementResult(value.result) }
+    default: return { ...value, counts: normalizedCounts }
+  }
+}
+export function normalizeConvertedDraft(value: ConvertedDraftWire): ConvertedDraft { return { ...value, vehicles: value.vehicles.map(row => ({ ...row, dispatch: normalizeDispatchCommand(row.dispatch) })) } }

src/modules/overseas-warehouse/index.ts

@@ -6,8 +6,12 @@ export type { FbaAppointmentDto, BatchFbaAppointmentPayload, UpdateFbaAppointmen
 export { default as FbaAppointmentFields } from './components/FbaAppointmentFields.vue'
 export { createAppointmentForm, appointmentPayload, appointmentFormError } from './appointmentForm'
 export { overseasWarehousePermissions } from './permissions'
-export { getDispatch, getBatchDispatchCandidates, createDispatchDraftContainer, listDispatchDrafts, lockDispatchDraftPallet, preArrangeDraftDispatch, releaseDispatchDraft } from './api/dispatches'
-export type { DispatchBatchReference, BatchDispatchCandidate, BatchDispatchCandidates, DispatchBatchAllocation, DispatchSummaryDto, PreArrangeDispatchDraftPayload } from './api/dispatches'
+export { getDispatch, getBatchDispatchCandidates, listDispatchCandidates, createDispatchDraft, createDispatchDraftContainer, listDispatchDrafts, lockDispatchDraftPallet, convertDispatchDraft, releaseDispatchDraft, addDispatchCargo } from './api/dispatches'
+export type { BatchDispatchCandidate, BatchDispatchCandidates } from './api/dispatches'
+export type { DispatchBatchReference, DispatchBatchAllocation, DispatchDetail, DispatchDraft, ConvertDraft, ConvertedDraft, CommandResult, Candidate, DraftSelection, VersionCommand } from './dispatchContracts'
+export { DispatchInputError, requireVersion, requireBatchVersions, stageLabel } from './dispatchContracts'
+export { useDispatchCommandRecovery, validateCommandResult, validateCurrentDispatch, isDefiniteDispatchRejection } from './dispatchCommandRecovery'
+export { default as DispatchWorkflowDialog } from './components/DispatchWorkflowDialog.vue'
 export { dispatchVehicleSpecs } from './dispatchVehicleSpecs'
 export { getContainerPlanProgress, getContainerInboundPlanPreview, convertLastMileContainerToInboundPlans } from './api/lastMileOrders'
 export type { ContainerPlanProgressDetailDto, ContainerInboundPlanPreviewDto, ConvertContainerInboundPlanPayload } from './api/lastMileOrders'

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

@@ -58,7 +58,8 @@ describe('overseas warehouse 1920px layout acceptance', () => {
     expect(sharedDetail).toContain('grid-template-columns: repeat(2, minmax(0, 1fr))')
     expect(page('LastMileOrderDetailView.vue')).toContain('density-fields')
     expect(page('InboundOrderDetailView.vue')).toContain('density-fields')
-    expect(page('DispatchDetailView.vue')).toContain('.document-section { grid-column: 1 / -1; }')
+    expect(page('DispatchDetailView.vue')).toContain('class="density-element-tabs density-contained-tabs"')
+    expect(page('DispatchDetailView.vue').match(/<el-tab-pane name=/g)).toHaveLength(4)
     expect(page('DispatchDetailView.vue')).toContain('density-fields')
     expect(page('DeliveryOrderDetailView.vue')).toContain('density-fields')
     expect(page('InventoryDetailView.vue')).toContain('density-fields')

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

@@ -3,77 +3,54 @@ import { flushPromises, mount } from '@vue/test-utils'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { getDispatch } from '../api/dispatches'
 import DispatchDetailView from './DispatchDetailView.vue'
+import { detail, destination } from '../dispatchTestFixtures'
 import { DataTableStub } from './phase5TestStubs'
-
-const sourceQuery = vi.hoisted(() => ({} as Record<string, string>))
-const routerPush = vi.hoisted(() => vi.fn())
-const canPermission = vi.hoisted(() => vi.fn(() => false))
-vi.mock('@/core/access/accessPreview', () => ({ useAccessPreviewStore: () => ({ can: canPermission }) }))
-vi.mock('vue-router', () => ({ useRoute: () => ({ params: { dispatchNo: 'PC/1' }, query: sourceQuery }), useRouter: () => ({ push: routerPush }) }))
+const query = vi.hoisted(() => ({} as Record<string, string>))
+const push = vi.hoisted(() => vi.fn())
+const can = vi.hoisted(() => vi.fn(() => false))
+vi.mock('@/core/access/accessPreview', () => ({ useAccessPreviewStore: () => ({ can }) }))
+vi.mock('vue-router', () => ({ useRoute: () => ({ params: { dispatchNo: 'PC/1' }, query }), useRouter: () => ({ push }) }))
 vi.mock('../api/dispatches', () => ({ getDispatch: vi.fn() }))
-
-describe('DispatchDetailView', () => {
-  beforeEach(() => {
-    routerPush.mockReset()
-    canPermission.mockReset().mockReturnValue(false)
-    Object.keys(sourceQuery).forEach(key => delete sourceQuery[key])
-    vi.mocked(getDispatch).mockReset().mockResolvedValue({
-      id: '1', dispatchNo: 'PC/1', appointmentBatches: [], vehiclePlate: 'CA-100', driverName: '张师傅', status: 'PENDING_DEPARTURE',
-      route: 'LAX → ONT8', items: [{ id: '11', planPalletId: '20', orderNo: 'LM-1', warehousePalletId: '21', fbaWarehouseCode: 'ONT8', grossWeightKg: 88.5, volumeCbm: 1.25 }],
-    })
-  })
-
-  it('loads the business dispatch number and renders summary and related orders', async () => {
-    const wrapper = mount(DispatchDetailView, { global: { plugins: [ElementPlus], stubs: { DataTable: DataTableStub } } })
-    await flushPromises()
+vi.mock('@/modules/overseas-master-data', () => ({ inquiryReturnTarget: (value: Record<string, string>) => value.fleetOfferNo ? { name: 'overseas-master-data-capacity-offer-detail', params: { offerNo: value.fleetOfferNo }, query: { inquiry: value.fleetBookingNo } } : null }))
+const options = { global: { plugins: [ElementPlus], stubs: { DataTable: DataTableStub, DispatchWorkflowDialog: true } } }
+beforeEach(() => { vi.mocked(getDispatch).mockResolvedValue(detail()); can.mockReturnValue(false); push.mockReset(); Object.keys(query).forEach(key => delete query[key]) })
+describe('whole-dispatch four-tab detail', () => {
+  it('uses only four accessible colored tabs and switches without another network read', async () => {
+    const wrapper = mount(DispatchDetailView, options); await flushPromises()
     expect(getDispatch).toHaveBeenCalledWith('PC/1')
-    expect(wrapper.text()).toContain('PC/1')
-    expect(wrapper.text()).toContain('CA-100')
-    expect(wrapper.text()).toContain('待发车')
-    const table = wrapper.findComponent(DataTableStub)
-    expect(table.props('data')).toEqual([{ orderNo: 'LM-1', weight: 88.5, palletCount: 1, fbaWarehouse: 'ONT8', volume: 1.25, containerNo: '—' }])
-    wrapper.unmount()
+    const tabs = wrapper.findAll('[role="tab"]')
+    expect(tabs.map(tab => tab.text())).toEqual(['🚚车辆信息', '📋排车信息', '📝单据信息', '📦关联订单明细'])
+    expect(wrapper.findAll('.density-tab-icon')).toHaveLength(4)
+    await tabs[1]!.trigger('click'); await flushPromises()
+    expect(tabs[1]!.attributes('aria-selected')).toBe('true')
+    expect(wrapper.get(`#${tabs[1]!.attributes('aria-controls')}`).text()).toContain('LAX → ONT8')
+    expect(getDispatch).toHaveBeenCalledTimes(1); expect(wrapper.text()).toContain('装车前'); wrapper.unmount()
   })
-
-  it('keeps related order weight unknown when one pallet lacks physical weight', async () => {
-    vi.mocked(getDispatch).mockResolvedValueOnce({ id: '1', dispatchNo: 'PC/1', appointmentBatches: [], status: 'PENDING_DEPARTURE', items: [
-      { id: '11', planPalletId: '31', orderNo: 'LM-1', warehousePalletId: '21', grossWeightKg: 88.5, volumeCbm: 1 },
-      { id: '12', planPalletId: '32', orderNo: 'LM-1', warehousePalletId: '22', grossWeightKg: null, volumeWeightKg: 999, volumeCbm: 1 },
-    ] })
-    const wrapper = mount(DispatchDetailView, { global: { plugins: [ElementPlus], stubs: { DataTable: DataTableStub } } })
-    await flushPromises()
-    expect(wrapper.findComponent(DataTableStub).props('data')).toEqual([expect.objectContaining({ weight: null })])
-    wrapper.unmount()
+  it('uses exact server order attribution including unknown measurements and real container numbers', async () => {
+    const value = detail(); value.orderDetails.push({ ...value.orderDetails[0]!, customerId: 'C2', customerName: '客户乙', sourceKey: 'source-2', orderNo: 'LM-2', grossWeightKg: 12.25 })
+    vi.mocked(getDispatch).mockResolvedValueOnce(value)
+    const wrapper = mount(DispatchDetailView, options); await flushPromises()
+    expect(wrapper.getComponent(DataTableStub).props('data')).toEqual(value.orderDetails)
+    expect(value.orderDetails[0]!.grossWeightKg).toBeNull(); wrapper.unmount()
   })
-
-  it('shows server blocking reasons and opens only authorized original documents', async () => {
-    const data = await getDispatch('PC/1')
-    data.actions = { canEdit: false, editBlockReason: '请先解除车次关联', canCancel: false, cancelBlockReason: '请先解除车次关联', canRemovePallet: false, removePalletBlockReason: '请先解除车次关联', canTransfer: false, transferBlockReason: '原出库已取消，请取消原排车后重新预排', outboundNo: 'OUT-1', outboundStatus: 'CANCELLED' }
-    data.workflow = { tripNo: 'TR-1', dispatchReview: { status: 'PENDING', reason: null, reviewedAt: null }, loadingReview: { status: 'PENDING', reason: null, reviewedAt: null } }
-    vi.mocked(getDispatch).mockResolvedValue(data)
-    canPermission.mockReturnValue(true)
-    const wrapper = mount(DispatchDetailView, { global: { plugins: [ElementPlus], stubs: { DataTable: DataTableStub } } }); await flushPromises()
-    expect(wrapper.text()).toContain('原出库已取消')
-    await wrapper.findAll('button').find(button => button.text().includes('处理原车次'))!.trigger('click')
-    expect(routerPush).toHaveBeenLastCalledWith({ name: 'overseas-master-data-trip-detail', params: { tripNo: 'TR-1' }, query: { tab: 'overview' } })
-    await wrapper.findAll('button').find(button => button.text().includes('查看原出库'))!.trigger('click')
-    expect(routerPush).toHaveBeenLastCalledWith({ name: 'overseas-outbounds', query: { documentNo: 'OUT-1' } })
-    wrapper.unmount()
-    canPermission.mockReturnValue(false)
-    const readonly = mount(DispatchDetailView, { global: { plugins: [ElementPlus], stubs: { DataTable: DataTableStub } } }); await flushPromises()
-    expect(readonly.findAll('button').some(button => ['处理原车次', '查看原出库'].some(label => button.text().includes(label)))).toBe(false)
-    expect(readonly.text()).toContain('原出库已取消')
-    readonly.unmount()
+  it('renders all customer delivery references and real update time/remark without leaking internal IDs', async () => {
+    const value = detail(); value.documents.deliveries = ['DEL-A', 'DEL-B'].map((deliveryNo, index) => ({ deliveryNo, customerId: `C${index}`, customerName: `客户${index}`, outboundNo: `OUT-${index}`, groupKey: `group-${index}`, destination: destination(), status: 'WAIT_DELIVERY', packageCount: 1, palletCount: 1 }))
+    vi.mocked(getDispatch).mockResolvedValueOnce(value)
+    const wrapper = mount(DispatchDetailView, options); await flushPromises(); await wrapper.findAll('[role="tab"]')[2]!.trigger('click')
+    expect(wrapper.text()).toContain('DEL-A'); expect(wrapper.text()).toContain('DEL-B'); expect(wrapper.text()).toContain('真实备注')
+    expect(wrapper.findAll('button').some(button => button.text() === 'DEL-A')).toBe(false); wrapper.unmount()
   })
-  it.each([false, true])('returns to the original inquiry only for a valid source: %s', async fromInquiry => {
-    if (fromInquiry) Object.assign(sourceQuery, { fleetSource: 'inquiry', fleetOfferNo: 'FO-1', fleetBookingNo: 'FB-2' })
-    const wrapper = mount(DispatchDetailView, { global: { plugins: [ElementPlus], stubs: { DataTable: DataTableStub } } })
-    await flushPromises()
-    const backButton = wrapper.get('button.density-back')
-    expect(backButton.text()).toBe(fromInquiry ? '返回原拼车登记' : '返回列表')
-    await backButton.trigger('click')
-    expect(routerPush).toHaveBeenCalledWith(fromInquiry ? { name: 'overseas-master-data-capacity-offer-detail', params: { offerNo: 'FO-1' }, query: { inquiry: 'FB-2' } } : { name: 'overseas-dispatches' })
-    wrapper.unmount()
+  it('requires a literal service allowance and permission for a write action', async () => {
+    can.mockReturnValue(true); vi.mocked(getDispatch).mockResolvedValueOnce(detail({ actions: { DEPART: { allowed: false, blockCode: 'NOT_ARRANGED', blockReason: '尚未安排派送' } } }))
+    const wrapper = mount(DispatchDetailView, options); await flushPromises()
+    expect(wrapper.text()).toContain('尚未安排派送'); expect(wrapper.findAll('button').some(button => button.text() === '确认发车')).toBe(false); wrapper.unmount()
+  })
+  it('retains a real API failure and exposes retry rather than rendering a successful empty detail', async () => {
+    vi.mocked(getDispatch).mockRejectedValueOnce(new Error('permission denied'))
+    const wrapper = mount(DispatchDetailView, options); await flushPromises(); expect(wrapper.text()).toContain('排车详情加载失败，请重试'); expect(wrapper.findAll('[role="tab"]')).toHaveLength(0); wrapper.unmount()
+  })
+  it('keeps the original inquiry return target', async () => {
+    Object.assign(query, { fleetOfferNo: 'FO-1', fleetBookingNo: 'FB-2' }); const wrapper = mount(DispatchDetailView, options); await flushPromises(); await wrapper.get('button.density-back').trigger('click')
+    expect(push).toHaveBeenCalledWith({ name: 'overseas-master-data-capacity-offer-detail', params: { offerNo: 'FO-1' }, query: { inquiry: 'FB-2' } }); wrapper.unmount()
   })
-
 })

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

@@ -1,187 +1,95 @@
 <script setup lang="ts">
-import { inquiryReturnTarget } from '@/modules/overseas-master-data'
-import { physicalWeightKg } from '../dispatchPhysicalWeight'
 import '@/styles/adminDensity.css'
-import { computed, onMounted, ref } from 'vue'
+import { computed, onBeforeUnmount, ref, watch } from 'vue'
 import { useRoute, useRouter } from 'vue-router'
+import { inquiryReturnTarget } from '@/modules/overseas-master-data'
 import { useAccessPreviewStore } from '@/core/access/accessPreview'
 import { getApiErrorDetails, type ApiErrorDetails } from '@/shared/api/http'
 import ApiErrorMeta from '@/shared/components/ApiErrorMeta.vue'
 import DataTable, { type DataTableColumn } from '@/shared/components/DataTable.vue'
 import LoadErrorState from '@/shared/components/LoadErrorState.vue'
-import { getDispatch, type DispatchItemDto, type DispatchSummaryDto } from '../api/dispatches'
+import { getDispatch } from '../api/dispatches'
+import type { DispatchAction, DispatchDetail } from '../dispatchContracts'
+import { stageLabel } from '../dispatchContracts'
+import { canDispatchAction, dispatchActionLabels, displayDispatchValue as text } from '../dispatchPresentation'
+import DispatchWorkflowDialog from '../components/DispatchWorkflowDialog.vue'
+import DispatchEvidenceFiles from '../components/DispatchEvidenceFiles.vue'
 import OverseasDetailShell from '../components/OverseasDetailShell.vue'
-import { formatOverseasDateTime } from '../lastMilePresentation'
+import { formatOverseasDateTime as time } from '../lastMilePresentation'
 import { overseasWarehousePermissions as permission } from '../permissions'
 
-interface DetailField { label: string; value: string | number }
-interface RelatedOrderRow {
-  orderNo: string
-  weight: number | null
-  palletCount: number
-  fbaWarehouse: string
-  volume: number
-  containerNo: string
-}
-
-const route = useRoute()
-const router = useRouter()
-const access = useAccessPreviewStore()
+const route = useRoute(), router = useRouter(), access = useAccessPreviewStore()
 const dispatchNo = computed(() => String(route.params.dispatchNo || ''))
-const detail = ref<DispatchSummaryDto | null>(null)
-const loading = ref(false)
-const loadError = ref<ApiErrorDetails | null>(null)
-const actionBlockReasons = computed(() => {
-  const actions = detail.value?.actions
-  if (!actions) return detail.value ? ['操作资格暂未返回，请刷新详情'] : []
-  return [...new Set([actions.editBlockReason, actions.cancelBlockReason, actions.removePalletBlockReason, actions.transferBlockReason].filter(Boolean))]
-})
-function openTrip() {
-  if (!detail.value?.workflow || !access.can('platform:fleet:trip:list')) return
-  void router.push({ name: 'overseas-master-data-trip-detail', params: { tripNo: detail.value.workflow.tripNo }, query: { tab: 'overview' } })
-}
-function openOutbound() {
-  if (!detail.value?.actions?.outboundNo || !access.can(permission.outboundList)) return
-  void router.push({ name: 'overseas-outbounds', query: { documentNo: detail.value.actions.outboundNo } })
-}
-
-const dispatchStatusLabels: Record<string, string> = {
-  PENDING_DEPARTURE: '待发车',
-  PICKING: '拣货中',
-  READY_TO_DEPART: '待发车（拣货完成）',
-  PARTIAL_READY_TO_DEPART: '待发车（部分完成）',
-  DEPARTED: '已发车',
-  PARTIAL_DEPARTED: '已发车（部分完成）',
-  CANCELLED: '已取消',
-}
-const appointmentStatusLabels: Record<string, string> = {
-  PENDING: '待预约',
-  BOOKED: '已预约',
-  RESERVED: '已预约',
-  CONFIRMED: '已确认',
-  CANCELLED: '已取消',
-}
-
-function text(value: unknown) { return String(value ?? '').trim() || '—' }
-function dispatchStatus(value: unknown) {
-  const code = String(value ?? '').trim()
-  return dispatchStatusLabels[code] || text(code)
-}
-function appointmentStatus(value: unknown) {
-  const code = String(value ?? '').trim()
-  return appointmentStatusLabels[code] || text(code)
-}
-function orderReferences(item: DispatchItemDto) {
-  const references = String(item.orderRefs || '').split(/[,，;；\s]+/).map((value) => value.trim()).filter(Boolean)
-  return references.length ? references : [text(item.orderNo)]
-}
-
-const vehicleFields = computed<DetailField[]>(() => [
-  { label: '车牌号', value: text(detail.value?.vehiclePlate) },
-  { label: '司机', value: text(detail.value?.driverName) },
-  { label: '联系电话', value: text(detail.value?.driverPhone) },
-  { label: '拖车公司名称', value: text(detail.value?.carrierName) },
-  { label: '车辆状态', value: dispatchStatus(detail.value?.status) },
+const detail = ref<DispatchDetail | null>(null), activeTab = ref('vehicle'), loading = ref(false), loadError = ref<ApiErrorDetails | null>(null)
+const operation = ref<'ROUTE' | undefined>()
+const action = ref<DispatchAction>('EDIT'), actionOpen = ref(false)
+const detailActions: DispatchAction[] = ['EDIT', 'ADD_CARGO', 'REMOVE_CARGO', 'SUBMIT_REVIEW', 'DISPATCH_REVIEW', 'LOADING_REVIEW', 'RETURN_TO_REVIEW', 'LOADING_COMPLETE', 'ARRANGE_DELIVERY', 'DEPART', 'CANCEL']
+const visibleActions = computed(() => detailActions.filter(value => canDispatchAction(detail.value?.actions, value, access.can)))
+const actionBlockReasons = computed(() => [...new Set(Object.values(detail.value?.actions || {}).map(gate => gate?.allowed === true ? '' : gate?.blockReason).filter(Boolean))])
+const vehicleFields = computed(() => [
+  ['车牌号', text(detail.value?.vehicleInfo.vehicle?.plate)], ['司机', text(detail.value?.vehicleInfo.driver?.name)],
+  ['联系电话', text(detail.value?.vehicleInfo.driver?.phone)], ['拖车公司名称', text(detail.value?.vehicleInfo.vehicle?.carrierName)], ['车辆状态', text(detail.value?.vehicleInfo.vehicle?.vehicleStatus)],
 ])
-const dispatchFields = computed<DetailField[]>(() => [
-  { label: '路线', value: text(detail.value?.route) },
-  { label: '发车时间', value: formatOverseasDateTime(detail.value?.departAt) },
-  { label: '预计到达时间', value: formatOverseasDateTime(detail.value?.estimatedArrivalAt) },
-  { label: 'FBA预约', value: appointmentStatus(detail.value?.fbaAppointmentStatus) },
-  { label: '车辆预约', value: appointmentStatus(detail.value?.vehicleAppointmentStatus) },
+const dispatchFields = computed(() => [
+  ['路线', text(detail.value?.dispatchInfo.route)], ['发车时间', time(detail.value?.dispatchInfo.departedAt)],
+  ['预计到达时间', time(detail.value?.dispatchInfo.estimatedArrivalAt)],
+  ['FBA预约', detail.value?.dispatchInfo.fbaAppointments.map(item => [item.destinationWarehouseCode, item.appointmentNo, item.status].filter(Boolean).join(' · ')).join('；') || '—'],
+  ['车辆预约', detail.value?.dispatchInfo.vehicleAppointment ? [detail.value.dispatchInfo.vehicleAppointment.referenceNo, detail.value.dispatchInfo.vehicleAppointment.status, time(detail.value.dispatchInfo.vehicleAppointment.appointmentAt)].join(' · ') : '—'],
 ])
-const documentFields = computed<DetailField[]>(() => [
-  { label: '排车单号', value: text(detail.value?.dispatchNo || dispatchNo.value) },
-  { label: '关联订单', value: text(detail.value?.orderNos) },
-  { label: '创建时间', value: formatOverseasDateTime(detail.value?.createdAt) },
-  { label: '更新时间', value: '—' },
-  { label: '备注', value: '—' },
-  ...(detail.value?.partialCompletionReason
-    ? [{ label: '部分完成原因', value: text(detail.value.partialCompletionReason) }]
-    : []),
+const documentFields = computed(() => [
+  ['排车单号', text(detail.value?.documents.dispatchNo)], ['创建时间', time(detail.value?.documents.createdAt)],
+  ['更新时间', time(detail.value?.documents.updatedAt)], ['备注', text(detail.value?.documents.remark)],
 ])
-
-const relatedOrders = computed<RelatedOrderRow[]>(() => {
-  const grouped = new Map<string, { pallets: Set<string>; destinations: Set<string>; weight: number | null; volume: number }>()
-  for (const item of detail.value?.items || []) {
-    for (const orderNo of orderReferences(item)) {
-      const current = grouped.get(orderNo) || { pallets: new Set<string>(), destinations: new Set<string>(), weight: 0, volume: 0 }
-      current.pallets.add(String(item.warehousePalletId || item.planPalletId || item.id))
-      const destination = text(item.fbaWarehouseCode || item.destinationWarehouseCode || item.destinationWarehouseName)
-      if (destination !== '—') current.destinations.add(destination)
-      const itemWeight = physicalWeightKg(item.grossWeightKg)
-      current.weight = current.weight === null || itemWeight === null ? null : current.weight + itemWeight
-      current.volume += Number(item.volumeCbm || 0)
-      grouped.set(orderNo, current)
-    }
-  }
-  return [...grouped.entries()].map(([orderNo, value]) => ({
-    orderNo,
-    weight: value.weight === null ? null : Number(value.weight.toFixed(3)),
-    palletCount: value.pallets.size,
-    fbaWarehouse: [...value.destinations].join('、') || '—',
-    volume: Number(value.volume.toFixed(3)),
-    containerNo: '—',
-  }))
-})
-
+const relatedOrders = computed(() => detail.value?.orderDetails || [])
 const orderColumns: DataTableColumn[] = [
+  { key: 'customerName', prop: 'customerName', label: '客户', minWidth: 140 },
   { key: 'orderNo', prop: 'orderNo', label: '订单号', minWidth: 210 },
-  { key: 'weight', prop: 'weight', label: '重量(kg)', minWidth: 130, align: 'right' },
+  { key: 'inboundCode', prop: 'inboundCode', label: '入仓码', minWidth: 170 },
+  { key: 'weight', prop: 'grossWeightKg', label: '重量(kg)', minWidth: 130, align: 'right' },
   { key: 'palletCount', prop: 'palletCount', label: '托数', minWidth: 100, align: 'right' },
-  { key: 'fbaWarehouse', prop: 'fbaWarehouse', label: '目的FBA仓', minWidth: 150 },
-  { key: 'volume', prop: 'volume', label: '体积(m³)', minWidth: 130, align: 'right' },
+  { key: 'fbaWarehouse', prop: 'destinationFbaWarehouse', label: '目的FBA仓', minWidth: 150 },
+  { key: 'volume', prop: 'volumeCbm', label: '体积(m³)', minWidth: 130, align: 'right' },
   { key: 'containerNo', prop: 'containerNo', label: '集装箱号', minWidth: 170 },
 ]
-
+let generation = 0
 async function load() {
-  if (!dispatchNo.value) {
-    loadError.value = { message: '详情缺少排车单号，请从排车列表重新进入' }
-    return
-  }
+  const current = ++generation, no = dispatchNo.value
+  detail.value = null; loadError.value = null
+  if (!no) { loadError.value = { message: '详情缺少排车单号，请从排车列表重新进入' }; return }
   loading.value = true
-  loadError.value = null
-  try { detail.value = await getDispatch(dispatchNo.value) }
-  catch (error) { loadError.value = getApiErrorDetails(error, '排车详情加载失败，请重试') }
-  finally { loading.value = false }
+  try { const result = await getDispatch(no); if (current === generation) { if (result.dispatchNo !== no) throw new Error('返回排车单与当前业务号不一致'); detail.value = result } }
+  catch (error) { if (current === generation) loadError.value = getApiErrorDetails(error, '排车详情加载失败，请重试') }
+  finally { if (current === generation) loading.value = false }
 }
 function back() { void router.push(inquiryReturnTarget(route.query) || { name: 'overseas-dispatches' }) }
-
-onMounted(load)
+function openAction(value: DispatchAction, requestedOperation?: 'ROUTE') { if (!canDispatchAction(detail.value?.actions, value, access.can)) return; operation.value = requestedOperation; action.value = value; actionOpen.value = true }
+watch(dispatchNo, load, { immediate: true })
+onBeforeUnmount(() => { generation++ })
 </script>
 
 <template>
-  <OverseasDetailShell class="admin-density" dense title="排车详情" reference-label="排车单号" :reference-value="detail?.dispatchNo || dispatchNo" :back-text="inquiryReturnTarget(route.query) ? '返回原拼车登记' : undefined" :back-label="inquiryReturnTarget(route.query) ? '返回原拼车登记' : '返回排车列表'" domain="排车详情" :pending="false" :status-text="detail ? dispatchStatus(detail.status) : '加载中'" @back="back">
+  <OverseasDetailShell class="admin-density" dense title="排车详情" reference-label="排车单号" :reference-value="detail?.dispatchNo || dispatchNo" :back-text="inquiryReturnTarget(route.query) ? '返回原拼车登记' : undefined" :back-label="inquiryReturnTarget(route.query) ? '返回原拼车登记' : '返回排车列表'" domain="排车详情" :pending="false" :status-text="detail ? detail.status === 'CANCELLED' ? '已取消' : stageLabel(detail.stage) : '加载中'" @back="back">
     <LoadErrorState v-if="loadError" title="排车详情加载失败" :message="loadError.message" :loading="loading" @retry="load"><template #details><ApiErrorMeta :details="loadError" /></template></LoadErrorState>
     <div v-else v-loading="loading" class="dispatch-detail" :aria-busy="loading">
-      <section v-if="detail" class="detail-section" aria-label="排车操作提示"><p v-for="reason in actionBlockReasons" :key="String(reason)">{{ reason }}</p><div class="density-actions"><el-button v-if="detail.workflow && access.can('platform:fleet:trip:list')" class="density-action" @click="openTrip">处理原车次 {{ detail.workflow.tripNo }}</el-button><el-button v-if="detail.actions?.outboundNo && access.can(permission.outboundList)" class="density-action" @click="openOutbound">查看原出库 {{ detail.actions.outboundNo }}</el-button></div></section>
-      <div class="summary-grid">
-        <section class="detail-section" aria-labelledby="dispatch-vehicle-heading"><h2 id="dispatch-vehicle-heading">车辆信息</h2><dl class="detail-fields density-fields"><div v-for="field in vehicleFields" :key="field.label"><dt>{{ field.label }}</dt><dd>{{ field.value }}</dd></div></dl></section>
-        <section class="detail-section" aria-labelledby="dispatch-info-heading"><h2 id="dispatch-info-heading">排车信息</h2><dl class="detail-fields density-fields"><div v-for="field in dispatchFields" :key="field.label"><dt>{{ field.label }}</dt><dd>{{ field.value }}</dd></div></dl></section>
-        <section class="detail-section document-section" aria-labelledby="dispatch-document-heading"><h2 id="dispatch-document-heading">单据信息</h2><dl class="detail-fields density-fields"><div v-for="field in documentFields" :key="field.label"><dt>{{ field.label }}</dt><dd>{{ field.value }}</dd></div></dl></section>
-      </div>
-      <section class="detail-section order-section" aria-labelledby="dispatch-orders-heading"><h2 id="dispatch-orders-heading">关联订单明细</h2><DataTable :data="relatedOrders" :columns="orderColumns" column-settings-mode="hide" row-key="orderNo" empty-text="暂无关联订单明细" /></section>
+      <section v-if="detail" class="detail-section" aria-label="排车操作提示"><p v-for="reason in actionBlockReasons" :key="String(reason)">{{ reason }}</p><div class="density-actions"><el-button v-for="value in visibleActions" :key="value" class="density-action" @click="openAction(value)">{{ dispatchActionLabels[value] }}</el-button><el-button v-if="canDispatchAction(detail?.actions, 'EDIT', access.can)" @click="openAction('EDIT', 'ROUTE')">调整卸货顺序</el-button></div></section>
+      <el-tabs v-model="activeTab" class="density-element-tabs density-contained-tabs">
+        <el-tab-pane name="vehicle"><template #label><span class="density-tab-icon" aria-hidden="true">🚚</span><span>车辆信息</span></template><dl class="detail-fields density-fields"><div v-for="field in vehicleFields" :key="field[0]"><dt>{{ field[0] }}</dt><dd>{{ field[1] }}</dd></div></dl><DispatchEvidenceFiles :model-value="detail?.vehicleInfo.vehicle?.evidenceFileIds || []" :dispatch-no="dispatchNo" kind="VEHICLE" readonly /><DispatchEvidenceFiles :model-value="detail?.vehicleInfo.driver?.evidence?.fileIds || []" :dispatch-no="dispatchNo" kind="DRIVER" readonly /></el-tab-pane>
+        <el-tab-pane name="dispatch"><template #label><span class="density-tab-icon" aria-hidden="true">📋</span><span>排车信息</span></template><dl class="detail-fields density-fields"><div v-for="field in dispatchFields" :key="field[0]"><dt>{{ field[0] }}</dt><dd>{{ field[1] }}</dd></div></dl></el-tab-pane>
+        <el-tab-pane name="documents"><template #label><span class="density-tab-icon" aria-hidden="true">📝</span><span>单据信息</span></template>
+          <dl class="detail-fields density-fields"><div v-for="field in documentFields" :key="field[0]"><dt>{{ field[0] }}</dt><dd>{{ field[1] }}</dd></div><div class="linked-documents"><dt>关联派送单</dt><dd><template v-for="delivery in detail?.documents.deliveries || []" :key="delivery.deliveryNo"><el-button v-if="access.can(permission.deliveryList)" link type="primary" @click="router.push({ name: 'overseas-delivery-order-detail', params: { deliveryNo: delivery.deliveryNo } })">{{ delivery.deliveryNo }}</el-button><span v-else>{{ text(delivery.deliveryNo) }}</span></template><span v-if="!detail?.documents.deliveries.length">—</span></dd></div></dl>
+          <div class="density-actions"><el-button v-for="outbound in detail?.documents.outbounds || []" v-show="access.can(permission.outboundList)" :key="outbound.outboundNo" link @click="router.push({ name: 'overseas-outbounds', query: { documentNo: outbound.outboundNo } })">查看出库 {{ outbound.outboundNo }}</el-button></div>
+        </el-tab-pane>
+        <el-tab-pane name="orders"><template #label><span class="density-tab-icon" aria-hidden="true">📦</span><span>关联订单明细</span></template><DataTable :data="relatedOrders" :columns="orderColumns" column-settings-mode="hide" row-key="sourceKey" empty-text="暂无关联订单明细" /></el-tab-pane>
+      </el-tabs>
     </div>
+    <DispatchWorkflowDialog v-model="actionOpen" :dispatch-no="dispatchNo" :action="action" :operation="operation" @saved="load" />
   </OverseasDetailShell>
 </template>
 
 <style scoped>
 .detail-section { min-width: 0; padding: var(--admin-space-5); }
-.summary-grid > .detail-section:nth-child(2) { border-right: 0; }
-.document-section { grid-column: 1 / -1; }
-.order-section h2 { margin-right: var(--admin-space-1); margin-left: var(--admin-space-1); }
-@media (max-width: 960px) {
-  .summary-grid { grid-template-columns: 1fr; }
-  .summary-grid > .detail-section, .summary-grid > .detail-section:nth-child(2) { border-right: 0; }
-  .document-section { grid-column: auto; }
-  .detail-fields, .document-section .detail-fields { grid-template-columns: 1fr; }
-  .detail-fields > div { grid-template-columns: 132px minmax(0, 1fr); }
-}
-
 .dispatch-detail { min-width: 0; min-height: 0; }
-.summary-grid { display: grid; grid-template-columns: minmax(0, 1fr); border: 0; border-bottom: 0; background: #fff; }
-.summary-grid > .detail-section { border-right: 0; border-bottom: 1px solid var(--cc-border); }
-.detail-section h2 { margin: 0 0 var(--admin-space-5); color: var(--cc-text); font-size: var(--admin-font-section); }
-.order-section { overflow: hidden; border: 0; border-top: 0; background: #fff; }
-
+.linked-documents { grid-column: 1 / -1; }
+.linked-documents dd { display: flex; flex-wrap: wrap; gap: var(--admin-space-4); overflow-wrap: anywhere; }
+@media (max-width: 960px) { .detail-fields { grid-template-columns: 1fr; } .detail-fields > div { grid-template-columns: 132px minmax(0, 1fr); } }
 </style>

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

@@ -1,382 +1,71 @@
 import { createPinia } from 'pinia'
-import ElementPlus, { ElMessage, ElFormItem, ElDatePicker, ElSelect, ElCheckbox } from 'element-plus'
-import AppDialog from '@/shared/components/AppDialog.vue'
-import { readFileSync } from 'node:fs'
-import { resolve } from 'node:path'
-import { enableAutoUnmount, flushPromises, mount } from '@vue/test-utils'
-import { afterAll, afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import QueryToolbar, { type QueryModel } from '@/shared/components/QueryToolbar.vue'
-import LoadErrorState from '@/shared/components/LoadErrorState.vue'
-import RowActions from '@/shared/components/RowActions.vue'
-import { cancelDispatch, getDispatchBolPdf, getDispatchExternalFreight, getDispatchFeeCoverage, listDispatches, removeDispatchItem, transferDispatchToDelivery, updateDispatch } from '../api/dispatches'
-import DeliveryFeeCoveragePanel from '../components/DeliveryFeeCoveragePanel.vue'
+import ElementPlus from 'element-plus'
+import { flushPromises, mount } from '@vue/test-utils'
+import { beforeEach, expect, it, vi } from 'vitest'
 import DispatchesView from './DispatchesView.vue'
-vi.mock('@/modules/warehouses', () => ({
-  listAllPlatformWarehouses: vi.fn(async (query: { keyword: string }) => [{ id: query.keyword, warehouseCode: query.keyword, warehouseType: 'FBA' }]),
-  getPlatformWarehouse: vi.fn(async (id: string) => ({ warehouse: { warehouseCode: id, warehouseType: id === '321' ? 'OVERSEAS' : 'FBA' }, addresses: [{ addressType: 'OPERATING', addressLine1: '100 Example Street', city: 'City', stateProvince: 'CA', countryCode: 'US' }], capabilities: [] })),
-}))
-
+import QueryToolbar from '@/shared/components/QueryToolbar.vue'
+import RowActions from '@/shared/components/RowActions.vue'
+import { getDispatch, getDispatchBolPdf, listDispatches } from '../api/dispatches'
+import { detail, listRow, page } from '../dispatchTestFixtures'
+import type { DispatchPage } from '../dispatchContracts'
+import { useDispatchCommandRecovery } from '../dispatchCommandRecovery'
+const identity = vi.hoisted(() => ({ id: '' }))
 const push = vi.hoisted(() => vi.fn())
-vi.mock('vue-router', () => ({ useRouter: () => ({ push }), useRoute: () => ({ query: {} }) }))
-const canPermission = vi.hoisted(() => vi.fn<(permissionCode: string) => boolean>(() => true))
-vi.mock('@/core/access/accessPreview', () => ({ useAccessPreviewStore: () => ({ can: canPermission }) }))
-vi.mock('../api/dispatches', () => ({ listDispatches: vi.fn(), removeDispatchItem: vi.fn(), getDispatchBolPdf: vi.fn(), getDispatchExternalFreight: vi.fn(), getDispatchFeeCoverage: vi.fn(), updateDispatch: vi.fn(), cancelDispatch: vi.fn(), transferDispatchToDelivery: vi.fn() }))
-
-class ResizeObserverStub implements ResizeObserver {
-  observe() {}
-  unobserve() {}
-  disconnect() {}
-}
-
-function memoryStorage(): Storage {
-  const values = new Map<string, string>()
-  return {
-    get length() { return values.size },
-    clear: () => values.clear(),
-    getItem: (key) => values.get(key) ?? null,
-    key: (index) => [...values.keys()][index] ?? null,
-    removeItem: (key) => values.delete(key),
-    setItem: (key, value) => values.set(key, value),
-  }
-}
-
-enableAutoUnmount(afterEach)
-afterEach(() => vi.restoreAllMocks())
-afterAll(() => vi.unstubAllGlobals())
-
-const allowedActions = { canEdit: true, editBlockReason: null, canCancel: true, cancelBlockReason: null,
-  canRemovePallet: true, removePalletBlockReason: null, canTransfer: true, transferBlockReason: null, outboundNo: null, outboundStatus: null }
-
-describe('DispatchesView', () => {
-  beforeEach(() => {
-    vi.stubGlobal('ResizeObserver', ResizeObserverStub)
-    vi.stubGlobal('localStorage', memoryStorage())
-    vi.mocked(listDispatches).mockReset().mockResolvedValue({
-      records: [{
-        id: '190000000000000099', dispatchNo: 'PC-1', appointmentBatches: [], actions: allowedActions, vehiclePlate: 'CA-100', driverName: '张师傅',
-        driverPhone: '555-0100', carrierName: 'Carrier A', orderNos: 'LM-1,LM-2', route: 'ONT8,LAX9',
-        overseasWarehouseId: '321', overseasWarehouseName: '洛杉矶仓', departAt: '2026-08-20T09:00:00', fbaAppointmentNo: 'FBA-1',
-        fbaAppointmentStatus: 'CONFIRMED', vehicleAppointmentStatus: 'BOOKED', estimatedArrivalAt: '2026-08-20T18:00:00',
-        status: 'PENDING_DEPARTURE', palletCount: 12, packageCount: 80, createdAt: '2026-08-19T16:00:00',
-      }],
-      page: 1, size: 20, total: 1, pages: 1,
-    })
-    vi.mocked(updateDispatch).mockReset()
-    vi.mocked(getDispatchBolPdf).mockReset().mockResolvedValue(new Blob(['%PDF-test'], { type: 'application/pdf' }))
-    vi.mocked(removeDispatchItem).mockReset()
-    vi.mocked(cancelDispatch).mockReset()
-    vi.mocked(transferDispatchToDelivery).mockReset().mockResolvedValue({ dispatchNo: 'PC-1', outboundNo: 'OUT-1', outboundStatus: 'WAIT_OUTBOUND', palletCount: 12, packageCount: 80, deliveries: [], replayed: false })
-    vi.mocked(getDispatchExternalFreight).mockReset().mockResolvedValue({ snapshotHash: 'own-hash', requiresDeliveryFee: true, quotes: [] })
-    vi.mocked(getDispatchFeeCoverage).mockReset().mockResolvedValue({ dispatchNo: 'PC-1', sourceComplete: true, blockReason: null, cargoHash: 'cargo-hash', cargo: [], feeSources: [] })
-    canPermission.mockReset().mockReturnValue(true)
-  })
-
-
-  it('queries stages on the server and discards an older response after switching', async () => {
-    let resolveOld!: (value: Awaited<ReturnType<typeof listDispatches>>) => void
-    vi.mocked(listDispatches).mockImplementationOnce(() => new Promise(resolve => { resolveOld = resolve }))
-    const wrapper = mount(DispatchesView, { global: { plugins: [createPinia(), ElementPlus] } })
-    await wrapper.get('[role="tablist"]').findAll('button')[2]!.trigger('click')
-    await flushPromises()
-    expect(listDispatches).toHaveBeenLastCalledWith(expect.objectContaining({ stage: 'LOADING', page: 1, status: undefined }))
-    expect(wrapper.text()).toContain('PC-1')
-    resolveOld({ records: [], total: 0, page: 1, size: 10, pages: 0 })
-    await flushPromises()
-    expect(wrapper.text()).toContain('PC-1')
-    await wrapper.get('[role="tablist"]').findAll('button')[3]!.trigger('click')
-    await flushPromises()
-    expect(listDispatches).toHaveBeenLastCalledWith(expect.objectContaining({ stage: 'AFTER_LOADING', page: 1 }))
-  })
-
-  it('shows the shared route map only in the after-loading vehicle section without another query', async () => {
-    const wrapper = mount(DispatchesView, { attachTo: document.body, global: { plugins: [createPinia(), ElementPlus] } })
-    await flushPromises()
-    expect(wrapper.text()).not.toContain('查看路线')
-    await wrapper.get('[aria-label="排车执行阶段"]').findAll('button')[3]!.trigger('click')
-    await flushPromises()
-    const requests = vi.mocked(listDispatches).mock.calls.length
-    await wrapper.findAll('button').find(button => button.text() === '查看路线')!.trigger('click')
-    await flushPromises()
-    expect(wrapper.findComponent({ name: 'TransportRouteDialog' }).props('modelValue')).toBe(true)
-    expect(wrapper.findComponent({ name: 'TransportRouteDialog' }).props('origin')).toEqual({ kind: 'warehouse', label: '洛杉矶仓', warehouseId: '321' })
-    expect(wrapper.findComponent({ name: 'TransportRouteDialog' }).props('destinations')).toEqual(['ONT8', 'LAX9'].map(code => ({ kind: 'warehouse', label: code, warehouseCode: code })))
-    expect(listDispatches).toHaveBeenCalledTimes(requests)
-    await wrapper.get('[aria-label="排车执行阶段"]').findAll('button')[1]!.trigger('click')
-    await flushPromises()
-    await wrapper.get('[aria-label="排车业务分区"]').findAll('button')[1]!.trigger('click')
-    expect(wrapper.findAll('button').some(button => button.text() === '查看路线')).toBe(false)
-  })
-
-  it('shows review facts and opens the matching trip section with read permission', async () => {
-    const result = await listDispatches({ page: 1, size: 10 })
-    result.records[0]!.workflow = { tripNo: 'TR-A', dispatchReview: { status: 'REJECTED', reason: '请核对货量', reviewedAt: null }, loadingReview: { status: 'PENDING', reason: null, reviewedAt: null } }
-    vi.mocked(listDispatches).mockClear().mockResolvedValue(result)
-    canPermission.mockImplementation(code => code === 'platform:fleet:trip:list')
-    const wrapper = mount(DispatchesView, { global: { plugins: [createPinia(), ElementPlus] } })
-    await flushPromises()
-    const sections = wrapper.get('[aria-label="排车业务分区"]')
-    expect(sections.findAll('button').map(button => button.text())).toEqual(['车辆信息'])
-    await wrapper.get('[aria-label="排车执行阶段"]').findAll('button')[1]!.trigger('click')
-    await flushPromises()
-    expect(sections.findAll('button').map(button => button.text())).toEqual(['车辆信息', '调度审核', '理货员审核'])
-    expect(wrapper.findAll('[role="tablist"]')).toHaveLength(2)
-    expect(wrapper.text()).not.toContain('请核对货量')
-    await sections.findAll('button')[1]!.trigger('click')
-    await flushPromises()
-    expect(wrapper.text()).toContain('请核对货量')
-    expect(wrapper.findAll('button').some(button => button.text() === '打印BOL')).toBe(false)
-    await wrapper.findAll('button').find(button => button.text() === '查看审核')!.trigger('click')
-    expect(push).toHaveBeenLastCalledWith({ name: 'overseas-master-data-trip-detail', params: { tripNo: 'TR-A' }, query: { tab: 'overview' } })
-    await sections.findAll('button')[2]!.trigger('click')
-    await flushPromises()
-    expect(wrapper.text()).not.toContain('请核对货量')
-    expect(wrapper.text()).toContain('待审核')
-    const links = wrapper.findAll('button').filter(button => button.text() === '查看审核')
-    await links[0]!.trigger('click')
-    expect(push).toHaveBeenLastCalledWith({ name: 'overseas-master-data-trip-detail', params: { tripNo: 'TR-A' }, query: { tab: 'loading' } })
-    expect(wrapper.text()).not.toContain('前往审核')
-    expect(listDispatches).toHaveBeenCalledTimes(2)
-  })
-
-  it.each([0, 2, 3, 4].flatMap(stageIndex => [1, 2].map(sectionIndex => [stageIndex, sectionIndex])))('leaving a review section for stage %s resets section %s to vehicle information', async (stageIndex, sectionIndex) => {
-    const wrapper = mount(DispatchesView, { global: { plugins: [createPinia(), ElementPlus] } })
-    await flushPromises()
-    const stages = wrapper.get('[aria-label="排车执行阶段"]').findAll('button')
-    const sections = wrapper.get('[aria-label="排车业务分区"]')
-    await stages[1]!.trigger('click')
-    await flushPromises()
-    await sections.findAll('button')[sectionIndex]!.trigger('click')
-    expect(wrapper.findAll('button').some(button => button.text() === '打印BOL')).toBe(false)
-    await stages[stageIndex]!.trigger('click')
-    await flushPromises()
-    expect(sections.findAll('button').map(button => button.text())).toEqual(['车辆信息'])
-    expect(sections.get('button').attributes('aria-selected')).toBe('true')
-    expect(wrapper.findAll('button').some(button => button.text() === '打印BOL')).toBe(true)
-    expect(wrapper.findAll('button').some(button => ['前往审核', '查看审核'].includes(button.text()))).toBe(false)
-    await stages[1]!.trigger('click')
-    await flushPromises()
-    expect(sections.findAll('button').map(button => button.text())).toEqual(['车辆信息', '调度审核', '理货员审核'])
-    expect(sections.get('button').attributes('aria-selected')).toBe('true')
-  })
-
-  it.each([
-    [[], ['查看', '打印BOL'], false],
-    [['edit'], ['查看', '打印BOL', '编辑'], false],
-    [['cancel'], ['查看', '打印BOL', '取消'], false],
-    [['transfer-delivery'], ['查看', '打印BOL', '转派送'], false],
-    [['edit', 'transfer-delivery'], ['查看', '打印BOL', '转派送', '更多'], true],
-    [['edit', 'cancel'], ['查看', '打印BOL', '编辑', '更多'], true],
-    [['edit', 'cancel', 'transfer-delivery'], ['查看', '打印BOL', '转派送', '更多'], true],
-  ])('uses the row action threshold for permissions %j', async (allowed, labels, overflow) => {
-    canPermission.mockImplementation(code => allowed.some(action => code === 'platform:overseas-warehouse:dispatch:' + action))
-    const wrapper = mount(DispatchesView, { global: { plugins: [createPinia(), ElementPlus] } })
-    await flushPromises()
-    const actions = wrapper.get('.el-table__body-wrapper .density-actions')
-    expect(actions.findAll('button').map(button => button.text().trim())).toEqual(labels)
-    expect(actions.find('.el-dropdown').exists()).toBe(overflow)
-  })
-
-  it('keeps the integrated header and filters usable through failure and retry', async () => {
-    vi.mocked(listDispatches).mockRejectedValueOnce(new Error('网络错误'))
-    const wrapper = mount(DispatchesView, { global: { plugins: [createPinia(), ElementPlus] } })
-    await flushPromises()
-    const card = wrapper.get('.data-table--integrated')
-    expect(card.get('.data-table__toolbar h1').text()).toBe('排车列表')
-    expect(card.get('.data-table__toolbar button[aria-label="列设置"]').text()).toBe('字段设置')
-    expect(card.get('.data-table__filters').findComponent(QueryToolbar).exists()).toBe(true)
-    expect(card.find('.el-table').exists()).toBe(false)
-    expect(card.find('.data-table__pagination').exists()).toBe(false)
-    wrapper.findComponent(LoadErrorState).vm.$emit('retry')
-    await flushPromises()
-    expect(card.find('.data-table__state').exists()).toBe(false)
-    expect(card.get('.el-table').text()).toContain('PC-1')
-    expect(card.get('.data-table__pagination').text()).toContain('共 1 条排车记录')
-  })
-
-  it('loads immediately and sends only supported page filters', async () => {
-    const wrapper = mount(DispatchesView, { global: { plugins: [createPinia(), ElementPlus] } })
-    await flushPromises()
-    expect(listDispatches).toHaveBeenCalledWith({ page: 1, size: 10, dispatchNo: undefined, vehiclePlate: undefined, status: undefined, fbaAppointmentNo: undefined })
-
-    const model: QueryModel = {
-      dispatchNo: 'PC-1', vehiclePlate: 'CA-100',
-      status: 'PENDING_DEPARTURE', fbaAppointmentNo: 'FBA-1',
-    }
-    wrapper.findComponent(QueryToolbar).vm.$emit('search', model)
-    await flushPromises()
-
-    expect(listDispatches).toHaveBeenCalledWith({
-      page: 1, size: 10, dispatchNo: 'PC-1',
-      vehiclePlate: 'CA-100', status: 'PENDING_DEPARTURE', fbaAppointmentNo: 'FBA-1',
-    })
-    expect(wrapper.text()).toContain('PC-1')
-    expect(wrapper.text()).toContain('待发车')
-    expect(wrapper.text()).toContain('FBA-1 · 已确认')
-    expect(wrapper.text()).toContain('已预约')
-    expect(wrapper.get('.data-table').classes()).not.toContain('admin-text-actions')
-    expect(wrapper.get('.query-toolbar').classes()).not.toContain('admin-text-actions')
-    expect(wrapper.get('.data-table__toolbar button[aria-label="列设置"]').find('svg').exists()).toBe(true)
-    expect(wrapper.get('.query-toolbar__actions .el-button--primary').text()).toBe('查询')
-    expect(wrapper.get('button[aria-label="上一页"]').find('svg').exists()).toBe(true)
-    expect(wrapper.findAll('.query-toolbar__actions button svg')).toHaveLength(3)
-    expect(wrapper.get('.el-table__body-wrapper .row-actions').classes()).toContain('admin-text-actions')
-  })
-
-  it('keeps long dispatch identifiers as strings', async () => {
-    vi.mocked(listDispatches).mockResolvedValueOnce({
-      records: [{ id: '190000000000000099', dispatchNo: '190000000000000099', appointmentBatches: [] }],
-      page: 1, size: 20, total: 1, pages: 1,
-    })
-    const wrapper = mount(DispatchesView, { global: { plugins: [createPinia(), ElementPlus] } })
-    await flushPromises()
-    expect(wrapper.html()).toContain('190000000000000099')
-  })
-
-  it('opens the server-generated BOL PDF with one request', async () => {
-    const pdfWindow = { location: { href: '' }, close: vi.fn() }
-    vi.spyOn(window, 'open').mockReturnValue(pdfWindow as unknown as Window)
-    vi.stubGlobal('URL', { createObjectURL: vi.fn(() => 'blob:dispatch-bol'), revokeObjectURL: vi.fn() })
-    const wrapper = mount(DispatchesView, { global: { plugins: [createPinia(), ElementPlus] } })
-    await flushPromises()
-    expect(getDispatchBolPdf).not.toHaveBeenCalled()
-
-    await wrapper.findAll('.el-table__body-wrapper button').find((button) => button.text().trim() === '打印BOL')!.trigger('click')
-    await flushPromises()
-
-    expect(getDispatchBolPdf).toHaveBeenCalledOnce()
-    expect(getDispatchBolPdf).toHaveBeenCalledWith('PC-1')
-    expect(pdfWindow.location.href).toBe('blob:dispatch-bol')
-  })
-
-  it('documents the backend feature flag required by a missing endpoint', () => {
-    const source = readFileSync(resolve(process.cwd(), 'src/modules/overseas-warehouse/pages/DispatchesView.vue'), 'utf8')
-    expect(source).toContain('请确认海外尾程排车接口已发布')
-  })
-
-  it('uses server blocks even for a pending row and offers the original trip and outbound paths', async () => {
-    const result = await listDispatches({ page: 1, size: 10 })
-    Object.assign(result.records[0]!, {
-      actions: { ...allowedActions, canEdit: false, canCancel: false, canRemovePallet: false, canTransfer: false,
-        editBlockReason: '请先在车次 TR-A 中解除关联', cancelBlockReason: '请先在车次 TR-A 中解除关联',
-        removePalletBlockReason: '请先在车次 TR-A 中解除关联', transferBlockReason: '原出库已取消，请取消原排车后通过新预排重新安排',
-        outboundNo: 'OUT-A', outboundStatus: 'CANCELLED' },
-      workflow: { tripNo: 'TR-A', dispatchReview: { status: 'PENDING', reason: null, reviewedAt: null }, loadingReview: { status: 'PENDING', reason: null, reviewedAt: null } },
-    })
-    vi.mocked(listDispatches).mockClear().mockResolvedValue(result)
-    const wrapper = mount(DispatchesView, { global: { plugins: [createPinia(), ElementPlus] } }); await flushPromises()
-    const actions = wrapper.findAllComponents(RowActions).find(item => item.element.closest('.el-table__body-wrapper'))!
-    const visible = actions.props('actions').filter(action => action.visible !== false).map(action => action.key)
-    expect(visible.filter(key => ['edit', 'cancel', 'transfer'].includes(key))).toEqual([])
-    expect(visible).toEqual(expect.arrayContaining(['trip', 'outbound', 'detail']))
-    expect(wrapper.text()).toContain('原出库已取消')
-    actions.vm.$emit('action', 'edit'); actions.vm.$emit('action', 'transfer'); await flushPromises()
-    expect(wrapper.findAllComponents(AppDialog).filter(dialog => ['编辑排车', '转派送'].includes(String(dialog.props('title')))).every(dialog => !dialog.props('modelValue'))).toBe(true)
-    actions.vm.$emit('action', 'trip'); await flushPromises()
-    expect(push).toHaveBeenLastCalledWith({ name: 'overseas-master-data-trip-detail', params: { tripNo: 'TR-A' }, query: { tab: 'overview' } })
-    actions.vm.$emit('action', 'outbound'); await flushPromises()
-    expect(push).toHaveBeenLastCalledWith({ name: 'overseas-outbounds', query: { documentNo: 'OUT-A' } })
-    expect(getDispatchExternalFreight).not.toHaveBeenCalled()
-  })
-
-  it('keeps write commands closed when action capabilities are missing', async () => {
-    const result = await listDispatches({ page: 1, size: 10 })
-    delete result.records[0]!.actions
-    vi.mocked(listDispatches).mockClear().mockResolvedValue(result)
-    const wrapper = mount(DispatchesView, { global: { plugins: [createPinia(), ElementPlus] } }); await flushPromises()
-    expect(wrapper.findComponent(RowActions).props('actions').filter(action => action.visible !== false).map(action => action.key)).toEqual(['detail', 'bol'])
-    expect(wrapper.text()).toContain('操作资格暂未返回，请刷新列表')
-  })
-
-  it.each([
-    { replayed: true, outboundStatus: 'WAIT_OUTBOUND', method: 'info' as const, message: '本次未重复生成' },
-    { replayed: true, outboundStatus: 'CANCELLED', method: 'warning' as const, message: '请取消原排车后重新预排' },
-  ])('reports transfer replay accurately for $outboundStatus', async result => {
-    const success = vi.spyOn(ElMessage, 'success'), notice = vi.spyOn(ElMessage, result.method)
-    vi.mocked(transferDispatchToDelivery).mockResolvedValue({ dispatchNo: 'PC-1', outboundNo: 'OUT-OLD', palletCount: 1, packageCount: 2, deliveries: [], replayed: result.replayed, outboundStatus: result.outboundStatus })
-    vi.mocked(getDispatchExternalFreight).mockResolvedValue({ snapshotHash: 'external-hash', requiresDeliveryFee: false, quotes: [] })
-    const wrapper = mount(DispatchesView, { global: { plugins: [createPinia(), ElementPlus] } }); await flushPromises()
-    await wrapper.findAll('button').find(button => button.text() === '转派送')!.trigger('click'); await flushPromises()
-    const dialog = wrapper.findAllComponents(AppDialog).find(item => item.props('title') === '转派送')!
-    dialog.findComponent(ElDatePicker).vm.$emit('update:modelValue', '2026-10-03T12:00:00')
-    for (const [label, value] of [['派送方式', 'TRUCK_PALLET'], ['提货方式', 'WAREHOUSE_PICKUP'], ['装车类型', 'PALLET']]) {
-      dialog.findAllComponents(ElFormItem).find(item => item.props('label') === label)!.findComponent(ElSelect).vm.$emit('update:modelValue', value)
-    }
-    await flushPromises(); dialog.vm.$emit('confirm'); await flushPromises()
-    expect(notice).toHaveBeenCalledWith(expect.stringContaining(result.message))
-    expect(success).not.toHaveBeenCalledWith('已生成出库单和派送单')
-  })
-
-  it('loads external quotes only when opened and submits their hash without a duplicate delivery charge', async () => {
-    vi.mocked(getDispatchExternalFreight).mockResolvedValue({ snapshotHash: 'external-hash', requiresDeliveryFee: false, quotes: [
-      { bookingNo: 'FB-1', recordVersion: '4', incomingNo: 'WT-1', inboundCode: 'IN-1', customerName: '客户甲', destinationKey: 'FBA:ONT8', currency: 'CNY', amount: 60, quantity: 2, quantityUnit: '托位', unitPrice: 30 },
-    ] })
-    const wrapper = mount(DispatchesView, { global: { plugins: [createPinia(), ElementPlus] } })
-    await flushPromises()
-    expect(getDispatchExternalFreight).not.toHaveBeenCalled()
-    await wrapper.findAll('button').find(button => button.text() === '转派送')!.trigger('click')
-    await flushPromises()
-    expect(getDispatchExternalFreight).toHaveBeenCalledOnce()
-    expect(getDispatchExternalFreight).toHaveBeenCalledWith('PC-1')
-    const dialog = wrapper.findAllComponents(AppDialog).find(item => item.props('title') === '转派送')!
-    expect(dialog.text()).toContain('FB-1')
-    expect(dialog.text()).not.toContain('请输入派送费用')
-    dialog.findComponent(ElDatePicker).vm.$emit('update:modelValue', '2026-10-03T12:00:00')
-    for (const [label, value] of [['派送方式', 'TRUCK_PALLET'], ['提货方式', 'WAREHOUSE_PICKUP'], ['装车类型', 'PALLET']]) {
-      dialog.findAllComponents(ElFormItem).find(item => item.props('label') === label)!.findComponent(ElSelect).vm.$emit('update:modelValue', value)
-    }
-    await flushPromises()
-    dialog.vm.$emit('confirm')
-    await flushPromises()
-    expect(transferDispatchToDelivery).toHaveBeenCalledWith('PC-1', expect.objectContaining({ fees: [], externalFreightHash: 'external-hash' }))
-  })
-
-  it('confirms an original delivery fee without submitting a new receivable', async () => {
-    vi.mocked(getDispatchFeeCoverage).mockResolvedValue({ dispatchNo: 'PC-1', sourceComplete: true, blockReason: null, cargoHash: 'actual-cargo',
-      cargo: [{ dispatchItemId: '201', warehousePalletId: '501', palletNo: 'PLT-1', orderId: '401', sourceRegion: 'FIRSTLEG', sourceInboundId: '11', inboundCode: 'IN-11', packages: 20, dispatchInboundCode: 'IN-11' }],
-      feeSources: [{ financeFeeId: '711', sourceFeeId: '811', sourceType: 'INBOUND_FEE', sourceVersion: 3, customerId: '101', sourceInboundId: '11', inboundCode: 'IN-11', feeItemCode: 'FREIGHT', feeItemName: '原运费', currency: 'CNY', amount: 100, sourceHash: 'original-fee-hash', status: 'AVAILABLE' }],
-    })
-    const wrapper = mount(DispatchesView, { global: { plugins: [createPinia(), ElementPlus] } })
-    await flushPromises()
-    expect(getDispatchFeeCoverage).not.toHaveBeenCalled()
-    await wrapper.findAll('button').find(button => button.text() === '转派送')!.trigger('click')
-    await flushPromises()
-    expect(getDispatchFeeCoverage).toHaveBeenCalledTimes(1)
-    const dialog = wrapper.findAllComponents(AppDialog).find(item => item.props('title') === '转派送')!
-    await dialog.findComponent(DeliveryFeeCoveragePanel).findAllComponents(ElCheckbox).find(row => row.text() === '已含派送')!.find('input').setValue(true)
-    dialog.findComponent(ElDatePicker).vm.$emit('update:modelValue', '2026-10-03T12:00:00')
-    for (const [label, value] of [['派送方式', 'TRUCK_PALLET'], ['提货方式', 'WAREHOUSE_PICKUP'], ['装车类型', 'PALLET']]) {
-      dialog.findAllComponents(ElFormItem).find(item => item.props('label') === label)!.findComponent(ElSelect).vm.$emit('update:modelValue', value)
-    }
-    await flushPromises()
-    expect(dialog.text()).toContain('本次全部货物已覆盖：派送')
-    dialog.vm.$emit('confirm')
-    await flushPromises()
-    expect(transferDispatchToDelivery).toHaveBeenCalledWith('PC-1', expect.objectContaining({ fees: [], feeCoverageCargoHash: 'actual-cargo', feeCoverage: [{ financeFeeId: '711', sourceVersion: 3, sourceHash: 'original-fee-hash', services: ['DELIVERY_FEE'] }] }))
-  })
-
-  it('gates edit, cancel, pallet removal and transfer with independent permissions and server capabilities', async () => {
-    const source = readFileSync(resolve(process.cwd(), 'src/modules/overseas-warehouse/pages/DispatchesView.vue'), 'utf8')
-    expect(source).toContain('permission.dispatchEdit')
-    expect(source).toContain('permission.dispatchCancel')
-    expect(source).toContain('permission.dispatchTransferDelivery')
-    expect(source).toContain("import RowActions, { type RowActionItem } from '@/shared/components/RowActions.vue'")
-    expect(source).toContain("{ key: 'transfer', label: '转派送', priority: 250")
-    expect(source).toContain('access.can(permission.dispatchEdit) && row.actions?.canEdit === true')
-    expect(source).toContain('access.can(permission.dispatchCancel) && row.actions?.canCancel === true')
-    expect(source).toContain('access.can(permission.dispatchTransferDelivery) && row.actions?.canTransfer === true')
-    expect(source).toContain('access.can(permission.dispatchEdit) && row.actions?.canRemovePallet === true')
-    expect(source).toContain('!canRemovePallet(editRow.value)')
-    expect(source).toContain('removeDispatchItem')
-    expect(source).not.toContain('托盘箱唛确认')
-    expect(source).not.toContain('palletCartonMarks')
-    expect(source).toContain('v-model="editForm.route" readonly')
-    expect(source).not.toContain('route: editForm.route.trim()')
-    expect(source).toContain('dispatchVehicleSizeOptions')
-    expect(source).not.toContain('departDispatch')
-
-    canPermission.mockReturnValue(false)
-    const wrapper = mount(DispatchesView, { global: { plugins: [createPinia(), ElementPlus] } })
-    await flushPromises()
-    expect(wrapper.text()).not.toContain('转派送')
-  })
+const can = vi.hoisted(() => vi.fn(() => true))
+vi.mock('vue-router', () => ({ useRoute: () => ({ query: {} }), useRouter: () => ({ push }) }))
+vi.mock('@/core/access/accessPreview', () => ({ useAccessPreviewStore: () => ({ can }) }))
+vi.mock('@/core/auth/auth', () => ({ useAuthStore: () => ({ user: identity }) }))
+vi.mock('@/modules/appointment-calendar', () => ({ appointmentReturnTarget: () => null }))
+vi.mock('@/modules/overseas-master-data', () => ({ TransportRouteDialog: { template: '<div />' }, routeLocation: (label: string) => ({ label }) }))
+vi.mock('../api/dispatches', () => ({ listDispatches: vi.fn(), getDispatch: vi.fn(), getDispatchBolPdf: vi.fn() }))
+const options = { global: { plugins: [createPinia(), ElementPlus], stubs: { SmartDispatchDialog: true, DispatchWorkflowDialog: true } } }
+beforeEach(() => { vi.clearAllMocks(); identity.id = crypto.randomUUID(); sessionStorage.clear(); can.mockReturnValue(true); vi.stubGlobal('ResizeObserver', class { observe() {} unobserve() {} disconnect() {} }); localStorage.clear(); vi.mocked(listDispatches).mockResolvedValue(page()); vi.mocked(getDispatch).mockResolvedValue(detail()) })
+it('offers recovery of the original pending command independently of the filtered list rows', async () => {
+  const pending = useDispatchCommandRecovery(() => identity.id); pending.begin('PC-OTHER', 'DEPART', { 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('shows exactly five phases and uses server stage counts instead of current page length', async () => {
+  const wrapper = mount(DispatchesView, options); await flushPromises()
+  const tabs = wrapper.get('[aria-label="排车执行阶段"]').findAll('button')
+  expect(tabs.map(tab => tab.text())).toEqual(['装车前 3', '装车中 1', '装车后 1', '派送中 1', '派送完成 1'])
+  expect(listDispatches).toHaveBeenCalledWith(expect.objectContaining({ stage: 'BEFORE_LOADING', status: 'ACTIVE', beforeLoadingSection: 'VEHICLE_INFO' }))
+  await tabs[3]!.trigger('click'); await flushPromises()
+  expect(listDispatches).toHaveBeenLastCalledWith(expect.objectContaining({ stage: 'DELIVERING' })); expect(wrapper.find('[aria-label="装车前审核分区"]').exists()).toBe(false); wrapper.unmount()
+})
+it('queries each review section on the server and includes only its legal review filter', async () => {
+  const wrapper = mount(DispatchesView, options); await flushPromises()
+  await wrapper.get('[aria-label="装车前审核分区"]').findAll('button')[1]!.trigger('click'); await flushPromises()
+  expect(listDispatches).toHaveBeenLastCalledWith(expect.objectContaining({ beforeLoadingSection: 'DISPATCH_REVIEW' }))
+  wrapper.getComponent(QueryToolbar).vm.$emit('search', { status: 'ACTIVE', reviewStatus: 'PENDING', dispatchNo: '', vehiclePlate: '' }); await flushPromises()
+  expect(listDispatches).toHaveBeenLastCalledWith(expect.objectContaining({ reviewStatus: 'PENDING' })); wrapper.unmount()
+})
+it('discards a late page response after switching phase', async () => {
+  let old!: (value: DispatchPage) => void
+  vi.mocked(listDispatches).mockImplementationOnce(() => new Promise(resolve => { old = resolve }))
+  const wrapper = mount(DispatchesView, options)
+  await wrapper.get('[aria-label="排车执行阶段"]').findAll('button')[1]!.trigger('click'); await flushPromises()
+  old(page([])); await flushPromises(); expect(wrapper.text()).toContain('PC/1'); wrapper.unmount()
+})
+it('gates every mutation with both its literal service capability and independent permission', async () => {
+  vi.mocked(listDispatches).mockResolvedValue(page([listRow({ actions: { DEPART: { allowed: false, blockReason: '未安排', blockCode: 'NO' }, EDIT: { allowed: true, blockCode: null, blockReason: null } } })]))
+  const wrapper = mount(DispatchesView, options); await flushPromises()
+  const actions = wrapper.findAllComponents(RowActions).find(entry => entry.props('moreLabel') === '更多操作 · PC/1')!.props('actions') as Array<{ key: string }>
+  expect(actions.map(row => row.key)).toContain('EDIT'); expect(actions.map(row => row.key)).not.toContain('DEPART')
+  can.mockReturnValue(false); wrapper.unmount()
+  const readonly = mount(DispatchesView, options); await flushPromises(); expect((readonly.findAllComponents(RowActions).find(entry => entry.props('moreLabel') === '更多操作 · PC/1')!.props('actions') as Array<{ key: string }>).map(row => row.key)).toEqual(['detail', 'bol']); readonly.unmount()
+})
+it('keeps server errors visible with the integrated query and retry context', async () => {
+  vi.mocked(listDispatches).mockRejectedValueOnce(new Error('service unavailable'))
+  const wrapper = mount(DispatchesView, options); await flushPromises(); expect(wrapper.text()).toContain('排车列表加载失败，请重试'); expect(wrapper.findComponent(QueryToolbar).exists()).toBe(true); wrapper.unmount()
+})
+it('navigates by the business number without arranging a separate trip', async () => {
+  const wrapper = mount(DispatchesView, options); await flushPromises(); wrapper.findAllComponents(RowActions).find(entry => entry.props('moreLabel') === '更多操作 · PC/1')!.vm.$emit('action', 'detail'); await flushPromises()
+  expect(push).toHaveBeenCalledWith({ name: 'overseas-dispatch-detail', params: { dispatchNo: 'PC/1' } }); expect(wrapper.text()).not.toContain('安排车次'); wrapper.unmount()
+})
+it('reads one BOL on demand and preserves popup failure handling', async () => {
+  vi.stubGlobal('open', vi.fn().mockReturnValue(null)); const wrapper = mount(DispatchesView, options); await flushPromises(); wrapper.findAllComponents(RowActions).find(entry => entry.props('moreLabel') === '更多操作 · PC/1')!.vm.$emit('action', 'bol'); await flushPromises(); expect(getDispatchBolPdf).not.toHaveBeenCalled(); wrapper.unmount()
 })

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

@@ -1,743 +1,127 @@
 <script setup lang="ts">
 import '@/styles/adminDensity.css'
-import { appointmentReturnTarget, appointmentReturnQuery } from '@/modules/appointment-calendar'
-import { TripPreparationDialog, TransportRouteDialog, routeLocation, type RouteLocation } from '@/modules/overseas-master-data'
-import { computed, onMounted, reactive, ref } from 'vue'
-import { ElMessage, ElMessageBox } from 'element-plus'
+import { computed, onBeforeUnmount, onMounted, ref } from 'vue'
 import { useRoute, useRouter } from 'vue-router'
+import { ElMessage } 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 ApiErrorMeta from '@/shared/components/ApiErrorMeta.vue'
-import DataTable, { type DataTableColumn } from '@/shared/components/DataTable.vue'
 import ListPageLayout from '@/shared/components/ListPageLayout.vue'
-import LoadErrorState from '@/shared/components/LoadErrorState.vue'
+import DataTable, { type DataTableColumn } from '@/shared/components/DataTable.vue'
 import QueryToolbar, { type QueryField, type QueryModel } from '@/shared/components/QueryToolbar.vue'
-import StatusBadge from '@/shared/components/StatusBadge.vue'
-import OperationErrorToast from '@/shared/components/OperationErrorToast.vue'
 import RowActions, { type RowActionItem } from '@/shared/components/RowActions.vue'
-import { useAccessPreviewStore } from '@/core/access/accessPreview'
-import { cancelDispatch, getDispatchBolPdf, getDispatchExternalFreight, getDispatchFeeCoverage, listDispatches, removeDispatchItem, transferDispatchToDelivery, updateDispatch, type DispatchItemDto, type DispatchSummaryDto, type ExternalFreightPreview } from '../api/dispatches'
-import DeliveryFeeCoveragePanel from '../components/DeliveryFeeCoveragePanel.vue'
-import { fullyCoveredServices, coveredServiceLabels, type FeeCoveragePreview, type FeeCoverageSelection } from '../feeCoverageTypes'
-import AppDialog from '@/shared/components/AppDialog.vue'
-import type { DispatchListItem } from '../types'
-import { formatOverseasDateTime } from '../lastMilePresentation'
-import { overseasWarehousePermissions as permission } from '../permissions'
-import { dispatchVehicleSizeOptions } from '../dispatchVehicleSpecs'
+import LoadErrorState from '@/shared/components/LoadErrorState.vue'
+import ApiErrorMeta from '@/shared/components/ApiErrorMeta.vue'
+import OperationErrorToast from '@/shared/components/OperationErrorToast.vue'
+import { getDispatch, getDispatchBolPdf, listDispatches } from '../api/dispatches'
+import { dispatchStages, reviewLabels, stageLabel, type BeforeLoadingSection, type DispatchAction, type DispatchListRow, type DispatchStage, type DispatchStatistics, type DispatchStatus, type ReviewStatus } from '../dispatchContracts'
+import { canDispatchAction, dispatchActionLabels, dispatchActionPermissions } from '../dispatchPresentation'
+import { formatOverseasDateTime as time } from '../lastMilePresentation'
+import SmartDispatchDialog from '../components/SmartDispatchDialog.vue'
+import DispatchWorkflowDialog from '../components/DispatchWorkflowDialog.vue'
+import { useDispatchCommandRecovery } from '../dispatchCommandRecovery'
 
-const route = useRoute(), router = useRouter()
-const routeOpen = ref(false)
-const routeOrigin = ref<RouteLocation>(routeLocation('')), routeDestinations = ref<RouteLocation[]>([])
-function openRoute(row: DispatchListItem) {
-  routeOrigin.value = { kind: 'warehouse', label: row.overseasWarehouse, warehouseId: dispatchSnapshots.get(row.dispatchNo)?.overseasWarehouseId || undefined }
-  // The service's route field is a comma-separated set of destination warehouse codes, not a stop sequence.
-  routeDestinations.value = [...new Set(row.route.split(',').map(code => code.trim()).filter(Boolean))].map(code => ({ kind: 'warehouse', label: code, warehouseCode: code }))
-  routeOpen.value = true
-}
-const access = useAccessPreviewStore()
-const rows = ref<DispatchListItem[]>([])
-const selectedDispatches = ref<DispatchListItem[]>([]), prepareOpen = ref(false), prepareWarehouse = ref(''), prepareWarehouseName = ref(''), prepareNumbers = ref<string[]>([])
-const canPrepare = computed(() => access.can('platform:fleet:trip:edit') && access.can('platform:fleet:trip:list'))
-function beginPreparation() {
-  const selected = selectedDispatches.value
-  if (!selected.length || selected.some(row => row.statusCode !== 'PENDING_DEPARTURE' || row.workflow)) { ElMessage.warning('请选择尚未关联车次的待发运排车单'); return }
-  const warehouses = new Set(selected.map(row => dispatchSnapshots.get(row.dispatchNo)?.overseasWarehouseId))
-  if (warehouses.size !== 1 || ![...warehouses][0]) { ElMessage.warning('请选择同一起运仓的排车单'); return }
-  prepareWarehouse.value = String([...warehouses][0]); prepareWarehouseName.value = selected[0]!.overseasWarehouse
-  prepareNumbers.value = selected.map(row => row.dispatchNo); prepareOpen.value = true
-}
-const loading = ref(false)
-const loadError = ref<ApiErrorDetails | null>(null)
+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 page = ref(1)
 const pageSize = ref(10)
 const total = ref(0)
-const stage = ref<'' | 'BEFORE_LOADING' | 'LOADING' | 'AFTER_LOADING' | 'CANCELLED'>('')
-const stages = [
-  { value: '', label: '全部' }, { value: 'BEFORE_LOADING', label: '装车前' },
-  { value: 'LOADING', label: '装车中' }, { value: 'AFTER_LOADING', label: '装车后' },
-  { value: 'CANCELLED', label: '已取消' },
-] as const
-const section = ref<'vehicle' | 'dispatchReview' | 'loadingReview'>('vehicle')
-const sections = [
-  { value: 'vehicle', label: '车辆信息' },
-  { value: 'dispatchReview', label: '调度审核' },
-  { value: 'loadingReview', label: '理货员审核' },
-] as const
-const visibleSections = computed(() => stage.value === 'BEFORE_LOADING' ? sections : sections.filter(item => item.value === 'vehicle'))
-const reviewLabels = { PENDING: '待审核', APPROVED: '已通过', REJECTED: '已打回' }
-let loadSequence = 0
-function switchStage(value: typeof stage.value) {
-  if (stage.value === value) return
-  stage.value = value
-  if (value !== 'BEFORE_LOADING') section.value = 'vehicle'
-  filters.value.status = ''
-  page.value = 1
-  void load()
-}
-function openTrip(row: DispatchListItem, tab: 'overview' | 'loading') {
-  if (!row.workflow || !access.can('platform:fleet:trip:list')) return
-  void router.push({ name: 'overseas-master-data-trip-detail', params: { tripNo: row.workflow.tripNo }, query: { tab, ...appointmentReturnQuery(route.query) } })
-}
-const filters = ref<QueryModel>({
-  dispatchNo: typeof route.query.dispatchNo === 'string' ? route.query.dispatchNo : '',
-  vehiclePlate: '',
-  status: '',
-  fbaAppointmentNo: '',
-})
-const transferOpen = ref(false)
-const transferRow = ref<DispatchListItem | null>(null)
-const transferSaving = ref(false)
-const transferIdempotencyKey = ref('')
-const externalFreight = ref<ExternalFreightPreview | null>(null)
-const coveragePreview = ref<FeeCoveragePreview | null>(null)
-const coverageSelection = ref<FeeCoverageSelection[]>([])
-const coveredServices = computed(() => fullyCoveredServices(coveragePreview.value, coverageSelection.value, externalFreight.value?.quotes.map(row => row.incomingNo) || []))
-const requiresDeliveryFee = computed(() => !!externalFreight.value?.requiresDeliveryFee && !coveredServices.value.includes('DELIVERY_FEE'))
-const requiresLoadingFee = computed(() => needsLoadingFee.value && !coveredServices.value.includes('LOADING_FEE'))
-const requiresAppointmentFee = computed(() => isBuyAppointment.value && !coveredServices.value.includes('APPOINTMENT_FEE'))
-const freightLoading = ref(false)
-let freightGeneration = 0
-const mutationError = ref<ApiErrorDetails | null>(null)
-const editOpen = ref(false)
-const editRow = ref<DispatchListItem | null>(null)
-const editSaving = ref(false)
-const editItems = ref<DispatchItemDto[]>([])
-const removingItemId = ref('')
-const bolLoadingNo = ref('')
-const dispatchSnapshots = new Map<string, DispatchSummaryDto>()
-const editForm = reactive({
-  vehiclePlate: '',
-  driverName: '',
-  driverPhone: '',
-  carrierName: '',
-  route: '',
-  departAt: '',
-  fbaAppointmentNo: '',
-  fbaAppointmentStatus: '',
-  vehicleAppointmentStatus: '',
-  estimatedArrivalAt: '',
-})
-const transferForm = reactive({
-  plannedDeliveryAt: '',
-  deliveryMethod: '',
-  waybillNo: '',
-  carrierName: '',
-  pickupMethod: '',
-  loadingType: '',
-  vehicleType: '',
-  vehicleSize: '',
-  driverName: '',
-  driverPhone: '',
-  vehiclePlate: '',
-  appointmentAccount: '',
-  sellerName: '',
-  deliveryFee: undefined as number | undefined,
-  loadingFee: undefined as number | undefined,
-  appointmentFee: undefined as number | undefined,
-  remark: '',
-})
-
-const deliveryMethodOptions = [
-  { label: 'FBA自提', value: 'FBA_PICKUP' },
-  { label: '客户自提', value: 'CUSTOMER_PICKUP' },
-  { label: '卡派打托', value: 'TRUCK_PALLET' },
-  { label: '卡派地板', value: 'TRUCK_FLOOR' },
-  { label: '快递', value: 'EXPRESS' },
-  { label: '外配', value: 'OUTSOURCED' },
-  { label: '专车直送', value: 'DEDICATED_TRUCK' },
-  { label: '零担派送', value: 'LTL' },
-]
-const pickupMethodOptions = [
-  { label: '一提一卸', value: 'ONE_PICKUP_ONE_DROP' },
-  { label: '一提多卸', value: 'ONE_PICKUP_MULTI_DROP' },
-  { label: '多提一卸', value: 'MULTI_PICKUP_ONE_DROP' },
-  { label: '多提多卸', value: 'MULTI_PICKUP_MULTI_DROP' },
-  { label: '仓库自提', value: 'WAREHOUSE_PICKUP' },
-]
-const loadingTypeOptions = [
-  { label: '托盘', value: 'PALLET' },
-  { label: '地板', value: 'FLOOR' },
-  { label: '混装', value: 'MIXED' },
-]
-const vehicleTypeOptions = ['厢式货车', '平板车', '冷藏车', '集装箱卡车', '尾板车'].map((label) => ({ label, value: label }))
-const vehicleSizeOptions = dispatchVehicleSizeOptions
-const appointmentAccountOptions = [
-  { label: '4号账号（美西）', value: '4' },
-  { label: '8号账号（美东）', value: '8' },
-  { label: '10号账号（美中）', value: '10' },
-  { label: '12号账号（加拿大）', value: '12' },
-  { label: '买约', value: 'BUY_APPOINTMENT' },
-]
-const isBuyAppointment = computed(() => transferForm.appointmentAccount === 'BUY_APPOINTMENT')
-const needsLoadingFee = computed(() => ['FLOOR', 'MIXED'].includes(transferForm.loadingType))
-
-const statusOptions = [
-  { label: '待发车', value: 'PENDING_DEPARTURE' },
-  { label: '拣货中', value: 'PICKING' },
-  { label: '待发车（拣货完成）', value: 'READY_TO_DEPART' },
-  { label: '待发车（部分完成）', value: 'PARTIAL_READY_TO_DEPART' },
-  { label: '已发车', value: 'DEPARTED' },
-  { label: '已发车（部分完成）', value: 'PARTIAL_DEPARTED' },
-  { label: '已取消', value: 'CANCELLED' },
-]
-
+const stage = ref<DispatchStage>('BEFORE_LOADING'), section = ref<BeforeLoadingSection>('VEHICLE_INFO')
+const model = ref<QueryModel>({ dispatchNo: String(route.query.dispatchNo || ''), vehiclePlate: '', status: 'ACTIVE', reviewStatus: '' })
+const operation = ref<'ROUTE' | undefined>()
+const action = ref<DispatchAction>('EDIT'), actionNo = ref(''), actionOpen = ref(false), createOpen = ref(false), bolLoadingNo = ref('')
+const routeOpen = ref(false), routeOrigin = ref<RouteLocation>(routeLocation('')), routeDestinations = ref<RouteLocation[]>([])
+const sections: Array<{ value: BeforeLoadingSection; label: string }> = [{ value: 'VEHICLE_INFO', label: '车辆信息' }, { value: 'DISPATCH_REVIEW', label: '调度审核' }, { value: 'LOADING_REVIEW', label: '理货员审核' }]
+const showSections = computed(() => stage.value === 'BEFORE_LOADING' && model.value.status === 'ACTIVE')
 const fields = computed<QueryField[]>(() => [
-  {
-    key: 'dispatchNo',
-    type: 'input',
-    label: '排车单号',
-    placeholder: '请输入排车单号',
-    width: 220,
-  },
-  {
-    key: 'vehiclePlate',
-    type: 'input',
-    label: '车牌号',
-    placeholder: '请输入车牌号',
-    width: 180,
-  },
-  {
-    key: 'status',
-    type: 'select',
-    label: '车辆状态',
-    placeholder: '全部状态',
-    options: statusOptions,
-    width: 180,
-  },
-  {
-    key: 'fbaAppointmentNo',
-    type: 'input',
-    label: 'FBA预约号',
-    placeholder: '请输入FBA预约号',
-    width: 220,
-  },
+  { key: 'dispatchNo', label: '排车单号', type: 'input', width: 180, placeholder: '请输入排车单号' },
+  { key: 'vehiclePlate', label: '车牌号', type: 'input', width: 150, placeholder: '请输入车牌号' },
+  { key: 'status', label: '单据范围', type: 'select', width: 140, options: [{ value: 'ACTIVE', label: '有效排车' }, { value: 'CANCELLED', label: '已取消' }, { value: 'ALL', label: '全部单据' }] },
+  ...(showSections.value && section.value !== 'VEHICLE_INFO' ? [{ key: 'reviewStatus', label: '审核结果', type: 'select' as const, width: 140, options: Object.entries(reviewLabels).map(([value, label]) => ({ value, label })) }] : []),
 ])
-
-const columns: DataTableColumn[] = [
+const columns = computed<DataTableColumn[]>(() => [
   { key: 'actions', label: '操作', width: 260, fixed: 'left', slotName: 'actions' },
-  { key: 'dispatchNo', prop: 'dispatchNo', label: '排车单号', minWidth: 220, fixed: 'left', singleLine: false },
-  { key: 'workflow', label: '关联车次', minWidth: 230, slotName: 'workflow', singleLine: false },
-  { key: 'dispatchReview', label: '调度审核', minWidth: 180, slotName: 'dispatchReview', singleLine: false },
-  { key: 'loadingReview', label: '理货审核（整车）', minWidth: 180, slotName: 'loadingReview', singleLine: false },
-  { key: 'vehiclePlate', prop: 'vehiclePlate', label: '车牌号', minWidth: 150, singleLine: false },
-  { key: 'driverName', prop: 'driverName', label: '司机', minWidth: 150, singleLine: false },
-  { key: 'driverPhone', prop: 'driverPhone', label: '联系电话', minWidth: 140 },
-  {
-    key: 'carrierName',
-    prop: 'carrierName',
-    label: '托车公司名称',
-    minWidth: 160,
-  },
-  { key: 'orderNos', prop: 'orderNos', label: '关联订单', minWidth: 260, singleLine: false },
-  { key: 'route', prop: 'route', label: '路线', minWidth: 180 },
-  {
-    key: 'overseasWarehouse',
-    prop: 'overseasWarehouse',
-    label: '海外仓',
-    minWidth: 160,
-  },
-  { key: 'departAt', prop: 'departAt', label: '发车时间', minWidth: 170 },
-  {
-    key: 'fbaAppointment',
-    prop: 'fbaAppointment',
-    label: 'FBA预约',
-    minWidth: 180,
-  },
-  {
-    key: 'vehicleAppointment',
-    prop: 'vehicleAppointment',
-    label: '车辆预约',
-    minWidth: 130,
-  },
-  {
-    key: 'estimatedArrivalAt',
-    prop: 'estimatedArrivalAt',
-    label: '预计到达时间',
-    minWidth: 170,
-  },
-  {
-    key: 'palletCount',
-    prop: 'palletCount',
-    label: '托盘数',
-    width: 90,
-    align: 'right',
-  },
-  {
-    key: 'packageCount',
-    prop: 'packageCount',
-    label: '箱数',
-    width: 80,
-    align: 'right',
-  },
-  {
-    key: 'status',
-    prop: 'status',
-    label: '车辆状态',
-    width: 150,
-    slotName: 'status',
-  },
-  { key: 'createdAt', prop: 'createdAt', label: '创建时间', minWidth: 170 },
-]
-
-const visibleColumns = computed(() => {
-  if (section.value === 'vehicle') {
-    const visible = columns.filter(column => !['dispatchReview', 'loadingReview'].includes(String(column.key)))
-    if (stage.value === 'AFTER_LOADING') visible.splice(visible.findIndex(column => column.key === 'status'), 0,
-      { key: 'routeMap', label: '路线地图', width: 120, slotName: 'routeMap' })
-    return visible
-  }
-  const keys = ['actions', 'dispatchNo', 'workflow', section.value, 'vehiclePlate', 'driverName', 'route', 'palletCount', 'packageCount', 'status']
-  return keys.map(key => columns.find(column => column.key === key)!)
-})
-const preparationColumns = computed<DataTableColumn[]>(() => canPrepare.value ? [visibleColumns.value[0]!, { key: 'selection', type: 'selection', width: 45, selectable: (row: DispatchListItem) => row.statusCode === 'PENDING_DEPARTURE' && !row.workflow }, ...visibleColumns.value.slice(1)] : visibleColumns.value)
-const tablePreferenceKey = computed(() => section.value === 'vehicle' ? 'overseas-dispatches' : `overseas-dispatches-${section.value}`)
-
-function text(value: unknown) {
-  const normalized = String(value ?? '').trim()
-  return normalized || '—'
-}
-
-function number(value: unknown) {
-  const normalized = Number(value)
-  return Number.isFinite(normalized) ? normalized : 0
-}
-
-function statusLabel(value: unknown) {
-  const status = String(value || '')
-  return statusOptions.find((option) => option.value === status)?.label || text(value)
-}
-
-function appointmentStatusLabel(value: unknown) {
-  const code = String(value || '')
-  const labels: Record<string, string> = {
-    PENDING: '待预约',
-    BOOKED: '已预约',
-    CONFIRMED: '已确认',
-    CANCELLED: '已取消',
-  }
-  return labels[code] || text(value)
-}
-
-function appointmentLabel(numberValue: unknown, statusValue: unknown) {
-  const appointmentNo = text(numberValue)
-  const appointmentStatus = appointmentStatusLabel(statusValue)
-  if (appointmentNo === '—') return appointmentStatus
-  return appointmentStatus === '—' ? appointmentNo : `${appointmentNo} · ${appointmentStatus}`
-}
-
-function toListItem(dto: DispatchSummaryDto): DispatchListItem {
-  return {
-    actions: dto.actions,
-    workflow: dto.workflow,
-    id: String(dto.id),
-    dispatchNo: text(dto.dispatchNo),
-    vehiclePlate: text(dto.vehiclePlate),
-    driverName: text(dto.driverName),
-    driverPhone: text(dto.driverPhone),
-    carrierName: text(dto.carrierName),
-    orderNos: text(dto.orderNos),
-    route: text(dto.route),
-    overseasWarehouse: text(dto.overseasWarehouseName || '仓库名称待补充'),
-    departAt: formatOverseasDateTime(dto.departAt),
-    fbaAppointment: appointmentLabel(dto.fbaAppointmentNo, dto.fbaAppointmentStatus),
-    vehicleAppointment: appointmentStatusLabel(dto.vehicleAppointmentStatus),
-    estimatedArrivalAt: formatOverseasDateTime(dto.estimatedArrivalAt),
-    status: statusLabel(dto.status),
-    statusCode: String(dto.status || ''),
-    palletCount: number(dto.palletCount),
-    packageCount: number(dto.packageCount),
-    createdAt: formatOverseasDateTime(dto.createdAt),
-  }
-}
-
-function dispatchError(error: unknown) {
-  const details = getApiErrorDetails(error, '排车列表加载失败，请重试')
-  return details.code === 'HTTP_404'
-    ? {
-        ...details,
-        message: '排车接口未启用或不存在，请确认海外尾程排车接口已发布',
-      }
-    : details
-}
-
-async function load(model: QueryModel = filters.value) {
-  const sequence = ++loadSequence
-  Object.assign(filters.value, model)
-  loading.value = true
-  loadError.value = null
+  { key: 'dispatchNo', prop: 'dispatchNo', label: '排车单号', minWidth: 190 },
+  { key: 'vehicle', label: '车牌号', minWidth: 130, slotName: 'vehicle' }, { key: 'driver', label: '司机／联系电话', minWidth: 170, slotName: 'driver' },
+  { key: 'warehouseName', prop: 'warehouseName', label: '起运仓', minWidth: 160 },
+  ...(showSections.value && section.value !== 'VEHICLE_INFO' ? [{ key: 'review', label: section.value === 'DISPATCH_REVIEW' ? '调度审核' : '理货员审核', minWidth: 210, slotName: 'review' }] : []),
+  { key: 'counts', label: '托数／箱数／已拣', minWidth: 160, slotName: 'counts' }, { key: 'planned', label: '计划发车', minWidth: 165, slotName: 'planned' },
+  { key: 'departure', label: '实际发车', minWidth: 165, slotName: 'departure' }, { key: 'stage', label: '作业阶段', minWidth: 110, slotName: 'stage' },
+  ...(stage.value === 'AFTER_LOADING' ? [{ key: 'routeMap', label: '路线', width: 100, slotName: 'routeMap' }] : []),
+])
+const preferenceKey = computed(() => `overseas-dispatches-${stage.value}-${section.value}`)
+let sequence = 0
+async function load() {
+  const current = ++sequence
+  loading.value = true; loadError.value = null
   try {
-    const result = await listDispatches({
-      page: page.value,
-      size: pageSize.value,
-      stage: stage.value || undefined,
-      dispatchNo: String(filters.value.dispatchNo || '').trim() || undefined,
-      vehiclePlate: String(filters.value.vehiclePlate || '').trim() || undefined,
-      status: String(filters.value.status || '').trim() || undefined,
-      fbaAppointmentNo: String(filters.value.fbaAppointmentNo || '').trim() || undefined,
-    })
-    if (sequence !== loadSequence) return
-    dispatchSnapshots.clear()
-    result.records.forEach((item) => dispatchSnapshots.set(String(item.dispatchNo), item))
-    rows.value = result.records.map(toListItem)
-    total.value = result.total
-  } catch (error) {
-    if (sequence !== loadSequence) return
-    rows.value = []
-    total.value = 0
-    loadError.value = dispatchError(error)
-  } finally {
-    if (sequence === loadSequence) loading.value = false
-  }
+    const result = await listDispatches({ page: page.value, size: pageSize.value, stage: stage.value, status: String(model.value.status || 'ACTIVE') as DispatchStatus | 'ALL', dispatchNo: String(model.value.dispatchNo || '').trim() || undefined, vehiclePlate: String(model.value.vehiclePlate || '').trim() || undefined,
+      ...(showSections.value ? { beforeLoadingSection: section.value, ...(section.value !== 'VEHICLE_INFO' && model.value.reviewStatus ? { reviewStatus: String(model.value.reviewStatus) as ReviewStatus } : {}) } : {}) })
+    if (current !== sequence) return
+    rows.value = result.records; total.value = result.total; statistics.value = result.statistics
+  } catch (cause) { if (current === sequence) { rows.value = []; total.value = 0; statistics.value = null; loadError.value = getApiErrorDetails(cause, '排车列表加载失败，请重试') } }
+  finally { if (current === sequence) loading.value = false }
 }
-
-function search(model: QueryModel) {
-  page.value = 1
-  void load(model)
+function search(value: QueryModel) { model.value = value; page.value = 1; void load() }
+function switchStage(value: DispatchStage) { stage.value = value; section.value = 'VEHICLE_INFO'; model.value.reviewStatus = ''; page.value = 1; void load() }
+function switchSection(value: BeforeLoadingSection) { section.value = value; model.value.reviewStatus = ''; page.value = 1; void load() }
+function openDetail(row: DispatchListRow) { void router.push({ name: 'overseas-dispatch-detail', params: { dispatchNo: row.dispatchNo } }) }
+const rowActionOrder: DispatchAction[] = ['EDIT', 'ADD_CARGO', 'REMOVE_CARGO', 'SUBMIT_REVIEW', 'DISPATCH_REVIEW', 'LOADING_REVIEW', 'RETURN_TO_REVIEW', 'LOADING_COMPLETE', 'ARRANGE_DELIVERY', 'DEPART', 'CANCEL']
+function rowActions(row: DispatchListRow): RowActionItem[] {
+  return [{ key: 'detail', label: '详情', priority: 500 }, ...rowActionOrder.filter(value => canDispatchAction(row.actions, value, access.can)).map((value, index) => ({ key: value, label: dispatchActionLabels[value], priority: 400 - index * 10, tone: value === 'CANCEL' ? 'danger' as const : undefined })), ...(canDispatchAction(row.actions, 'EDIT', access.can) ? [{ key: 'route-order', label: '调整卸货顺序', priority: 190 }] : []), { key: 'bol', label: '下载BOL', priority: 100, loading: bolLoadingNo.value === row.dispatchNo }]
 }
-function reset(model: QueryModel) {
-  page.value = 1
-  void load(model)
+function handleAction(value: string, row: DispatchListRow) {
+  if (value === 'detail') return openDetail(row)
+  if (value === 'bol') return void openBol(row)
+  if (value === 'route-order') { if (!canDispatchAction(row.actions, 'EDIT', access.can)) return; operation.value = 'ROUTE'; action.value = 'EDIT'; actionNo.value = row.dispatchNo; actionOpen.value = true; return }
+  operation.value = undefined
+  const requested = value as DispatchAction
+  if (!canDispatchAction(row.actions, requested, access.can)) return
+  action.value = requested; actionNo.value = row.dispatchNo; actionOpen.value = true
 }
-function openDetail(row: DispatchListItem) {
-  void router.push({
-    name: 'overseas-dispatch-detail',
-    params: { dispatchNo: row.dispatchNo },
-  })
+function recoverPending() {
+  const command = recovery.pending.value
+  if (!command) return
+  if (command.action === 'CREATE') { createOpen.value = true; return }
+  operation.value = command.operation; action.value = command.action; actionNo.value = command.dispatchNo; actionOpen.value = true
 }
-async function openBol(row: DispatchListItem) {
+async function openBol(row: DispatchListRow) {
   if (bolLoadingNo.value) return
-  const pdfWindow = window.open('', '_blank')
-  if (!pdfWindow) { ElMessage.warning('浏览器拦截了 BOL PDF 窗口，请允许本站打开新窗口'); return }
+  const windowHandle = window.open('', '_blank')
+  if (!windowHandle) { ElMessage.warning('请允许本站打开BOL预览窗口'); return }
   bolLoadingNo.value = row.dispatchNo
-  mutationError.value = null
-  try {
-    const pdf = await getDispatchBolPdf(row.dispatchNo)
-    const url = URL.createObjectURL(pdf)
-    pdfWindow.location.href = url
-    window.setTimeout(() => URL.revokeObjectURL(url), 60_000)
-  } catch (cause) {
-    pdfWindow.close()
-    mutationError.value = getApiErrorDetails(cause, 'BOL PDF 生成失败，请重试')
-  } finally {
-    bolLoadingNo.value = ''
-  }
+  try { const pdf = await getDispatchBolPdf(row.dispatchNo); const url = URL.createObjectURL(pdf); windowHandle.location.href = url; window.setTimeout(() => URL.revokeObjectURL(url), 60_000) }
+  catch (cause) { windowHandle.close(); mutationError.value = getApiErrorDetails(cause, 'BOL读取失败') }
+  finally { bolLoadingNo.value = '' }
 }
-function canEdit(row: DispatchListItem) {
-  return access.can(permission.dispatchEdit) && row.actions?.canEdit === true
+async function openRoute(row: DispatchListRow) {
+  try { const data = await getDispatch(row.dispatchNo); if (data.dispatchNo !== row.dispatchNo) throw new Error('路线排车号不一致'); routeOrigin.value = { kind: 'warehouse', label: row.warehouseName, warehouseId: row.warehouseId }; routeDestinations.value = [...new Set(data.orderDetails.map(item => item.destinationFbaWarehouse).filter((code): code is string => Boolean(code)))].map(code => ({ kind: 'warehouse', label: code, warehouseCode: code })); routeOpen.value = true }
+  catch (cause) { mutationError.value = getApiErrorDetails(cause, '运输路线读取失败') }
 }
-function canCancel(row: DispatchListItem) {
-  return access.can(permission.dispatchCancel) && row.actions?.canCancel === true
-}
-function canTransfer(row: DispatchListItem) {
-  return access.can(permission.dispatchTransferDelivery) && row.actions?.canTransfer === true
-}
-function canRemovePallet(row: DispatchListItem) {
-  return access.can(permission.dispatchEdit) && row.actions?.canRemovePallet === true
-}
-function actionBlockReasons(row: DispatchListItem) {
-  const actions = row.actions
-  if (!actions) return ['操作资格暂未返回，请刷新列表']
-  return [...new Set([actions.editBlockReason, actions.cancelBlockReason, actions.removePalletBlockReason, actions.transferBlockReason].filter(Boolean))]
-}
-function openOutbound(row: DispatchListItem) {
-  if (!row.actions?.outboundNo || !access.can(permission.outboundList)) return
-  void router.push({ name: 'overseas-outbounds', query: { documentNo: row.actions.outboundNo } })
-}
-function openEdit(row: DispatchListItem) {
-  if (!canEdit(row)) return
-  const source = dispatchSnapshots.get(row.dispatchNo)
-  editRow.value = row
-  editItems.value = [...(source?.items || [])]
-  Object.assign(editForm, {
-    vehiclePlate: source?.vehiclePlate || '',
-    driverName: source?.driverName || '',
-    driverPhone: source?.driverPhone || '',
-    carrierName: source?.carrierName || '',
-    route: source?.route || '',
-    departAt: source?.departAt || '',
-    fbaAppointmentNo: source?.fbaAppointmentNo || '',
-    fbaAppointmentStatus: source?.fbaAppointmentStatus || '',
-    vehicleAppointmentStatus: source?.vehicleAppointmentStatus || '',
-    estimatedArrivalAt: source?.estimatedArrivalAt || '',
-  })
-  mutationError.value = null
-  editOpen.value = true
-}
-async function openTransfer(row: DispatchListItem) {
-  if (!canTransfer(row)) return
-  transferRow.value = row
-  transferIdempotencyKey.value = `web-transfer-${row.dispatchNo}-${globalThis.crypto?.randomUUID?.() || `${Date.now()}-${Math.random().toString(16).slice(2)}`}`
-  Object.assign(transferForm, {
-    plannedDeliveryAt: '',
-    deliveryMethod: '',
-    waybillNo: '',
-    carrierName: row.carrierName === '—' ? '' : row.carrierName,
-    pickupMethod: '',
-    loadingType: '',
-    vehicleType: '',
-    vehicleSize: '',
-    driverName: row.driverName === '—' ? '' : row.driverName,
-    driverPhone: row.driverPhone === '—' ? '' : row.driverPhone,
-    vehiclePlate: row.vehiclePlate === '—' ? '' : row.vehiclePlate,
-    appointmentAccount: '',
-    sellerName: '',
-    deliveryFee: undefined,
-    loadingFee: undefined,
-    appointmentFee: undefined,
-    remark: '',
-  })
-  mutationError.value = null
-  transferOpen.value = true
-  externalFreight.value = null
-  coveragePreview.value = null
-  coverageSelection.value = []
-  freightLoading.value = true
-  const generation = ++freightGeneration
-  try {
-    const [preview, coverage] = await Promise.all([getDispatchExternalFreight(row.dispatchNo), getDispatchFeeCoverage(row.dispatchNo)])
-    if (generation === freightGeneration && transferOpen.value) { externalFreight.value = preview; coveragePreview.value = coverage }
-  } catch (cause) {
-    if (generation === freightGeneration && transferOpen.value) mutationError.value = getApiErrorDetails(cause, '约定运费读取失败，请重新打开转派送')
-  } finally {
-    if (generation === freightGeneration) freightLoading.value = false
-  }
-}
-async function submitEdit() {
-  if (!editRow.value || !canEdit(editRow.value) || editSaving.value) return
-  editSaving.value = true
-  mutationError.value = null
-  try {
-    await updateDispatch(editRow.value.dispatchNo, {
-      vehiclePlate: editForm.vehiclePlate.trim() || null,
-      driverName: editForm.driverName.trim() || null,
-      driverPhone: editForm.driverPhone.trim() || null,
-      carrierName: editForm.carrierName.trim() || null,
-      departAt: editForm.departAt || null,
-      fbaAppointmentNo: editForm.fbaAppointmentNo.trim() || null,
-      fbaAppointmentStatus: editForm.fbaAppointmentStatus || null,
-      vehicleAppointmentStatus: editForm.vehicleAppointmentStatus || null,
-      estimatedArrivalAt: editForm.estimatedArrivalAt || null,
-    })
-    editOpen.value = false
-    ElMessage.success('排车信息已保存')
-    await load()
-  } catch (cause) {
-    mutationError.value = getApiErrorDetails(cause, '排车信息保存失败，请重试')
-  } finally {
-    editSaving.value = false
-  }
-}
-async function removePallet(itemValue: unknown) {
-  const item = itemValue as DispatchItemDto
-  if (!editRow.value || !canRemovePallet(editRow.value) || removingItemId.value) return
-  try {
-    await ElMessageBox.confirm(`确认从排车单移除托盘 ${text(item.palletNo)}？移除后可重新排车。`, '移除排车托盘', { customClass: 'admin-density-confirm',
-      confirmButtonText: '确认移除',
-      cancelButtonText: '返回',
-      type: 'warning',
-    })
-  } catch {
-    return
-  }
-  removingItemId.value = String(item.id)
-  mutationError.value = null
-  try {
-    const updated = await removeDispatchItem(editRow.value.dispatchNo, String(item.id))
-    editItems.value = [...(updated.items || [])]
-    editForm.route = updated.route || ''
-    dispatchSnapshots.set(editRow.value.dispatchNo, updated)
-    const row = rows.value.find((value) => value.dispatchNo === editRow.value?.dispatchNo)
-    if (row) {
-      Object.assign(row, toListItem(updated))
-      editRow.value = row
-    }
-    ElMessage.success('托盘已移除，可重新排车')
-  } catch (cause) {
-    mutationError.value = getApiErrorDetails(cause, '托盘移除失败，请重试')
-  } finally {
-    removingItemId.value = ''
-  }
-}
-async function cancel(row: DispatchListItem) {
-  if (!canCancel(row)) return
-  try {
-    await ElMessageBox.confirm(`确认取消排车单 ${row.dispatchNo}？取消后将释放托盘锁。`, '取消排车', { customClass: 'admin-density-confirm',
-      confirmButtonText: '确认取消',
-      cancelButtonText: '返回',
-      type: 'warning',
-    })
-  } catch {
-    return
-  }
-  mutationError.value = null
-  try {
-    await cancelDispatch(row.dispatchNo)
-    ElMessage.success('排车单已取消并释放占用，可从入仓单或换标单重新预排')
-    await load()
-  } catch (cause) {
-    mutationError.value = getApiErrorDetails(cause, '排车取消失败，请重试')
-  }
-}
-function rowActions(row: DispatchListItem): RowActionItem[] {
-  if (section.value !== 'vehicle') {
-    const reviewPermission = section.value === 'dispatchReview' ? 'platform:fleet:trip:dispatch-review' : 'platform:fleet:trip:loading-review'
-    return [
-      { key: 'review', label: access.can(reviewPermission) ? '前往审核' : '查看审核', priority: 400, visible: !!row.workflow && access.can('platform:fleet:trip:list') },
-      { key: 'detail', label: '查看', priority: 300 },
-    ]
-  }
-  return [
-    { key: 'detail', label: '查看', priority: 300 },
-    { key: 'bol', label: '打印BOL', priority: 200, loading: bolLoadingNo.value === row.dispatchNo },
-    { key: 'trip', label: '处理原车次', priority: 150, visible: !!row.workflow && access.can('platform:fleet:trip:list') },
-    { key: 'outbound', label: '查看原出库', priority: 150, visible: !!row.actions?.outboundNo && access.can(permission.outboundList) },
-    { key: 'edit', label: '编辑', priority: 100, visible: canEdit(row) },
-    { key: 'transfer', label: '转派送', priority: 250, tone: 'success', visible: canTransfer(row) },
-    { key: 'cancel', label: '取消', tone: 'danger', divided: true, visible: canCancel(row) },
-  ]
-}
-function handleRowAction(command: string, row: DispatchListItem) {
-  if (command === 'review') openTrip(row, section.value === 'dispatchReview' ? 'overview' : 'loading')
-  else if (command === 'detail') openDetail(row)
-  else if (command === 'bol') void openBol(row)
-  else if (command === 'trip') openTrip(row, 'overview')
-  else if (command === 'outbound') openOutbound(row)
-  else if (command === 'edit') openEdit(row)
-  else if (command === 'transfer') openTransfer(row)
-  else if (command === 'cancel') void cancel(row)
-}
-async function submitTransfer() {
-  if (!transferRow.value || !canTransfer(transferRow.value)) return
-  if (transferSaving.value || freightLoading.value || !externalFreight.value) return
-  if (!transferForm.plannedDeliveryAt || !transferForm.deliveryMethod || !transferForm.pickupMethod || !transferForm.loadingType) {
-    ElMessage.warning('请填写预计派送时间、派送方式、提货方式和装车类型')
-    return
-  }
-  if (requiresDeliveryFee.value && transferForm.deliveryFee == null) {
-    ElMessage.warning('请填写派送费用')
-    return
-  }
-  if (requiresLoadingFee.value && transferForm.loadingFee == null) {
-    ElMessage.warning('当前装车类型需要填写装车费')
-    return
-  }
-  if (isBuyAppointment.value && (!transferForm.sellerName.trim() || requiresAppointmentFee.value && transferForm.appointmentFee == null)) {
-    ElMessage.warning('买约时请填写卖家姓名和买约费用')
-    return
-  }
-  const feeInputs = [
-    ['DELIVERY_FEE', requiresDeliveryFee.value ? transferForm.deliveryFee : undefined, '派送费用'],
-    ['LOADING_FEE', requiresLoadingFee.value ? transferForm.loadingFee : undefined, '装车费'],
-    ['APPOINTMENT_FEE', requiresAppointmentFee.value ? transferForm.appointmentFee : undefined, '买约费用'],
-  ] as const
-  const fees = feeInputs
-    .filter(([, amount]) => amount != null)
-    .map(([feeType, amount, feeName]) => ({
-      feeType,
-      feeName,
-      direction: 'RECEIVABLE' as const,
-      currency: 'USD' as const,
-      amount: Number(amount),
-      remark: feeName,
-    }))
-  transferSaving.value = true
-  try {
-    const result = await transferDispatchToDelivery(transferRow.value.dispatchNo, {
-      idempotencyKey: transferIdempotencyKey.value,
-      plannedDeliveryAt: transferForm.plannedDeliveryAt,
-      deliveryMethod: transferForm.deliveryMethod,
-      waybillNo: transferForm.waybillNo.trim() || undefined,
-      carrierName: transferForm.carrierName.trim() || undefined,
-      pickupMethod: transferForm.pickupMethod,
-      loadingType: transferForm.loadingType,
-      vehicleType: transferForm.vehicleType || undefined,
-      vehicleSize: transferForm.vehicleSize || undefined,
-      driverName: transferForm.driverName.trim() || undefined,
-      driverPhone: transferForm.driverPhone.trim() || undefined,
-      vehiclePlate: transferForm.vehiclePlate.trim() || undefined,
-      appointmentAccount: transferForm.appointmentAccount || undefined,
-      sellerName: isBuyAppointment.value ? transferForm.sellerName.trim() : undefined,
-      remark: transferForm.remark.trim() || undefined,
-      fees,
-      externalFreightHash: externalFreight.value.snapshotHash,
-      feeCoverageCargoHash: coverageSelection.value.length ? coveragePreview.value?.cargoHash : undefined,
-      feeCoverage: coverageSelection.value,
-    })
-    transferOpen.value = false
-    if (result.outboundStatus === 'CANCELLED') {
-      ElMessage.warning(`原出库单 ${result.outboundNo} 已取消，本次未生成新单据；请取消原排车后重新预排`)
-    } else if (result.replayed) {
-      ElMessage.info(`已存在出库单 ${result.outboundNo} 及关联派送单，本次未重复生成`)
-    } else {
-      ElMessage.success('已生成出库单和派送单')
-    }
-    await load()
-  } catch (cause) {
-    mutationError.value = getApiErrorDetails(cause, '转派送失败，请重试')
-  } finally {
-    transferSaving.value = false
-  }
-}
-
 onMounted(load)
+onBeforeUnmount(() => { sequence++ })
 </script>
-
 <template>
   <AdminPage class="admin-density"><ListPageLayout aria-label="海外仓排车列表">
-    <OperationErrorToast :details="mutationError" /><TripPreparationDialog v-model="prepareOpen" :warehouse-id="prepareWarehouse" :warehouse-name="prepareWarehouseName" :dispatch-nos="prepareNumbers" @saved="load()" />
-    <DataTable v-model:page="page" v-model:page-size="pageSize" appearance="integrated" :stripe="false" :data="rows" :columns="preparationColumns" @selection-change="selectedDispatches = $event" :loading="loading" :total="total" :preference-key="tablePreferenceKey" row-key="id" 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><h1>排车列表</h1></template><template #toolbar-end><el-button v-if="canPrepare" type="primary" :disabled="!selectedDispatches.length" @click="beginPreparation">安排车次</el-button></template>
-      <template #filters><div class="integrated-query-group">
-        <div class="density-status-tabs" role="tablist" aria-label="排车执行阶段">
-          <button v-for="item in stages" :key="item.value" role="tab" :aria-selected="stage === item.value" :class="{ 'is-active': stage === item.value }" @click="switchStage(item.value)">{{ item.label }}</button>
-        </div>
-        <div class="density-status-tabs" role="tablist" aria-label="排车业务分区">
-          <button v-for="item in visibleSections" :key="item.value" role="tab" :aria-selected="section === item.value" :class="{ 'is-active': section === item.value }" @click="section = item.value">{{ item.label }}</button>
-        </div>
-        <QueryToolbar v-model="filters" :fields="fields" :loading="loading" ariaLabel="排车列表筛选" preference-key="overseas-dispatches-query" :search-on-reset="false" @search="search" @reset="reset" /></div></template>
+    <OperationErrorToast :details="mutationError" />
+    <p v-if="recovery.pending.value" role="status">{{ recovery.pending.value.dispatchNo || '新排车单' }} 的{{ dispatchActionLabels[recovery.pending.value.action] }}结果尚待核对。<el-button link :disabled="recovery.busy.value" @click="recoverPending">核对原请求</el-button></p>
+    <DataTable v-model:page="page" v-model:page-size="pageSize" appearance="integrated" :stripe="false" :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><h1>排车列表</h1></template>
+      <template #toolbar-end><el-button v-if="access.can(dispatchActionPermissions.CREATE)" type="primary" @click="createOpen = true">新建排车</el-button></template>
+      <template #filters><div class="integrated-query-group"><div class="density-status-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><div v-if="showSections" class="density-status-tabs" role="tablist" aria-label="装车前审核分区"><button v-for="item in sections" :key="item.value" role="tab" :aria-selected="section === item.value" :class="{ 'is-active': section === item.value }" @click="switchSection(item.value)">{{ item.label }}</button></div><QueryToolbar v-model="model" :fields="fields" :loading="loading" ariaLabel="排车列表筛选" preference-key="overseas-dispatches-query" :search-on-reset="false" @search="search" @reset="search" /></div></template>
       <template v-if="loadError" #state><LoadErrorState title="排车列表加载失败" :message="loadError.message" :loading="loading" @retry="load"><template #details><ApiErrorMeta :details="loadError" /></template></LoadErrorState></template>
-       <template #actions="{ row }"><RowActions text-actions :actions="rowActions(row as DispatchListItem)" :more-label="`更多操作 · ${(row as DispatchListItem).dispatchNo || '当前记录'}`" @action="handleRowAction($event, row as DispatchListItem)" /><p v-for="reason in actionBlockReasons(row as DispatchListItem)" :key="String(reason)">{{ reason }}</p></template>
-      <template #workflow="{ row }">
-        <el-button v-if="row.workflow && access.can('platform:fleet:trip:list')" link type="primary" @click="openTrip(row as DispatchListItem, 'overview')">{{ row.workflow.tripNo }}</el-button>
-        <span v-else>{{ row.workflow?.tripNo || '未关联车次' }}</span>
-      </template>
-      <template v-for="review in (['dispatchReview', 'loadingReview'] as const)" :key="review" #[review]="{ row }">
-        <template v-if="(row as DispatchListItem).workflow">
-          <div>{{ reviewLabels[(row as DispatchListItem).workflow![review].status] }}</div>
-          <div v-if="row.workflow[review].status === 'REJECTED'">{{ row.workflow[review].reason || '—' }}</div>
-          <div v-if="row.workflow[review].reviewedAt">{{ formatOverseasDateTime(row.workflow[review].reviewedAt) }}</div>
-        </template>
-        <span v-else>未关联车次</span>
-      </template>
-      <template #status="{ row }"><StatusBadge :status="String((row as DispatchListItem).status || '—')" /></template>
-      <template #routeMap="{ row }"><el-button v-if="row.dispatchNo" link type="primary" @click="openRoute(row as DispatchListItem)">查看路线</el-button></template>
-      <template #pagination-left>共 {{ total }} 条排车记录</template>
+      <template #actions="{ row }"><RowActions text-actions :actions="rowActions(row as DispatchListRow)" :more-label="`更多操作 · ${row.dispatchNo}`" @action="handleAction($event, row as DispatchListRow)" /><p v-if="!row.actions">操作资格未返回，请刷新核对</p></template>
+      <template #vehicle="{ row }">{{ row.resources.vehicle?.plate || '—' }}</template><template #driver="{ row }">{{ row.resources.driver?.name || '—' }}<br>{{ row.resources.driver?.phone || '—' }}</template>
+      <template #review="{ row }"><template v-for="review in [section === 'DISPATCH_REVIEW' ? row.reviews.dispatchReview : row.reviews.loadingReview]" :key="review.reviewRound"><div>{{ reviewLabels[review.status as ReviewStatus] }}</div><div v-if="review.reason">{{ review.reason }}</div><div v-if="review.invalidatedReason">{{ review.invalidatedReason }}</div><div>{{ time(review.reviewedAt) }}</div></template></template>
+      <template #counts="{ row }">{{ row.counts.palletCount }}托／{{ row.counts.packageCount }}箱／已拣{{ row.counts.pickedPackageCount }}箱</template><template #planned="{ row }">{{ time(row.plannedDepartureAt) }}</template><template #departure="{ row }">{{ time(row.departedAt) }}</template><template #stage="{ row }">{{ row.status === 'CANCELLED' ? '已取消' : stageLabel(row.stage) }}</template><template #routeMap="{ row }"><el-button link @click="openRoute(row as DispatchListRow)">查看路线</el-button></template>
     </DataTable>
-    <TransportRouteDialog v-model="routeOpen" :origin="routeOrigin" :destinations="routeDestinations" />
-  </ListPageLayout></AdminPage><AppDialog class="admin-density-dialog" v-model="transferOpen" title="转派送" width="min(1120px, calc(100vw - 28px))" confirm-text="确认提交" :confirm-loading="transferSaving" :confirm-disabled="freightLoading || !externalFreight" @confirm="submitTransfer"><el-form class="density-form" label-position="top"><h3>派送信息</h3><div class="transfer-grid"><el-form-item label="排车单号"><el-input :model-value="transferRow?.dispatchNo" readonly /></el-form-item><el-form-item label="预计派送时间" required><el-date-picker v-model="transferForm.plannedDeliveryAt" type="datetime" value-format="YYYY-MM-DDTHH:mm:ss" placeholder="请选择预计派送时间" /></el-form-item><el-form-item label="派送方式" required><el-select v-model="transferForm.deliveryMethod" placeholder="请选择"><el-option v-for="option in deliveryMethodOptions" :key="option.value" v-bind="option" /></el-select></el-form-item><el-form-item label="快递/车队"><el-input v-model="transferForm.carrierName" placeholder="请输入快递或车队名称" /></el-form-item><el-form-item label="运单号"><el-input v-model="transferForm.waybillNo" placeholder="请输入运单号" /></el-form-item><el-form-item label="提货方式" required><el-select v-model="transferForm.pickupMethod" placeholder="请选择"><el-option v-for="option in pickupMethodOptions" :key="option.value" v-bind="option" /></el-select></el-form-item><el-form-item label="装车类型" required><el-select v-model="transferForm.loadingType" placeholder="请选择"><el-option v-for="option in loadingTypeOptions" :key="option.value" v-bind="option" /></el-select></el-form-item><el-form-item label="司机/车队名称"><el-input v-model="transferForm.driverName" placeholder="请输入司机或车队名称" /></el-form-item><el-form-item label="联系电话"><el-input v-model="transferForm.driverPhone" placeholder="请输入联系电话" /></el-form-item><el-form-item label="车牌号"><el-input v-model="transferForm.vehiclePlate" placeholder="请输入车牌号" /></el-form-item><el-form-item label="车辆类型"><el-select v-model="transferForm.vehicleType" clearable placeholder="请选择"><el-option v-for="option in vehicleTypeOptions" :key="option.value" v-bind="option" /></el-select></el-form-item><el-form-item label="车辆大小"><el-select v-model="transferForm.vehicleSize" clearable placeholder="请选择"><el-option v-for="option in vehicleSizeOptions" :key="option.value" v-bind="option" /></el-select></el-form-item><el-form-item label="预约账号"><el-select v-model="transferForm.appointmentAccount" clearable placeholder="请选择"><el-option v-for="option in appointmentAccountOptions" :key="option.value" v-bind="option" /></el-select></el-form-item><el-form-item v-if="isBuyAppointment" label="卖家姓名" required><el-input v-model="transferForm.sellerName" placeholder="请输入卖家姓名" /></el-form-item></div><DeliveryFeeCoveragePanel v-model="coverageSelection" :preview="coveragePreview" :loading="freightLoading" :disabled="transferSaving || freightLoading" /><p v-if="coveredServices.length">本次全部货物已覆盖：{{ coveredServices.map(service => coveredServiceLabels[service]).join('、') }}，无需重复登记对应应收。</p><h3>本次新增费用</h3><p v-if="freightLoading">正在读取约定运费…</p><p v-for="quote in externalFreight?.quotes || []" :key="quote.bookingNo">{{ quote.bookingNo }} · {{ quote.incomingNo }}：{{ quote.quantity }} {{ quote.quantityUnit }} × {{ quote.currency }} {{ quote.unitPrice }} = {{ quote.currency }} {{ quote.amount }}（外接约定运费）</p><div class="transfer-grid"><el-form-item v-if="requiresDeliveryFee" :label="externalFreight?.quotes.length || coverageSelection.length ? '派送费（未覆盖部分，USD）' : '派送费用（USD）'" required><el-input-number v-model="transferForm.deliveryFee" :min="0" :precision="2" controls-position="right" placeholder="请输入派送费用" /></el-form-item><el-form-item v-if="requiresLoadingFee" label="装车费（USD）" required><el-input-number v-model="transferForm.loadingFee" :min="0" :precision="2" controls-position="right" placeholder="请输入装车费" /></el-form-item><el-form-item v-if="requiresAppointmentFee" label="买约费用（USD）" required><el-input-number v-model="transferForm.appointmentFee" :min="0" :precision="2" controls-position="right" placeholder="请输入买约费用" /></el-form-item></div><el-form-item label="备注"><el-input v-model="transferForm.remark" type="textarea" :rows="3" placeholder="请输入派送备注（选填）" /></el-form-item><el-alert title="原运费仅按上方确认的服务范围引用；外接运费按实收约定带入。下方只登记未覆盖货物或服务的新增应收。" type="info" :closable="false" /></el-form></AppDialog>
-  <AppDialog class="admin-density-dialog" v-model="editOpen" title="编辑排车" width="min(900px, calc(100vw - 48px))" confirm-text="保存" :confirm-loading="editSaving" @confirm="submitEdit"><el-alert :title="`当前状态：${editRow?.status || '—'}；普通编辑不会修改排车状态；托盘移除资格以当前服务端校验结果为准。`" type="info" :closable="false" /><el-form class="density-form" label-position="top"><div class="edit-grid"><el-form-item label="车牌号"><el-input v-model="editForm.vehiclePlate" placeholder="请输入车牌号" /></el-form-item><el-form-item label="司机"><el-input v-model="editForm.driverName" placeholder="请输入司机姓名" /></el-form-item><el-form-item label="联系电话"><el-input v-model="editForm.driverPhone" placeholder="请输入联系电话" /></el-form-item><el-form-item label="拖车公司名称"><el-input v-model="editForm.carrierName" placeholder="请输入拖车公司名称" /></el-form-item><el-form-item label="路线"><el-input v-model="editForm.route" readonly placeholder="按已排托盘自动汇总 FBA 仓" /></el-form-item><el-form-item label="发车时间"><el-date-picker v-model="editForm.departAt" type="datetime" value-format="YYYY-MM-DDTHH:mm:ss" /></el-form-item><el-form-item label="预计到达时间"><el-date-picker v-model="editForm.estimatedArrivalAt" type="datetime" value-format="YYYY-MM-DDTHH:mm:ss" /></el-form-item><el-form-item label="FBA预约号"><el-input v-model="editForm.fbaAppointmentNo" placeholder="请输入 FBA 预约号" /></el-form-item><el-form-item label="FBA预约状态"><el-select v-model="editForm.fbaAppointmentStatus" clearable><el-option label="待预约" value="PENDING" /><el-option label="已预约" value="BOOKED" /><el-option label="已确认" value="CONFIRMED" /><el-option label="已取消" value="CANCELLED" /></el-select></el-form-item><el-form-item label="车辆预约状态"><el-select v-model="editForm.vehicleAppointmentStatus" clearable><el-option label="待预约" value="PENDING" /><el-option label="已预约" value="BOOKED" /><el-option label="已确认" value="CONFIRMED" /><el-option label="已取消" value="CANCELLED" /></el-select></el-form-item></div></el-form><p v-if="editRow?.actions?.removePalletBlockReason">{{ editRow.actions.removePalletBlockReason }}</p><h3>已排车托盘</h3><el-table :data="editItems" border max-height="280" empty-text="暂无托盘"><el-table-column label="操作" width="90" fixed="left"><template #default="{ row }"><el-button class="density-action" data-tone="danger" :loading="removingItemId === String(row.id)" :disabled="Boolean(removingItemId) || !editRow || !canRemovePallet(editRow)" @click="removePallet(row)">移除</el-button></template></el-table-column><el-table-column prop="palletNo" label="托盘号" min-width="160" /><el-table-column prop="orderNo" label="订单号" min-width="160" /><el-table-column prop="inboundCode" label="入仓码" min-width="140" /><el-table-column prop="packageCount" label="箱数" width="80" align="right" /></el-table></AppDialog>
+  </ListPageLayout></AdminPage>
+  <SmartDispatchDialog v-model="createOpen" :orders="[]" @created="load" />
+  <DispatchWorkflowDialog v-model="actionOpen" :dispatch-no="actionNo" :action="action" :operation="operation" @saved="load" />
+  <TransportRouteDialog v-model="routeOpen" :origin="routeOrigin" :destinations="routeDestinations" />
 </template>
-<style scoped>
-.transfer-grid,
-.edit-grid {
-  display: grid;
-  grid-template-columns: repeat(3, minmax(0, 1fr));
-  gap: 0 var(--admin-space-5);
-}
-.transfer-grid :deep(.el-select),
-.transfer-grid :deep(.el-date-editor),
-.transfer-grid :deep(.el-input-number),
-.edit-grid :deep(.el-select),
-.edit-grid :deep(.el-date-editor) {
-  width: 100%;
-}
-h3 {
-  margin: var(--admin-space-1) 0 var(--admin-space-5);
-}
-@media (max-width: 900px) {
-  .transfer-grid,
-  .edit-grid {
-    grid-template-columns: 1fr;
-  }
-}
-</style>

src/modules/overseas-warehouse/pages/InboundOrdersView.dispatch.test.ts

@@ -0,0 +1,53 @@
+import { flushPromises, mount } from '@vue/test-utils'
+import { beforeEach, expect, it, vi } from 'vitest'
+import InboundOrdersView from './InboundOrdersView.vue'
+import { overseasWarehousePermissions as permission } from '../permissions'
+
+const access = vi.hoisted(() => ({ codes: [] as string[] }))
+vi.mock('@/core/access/accessPreview', () => ({ useAccessPreviewStore: () => ({ can: (code: string) => access.codes.includes(code) }) }))
+vi.mock('vue-router', () => ({ useRouter: () => ({ push: vi.fn() }), onBeforeRouteLeave: vi.fn(), onBeforeRouteUpdate: vi.fn() }))
+vi.mock('../api/inboundOrders', () => ({ listInboundOrders: vi.fn().mockResolvedValue({ records: [], total: 0 }), createFbaAppointment: vi.fn(), getFbaAppointment: vi.fn(), updateFbaAppointment: vi.fn(), updateInboundPlan: vi.fn() }))
+vi.mock('../components/SmartDispatchDialog.vue', () => ({ default: { name: 'SmartDispatchDialog', props: ['modelValue', 'orders'], template: '<section v-if="modelValue" data-dispatch-dialog />' } }))
+vi.mock('element-plus', () => ({ ElMessage: { warning: vi.fn(), success: vi.fn() } }))
+
+function render() {
+  return mount(InboundOrdersView, { global: { directives: { loading: {} }, stubs: {
+    AdminPage: { template: '<main><slot /></main>' }, ListPageLayout: { template: '<div><slot /></div>' },
+    DataTable: { template: '<div><slot name="toolbar-actions" /></div>' },
+    ElButton: { template: '<button><slot /></button>' },
+    AppDialog: true, FbaAppointmentFields: true, QueryToolbar: true, OperationErrorToast: true,
+  } } })
+}
+
+beforeEach(() => { vi.clearAllMocks(); access.codes = [permission.inboundOrderList] })
+
+it('opens the existing smart-dispatch flow with dispatch list/create and no legacy smart permission or selected rows', async () => {
+  access.codes.push(permission.dispatchList, permission.dispatchCreate)
+  const wrapper = render()
+  try {
+    await flushPromises()
+    const button = wrapper.findAll('button').find(button => button.text() === '智能排车')!
+    expect(button.exists()).toBe(true)
+    await button.trigger('click')
+    expect(wrapper.find('[data-dispatch-dialog]').exists()).toBe(true)
+    expect(wrapper.getComponent({ name: 'SmartDispatchDialog' }).props('orders')).toEqual([])
+  } finally { wrapper.unmount() }
+})
+
+it.each([
+  ['list only', [permission.dispatchList]],
+  ['create only', [permission.dispatchCreate]],
+  ['legacy smart only', ['platform:overseas-warehouse:inbound-order:smart-dispatch']],
+  ['list plus legacy smart', [permission.dispatchList, 'platform:overseas-warehouse:inbound-order:smart-dispatch']],
+])('blocks the button and direct handler for %s', async (_, codes) => {
+  access.codes.push(...codes)
+  const wrapper = render()
+  try {
+    await flushPromises()
+    expect(wrapper.findAll('button').some(button => button.text() === '智能排车')).toBe(false)
+    const state = wrapper.vm as unknown as { openSmartDispatch(): void }
+    state.openSmartDispatch()
+    await flushPromises()
+    expect(wrapper.find('[data-dispatch-dialog]').exists()).toBe(false)
+  } finally { wrapper.unmount() }
+})

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

@@ -24,6 +24,7 @@ import { formatOverseasDateTime, inboundPlanStatusLabel, lastMileOrderTypeLabel
 import type { InboundOrderListItem } from '../types'
 
 const access = useAccessPreviewStore()
+const canCreateDispatch = computed(() => access.can(permission.dispatchList) && access.can(permission.dispatchCreate))
 const router = useRouter()
 const rows = ref<InboundOrderListItem[]>([])
 const selectedRows = ref<InboundOrderListItem[]>([])
@@ -145,6 +146,7 @@ function openAppointment() {
 }
 
 function openSmartDispatch() {
+  if (!canCreateDispatch.value) return
   smartDispatchOpen.value = true
 }
 
@@ -234,7 +236,7 @@ onMounted(() => { void load() })
         <template #notices><template v-if="loadError"><LoadErrorState title="入库单加载失败" :message="loadError.message" :loading="loading" @retry="load"><template #details><ApiErrorMeta :details="loadError" /></template></LoadErrorState></template></template>
 
 
-      <template #toolbar-actions><el-button v-if="access.can(permission.inboundOrderAppointment)" plain :disabled="!selectedRows.length" @click="openAppointment"><CalendarCheck2 :size="16" />预约</el-button><el-button v-if="access.can(permission.inboundOrderSmartDispatch)" type="primary" @click="openSmartDispatch"><Truck :size="16" />智能排车</el-button></template>
+      <template #toolbar-actions><el-button v-if="access.can(permission.inboundOrderAppointment)" plain :disabled="!selectedRows.length" @click="openAppointment"><CalendarCheck2 :size="16" />预约</el-button><el-button v-if="canCreateDispatch" type="primary" @click="openSmartDispatch"><Truck :size="16" />智能排车</el-button></template>
       <template #actions="{ row }"><div class="row-actions density-actions admin-text-actions"><el-button class="density-action" data-tone="neutral" size="small" @click="openDetail(row)">查看</el-button><el-button class="density-action" data-tone="neutral" v-if="access.can(permission.inboundOrderEdit) && ['待入库'].includes((row as InboundOrderListItem).status)" size="small" @click="openPlanEdit(row)">编辑</el-button><el-button class="density-action" data-tone="neutral" v-if="(row as InboundOrderListItem).appointmentStatus !== '多批预约' && (row as InboundOrderListItem).appointmentNo !== '—' && access.can(permission.inboundOrderList)" size="small" @click="openAppointmentEdit(row, true)">查看预约</el-button><el-button class="density-action" data-tone="neutral" v-if="(row as InboundOrderListItem).appointmentStatus !== '多批预约' && (row as InboundOrderListItem).appointmentNo !== '—' && access.can(permission.inboundOrderAppointment)" size="small" @click="openAppointmentEdit(row)">预约</el-button><el-button v-if="(row as InboundOrderListItem).appointmentStatus === '多批预约' && access.can('platform:appointment:list')" class="density-action" @click="openMultipleAppointments(row as InboundOrderListItem)">管理多批预约</el-button></div></template>
       <template #pagination-left>共 {{ total }} 条入库单 · 已选 {{ selectedRows.length }} 条</template>
     </DataTable></section>

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

@@ -50,9 +50,8 @@ async function exportLedger() { exportLoading.value = true; try { const range =
         <template #toolbar-start><h1>进销存记录</h1></template>
         <template #filters><QueryToolbar v-model="filters" :fields="fields" :loading="loading" ariaLabel="进销存记录筛选" preference-key="overseas-inventory-transactions-query" :search-on-reset="false" @search="search" @reset="reset" /></template>
         <template #notices><template v-if="loadError"><LoadErrorState title="进销存记录加载失败" :message="loadError.message" :loading="loading" @retry="load"><template #details><ApiErrorMeta :details="loadError" /></template></LoadErrorState></template>
-<template v-else><p class="read-only-boundary">本页面仅用于查询库存流水，不提供出库单跳转或库存变更操作。</p></template></template>
+</template>
 
 <template #toolbar-actions><el-button v-if="access.can(permission.inventoryExport) && access.can('platform:download:list')" plain :loading="exportLoading" @click="exportLedger"><Download :size="16" />导出记录</el-button><el-button class="density-back" link @click="back"><ArrowLeft :size="16" />返回库存管理</el-button></template><template #actions="{ row }"><div class="density-actions row-actions admin-text-actions"><el-button class="density-action" data-tone="neutral" :disabled="(row as InventoryTransactionListItem).inboundCode === '—'" @click="openRelationship(row as InventoryTransactionListItem)">关联数据</el-button></div></template><template #pagination-left>共 {{ total }} 条进销存记录</template></DataTable></section>
   <InboundCodeRelationshipDialog dense v-if="relationshipDialogOpen" v-model="relationshipDialogOpen" :inbound-code="relationshipDialogInboundCode" :can-read-base="access.can('platform:order:list')" :can-read-loading="access.can('platform:firstleg:smart-loading:list')" :can-read-overseas="access.can('platform:overseas-warehouse:inventory:list')" />
 </ListPageLayout></AdminPage></template>
-<style scoped>.read-only-boundary{margin:var(--admin-space-3) 2px 0;color:var(--cc-muted);font-size:var(--admin-font-caption);line-height:1.5}</style>

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

@@ -307,9 +307,9 @@ describe('LastMileOrdersView pending order and container conversion', () => {
 
   it.each([
     [[], ['查看'], false],
-    [['inbound-order:create'], ['查看', '生成入库计划'], false],
-    [['last-mile-order:edit'], ['查看', '人工修改节点'], false],
-    [['inbound-order:create', 'last-mile-order:edit'], ['查看', '生成入库计划', '人工修改节点'], false],
+    [['inbound-order:create'], ['查看', '入库'], false],
+    [['last-mile-order:edit'], ['查看', '修改节点'], false],
+    [['inbound-order:create', 'last-mile-order:edit'], ['查看', '入库', '修改节点'], false],
   ])('only collapses row actions above three for %j', async (allowed, labels, overflow) => {
     canAccess.mockImplementation(code => allowed.some(action => code === 'platform:overseas-warehouse:' + action))
     vi.mocked(listLastMileOrders).mockResolvedValue({ records: [{ id: 'order-1', customerId, orderNo: 'LM-1', currentStatus: 'PENDING_ASSIGNMENT', orderType: 'FIRST_LEG' }], page: 1, size: 10, total: 1, pages: 1 })
@@ -469,11 +469,11 @@ describe('LastMileOrdersView pending order and container conversion', () => {
     const wrapper = await mountView()
     const actions = wrapper.get('.el-table__body-wrapper .row-actions')
     expect(actions.text()).toContain('查看')
-    expect(actions.text()).not.toContain('生成入库计划')
+    expect(actions.text()).not.toContain('入库')
     expect(actions.text()).not.toContain('暂扣订单')
 
     await selectRows(wrapper, [(wrapper.findComponent(DataTable).props('data') as object[])[0]])
-    expect((button(wrapper, '生成入库计划')!.element as HTMLButtonElement).disabled).toBe(true)
+    expect((button(wrapper, '入库')!.element as HTMLButtonElement).disabled).toBe(true)
   })
 
   it('keeps the original pending order table and does not render a view switch or container table', async () => {
@@ -481,7 +481,7 @@ describe('LastMileOrdersView pending order and container conversion', () => {
     expect(wrapper.text()).toContain('尾程单号')
     expect(wrapper.text()).toContain('海外仓')
     expect(wrapper.text()).toContain('转仓')
-    expect(wrapper.text()).toContain('生成入库计划')
+    expect(wrapper.text()).toContain('入库')
     expect(wrapper.text()).toContain('按柜批量生成')
     expect(wrapper.text()).not.toContain('按订单')
     expect(wrapper.text()).not.toContain('待分配整柜')
@@ -545,7 +545,7 @@ describe('LastMileOrdersView pending order and container conversion', () => {
   it('opens the required single-order inbound-plan form without invoking the cabinet conversion', async () => {
     const wrapper = await openPending()
     await selectRows(wrapper, [selectedRow()])
-    await button(wrapper, '生成入库计划')!.trigger('click')
+    await button(wrapper, '入库')!.trigger('click')
     await flushPromises()
     expect(document.body.textContent).toContain('计划入库仓')
     expect(document.body.textContent).toContain('预计到仓时间')
@@ -572,7 +572,7 @@ describe('LastMileOrdersView pending order and container conversion', () => {
   it('shows cabinet-frozen facts but never sends arrival time or per-order warehouse overrides', async () => {
     const wrapper = await openPending()
     await selectRows(wrapper, [selectedRow()])
-    await button(wrapper, '生成入库计划')!.trigger('click')
+    await button(wrapper, '入库')!.trigger('click')
     await flushPromises()
     const confirm = [...document.body.querySelectorAll('button')]
       .find((item) => item.textContent?.includes('保存并生成入库单')) as HTMLButtonElement
@@ -598,7 +598,7 @@ describe('LastMileOrdersView pending order and container conversion', () => {
       orderTypeCode: 'ONE_CLICK_DROPSHIP',
       currentStatusCode: 'PENDING_ASSIGNMENT',
     })])
-    await button(wrapper, '生成入库计划')!.trigger('click')
+    await button(wrapper, '入库')!.trigger('click')
     await flushPromises()
 
     expect(getContainerInboundPlanPreview).not.toHaveBeenCalled()
@@ -610,7 +610,7 @@ describe('LastMileOrdersView pending order and container conversion', () => {
   it('blocks manual plan creation when the cabinet has no frozen expected arrival time', async () => {
     const wrapper = await openPending()
     await selectRows(wrapper, [selectedRow({ estimatedWarehouseAt: '', warehouseEta: '—' })])
-    await button(wrapper, '生成入库计划')!.trigger('click')
+    await button(wrapper, '入库')!.trigger('click')
     await flushPromises()
 
     const confirm = [...document.body.querySelectorAll('button')]
@@ -634,7 +634,7 @@ describe('LastMileOrdersView pending order and container conversion', () => {
     } as never)
     const wrapper = await openPending()
     await selectRows(wrapper, [selectedRow({ orderTypeCode: 'ONE_CLICK_DROPSHIP', pallets: 2 })])
-    await button(wrapper, '生成入库计划')!.trigger('click')
+    await button(wrapper, '入库')!.trigger('click')
     await flushPromises()
 
     const palletInput = wrapper.find('.command-form').findComponent({ name: 'ElInputNumber' })
@@ -944,7 +944,7 @@ describe('LastMileOrdersView pending order and container conversion', () => {
   it('starts cabinet plan generation directly from the workbench card', async () => {
     const wrapper = await mountView()
     await openHiddenContainerWorkbench(wrapper)
-    await button(wrapper, '生成入库计划')!.trigger('click')
+    await button(wrapper, '入库')!.trigger('click')
     await flushPromises()
     expect(document.body.textContent).toContain('头程已有 4 个托盘码，海外仓补充 1 个，最终生成 5 个托盘')
     expect(document.body.textContent).toContain('头程已有 4 托 / 海外仓补充 1 托')
@@ -974,7 +974,7 @@ describe('LastMileOrdersView pending order and container conversion', () => {
     await openHiddenContainerWorkbench(wrapper)
 
     expect(wrapper.text()).toContain('柜内接柜仓业务快照不一致')
-    expect((button(wrapper, '生成入库计划')!.element as HTMLButtonElement).disabled).toBe(true)
+    expect((button(wrapper, '入库')!.element as HTMLButtonElement).disabled).toBe(true)
     await wrapper.get('.container-workbench-card__detail').trigger('click')
     await flushPromises()
     expect(getContainerPlanProgress).toHaveBeenCalledWith(bookingId)
@@ -1183,7 +1183,7 @@ describe('LastMileOrdersView pending order and container conversion', () => {
     const wrapper = await mountView()
     await selectRows(wrapper, [selectedRow({ orderTypeCode: 'RETURN_RELABEL', currentStatusCode: 'INBOUND_COMPLETED', sourceOrderNo: 'RETURN-1' })])
     const actions = wrapper.get('.data-table__business-actions')
-    expect(actions.text()).not.toContain('生成入库计划')
+    expect(actions.text()).not.toContain('入库')
     const packing = actions.findAll('button').find(action => action.text().includes('创建退货合箱计划（1）'))!
     await packing.trigger('click')
     await flushPromises()

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

@@ -1000,9 +1000,9 @@ function lastMileRowActions(row: LastMileOrderListItem): RowActionItem[] {
     { key: 'review-direct-relabel', label: '审核', priority: 470, tone: 'warning', visible: access.can(permission.lastMileOrderTransfer) && row.orderTypeCode === 'RELABEL_APPLICATION' && row.currentStatusCode === 'PENDING_REVIEW' },
     { key: 'review-return', label: '审核', priority: 460, tone: 'warning', visible: access.can(permission.returnOrderReview) && row.orderTypeCode === 'RETURN_RELABEL' && row.currentStatusCode === 'PENDING_REVIEW' },
     { key: 'review', label: '审核', priority: 450, tone: 'warning', visible: access.can(permission.warehouseTransferApprove) && row.orderTypeCode === 'WAREHOUSE_TRANSFER' && row.currentStatusCode === 'PENDING_REVIEW' },
-    { key: 'inbound-plan', label: '生成入库计划', priority: 400, visible: access.can(permission.inboundOrderCreate) && canGenerateInboundPlan(row) && !inboundPlanCreated },
+    { key: 'inbound-plan', label: '入库', priority: 400, visible: access.can(permission.inboundOrderCreate) && canGenerateInboundPlan(row) && !inboundPlanCreated },
     { key: 'hold', label: row.detained ? '解除暂扣' : '暂扣订单', priority: 300, tone: 'warning', visible: access.can(permission.lastMileOrderTransfer) && (row.detained || row.currentStatusCode === 'INBOUND_COMPLETED') },
-    { key: 'manual-nodes', label: '人工修改节点', priority: 200, visible: access.can(permission.lastMileOrderTransfer) },
+    { key: 'manual-nodes', label: '修改节点', priority: 200, visible: access.can(permission.lastMileOrderTransfer) },
     { key: 'confirm-relabel', label: '换标完成确认', priority: 150, visible: access.can(permission.relabelOrderStatus) && Boolean(row.relabelOrderNo) && canConfirmRelabel(row) },
     { key: 'rework-relabel', label: '换标退回重做', priority: 100, tone: 'danger', divided: true, visible: access.can(permission.relabelOrderStatus) && canReworkRelabel(row) },
   ]
@@ -1124,7 +1124,7 @@ onMounted(() => { void load() })
             <el-tooltip :content="receivingWarehouseChangeDisabledReason(container)" :disabled="!receivingWarehouseChangeDisabledReason(container)" placement="top">
               <span><el-button plain :title="receivingWarehouseChangeDisabledReason(container) || '修改接柜仓'" :disabled="Boolean(receivingWarehouseChangeDisabledReason(container))" @click="openReceivingWarehouseChange(container)"><Pencil :size="15" />修改接柜仓</el-button></span>
             </el-tooltip>
-            <el-button v-if="access.can(permission.inboundOrderCreate)" type="primary" :disabled="actionLoading || !canGenerateContainerPlans(container)" @click="openContainerConversionFor(container)">{{ container.resourcePendingPlanCount && !container.pendingPlanCount ? '重试生成托盘码' : '生成入库计划' }}</el-button>
+            <el-button v-if="access.can(permission.inboundOrderCreate)" type="primary" :disabled="actionLoading || !canGenerateContainerPlans(container)" @click="openContainerConversionFor(container)">{{ container.resourcePendingPlanCount && !container.pendingPlanCount ? '重试生成托盘码' : '入库' }}</el-button>
           </span>
         </article>
       </div>
@@ -1135,7 +1135,7 @@ onMounted(() => { void load() })
       </div>
     </section></template>
 
-      <template v-if="statusTab !== '柜子'" #toolbar-actions><el-button v-if="access.can(permission.lastMileOrderPalletMerge)" plain :disabled="!palletMergeSelectionEditable || actionLoading" @click="submitPalletMerge(true)">合托</el-button><el-button v-if="access.can(permission.lastMileOrderPalletMerge)" plain :disabled="!canCancelPalletMerge || actionLoading" @click="submitPalletMerge(false)">取消合托</el-button><el-button v-if="selectedReturnRows.length" type="warning" @click="openReturnPackingPlan"><PackagePlus :size="16" />创建退货合箱计划（{{ selectedReturnRows.length }}）</el-button><el-button v-if="access.can(permission.lastMileOrderExport) && access.can('platform:download:list')" plain :loading="exportLoading" @click="exportOrders"><Download :size="16" />导出订单</el-button><el-button v-if="access.can(permission.lastMileOrderTransfer)" plain :disabled="!selectedRows.length || hasSelectedRejectedReturn() || actionLoading" @click="openTransfer">转仓</el-button><el-button v-if="access.can(permission.inboundOrderCreate) && selectedRows.length === 1 && canGenerateInboundPlan(selectedRows[0])" type="primary" plain :disabled="hasSelectedInboundPlan() || actionLoading" @click="openInboundPlan()">生成入库计划</el-button><el-button v-if="access.can(permission.inboundOrderCreate)" type="primary" :disabled="actionLoading" @click="openContainerConversion">按柜批量生成</el-button></template>
+      <template v-if="statusTab !== '柜子'" #toolbar-actions><el-button v-if="access.can(permission.lastMileOrderPalletMerge)" plain :disabled="!palletMergeSelectionEditable || actionLoading" @click="submitPalletMerge(true)">合托</el-button><el-button v-if="access.can(permission.lastMileOrderPalletMerge)" plain :disabled="!canCancelPalletMerge || actionLoading" @click="submitPalletMerge(false)">取消合托</el-button><el-button v-if="selectedReturnRows.length" type="warning" @click="openReturnPackingPlan"><PackagePlus :size="16" />创建退货合箱计划（{{ selectedReturnRows.length }}）</el-button><el-button v-if="access.can(permission.lastMileOrderExport) && access.can('platform:download:list')" plain :loading="exportLoading" @click="exportOrders"><Download :size="16" />导出订单</el-button><el-button v-if="access.can(permission.lastMileOrderTransfer)" plain :disabled="!selectedRows.length || hasSelectedRejectedReturn() || actionLoading" @click="openTransfer">转仓</el-button><el-button v-if="access.can(permission.inboundOrderCreate) && selectedRows.length === 1 && canGenerateInboundPlan(selectedRows[0])" type="primary" plain :disabled="hasSelectedInboundPlan() || actionLoading" @click="openInboundPlan()">入库</el-button><el-button v-if="access.can(permission.inboundOrderCreate)" type="primary" :disabled="actionLoading" @click="openContainerConversion">按柜批量生成</el-button></template>
       <template #relabelOrderNo="{ row }"><div v-for="application in row.relabelApplications" :key="application.relabelNo" class="relabel-suborder">{{ application.relabelNo }}</div><span v-if="!row.relabelApplications?.length">{{ row.relabelOrderNo }}</span></template>
       <template #relabelStatus="{ row }"><div v-for="application in row.relabelApplications" :key="application.relabelNo" class="relabel-suborder">{{ application.statusLabel }}</div><span v-if="!row.relabelApplications?.length">{{ row.relabelStatus }}</span></template>
       <template #actions="{ row }"><RowActions text-actions :actions="lastMileRowActions(row as LastMileOrderListItem)" :more-label="`更多尾程订单操作 · ${(row as LastMileOrderListItem).orderNo || '当前记录'}`" @action="handleLastMileRowAction($event, row as LastMileOrderListItem)" /></template>
@@ -1277,7 +1277,7 @@ onMounted(() => { void load() })
     <el-alert :title="holdForm.held ? '暂扣后不可创建出库计划；解除暂扣后恢复出库计划操作。' : '解除暂扣后恢复该订单的出库计划操作。'" type="warning" :closable="false" show-icon />
     <el-form class="command-form density-form" label-position="top"><div class="command-form__grid"><el-form-item label="暂扣状态" required><el-radio-group v-model="holdForm.held"><el-radio :value="true">暂扣</el-radio><el-radio :value="false">解除暂扣</el-radio></el-radio-group></el-form-item><el-form-item label="是否计费" required><el-radio-group v-model="holdForm.chargeable"><el-radio :value="true">是</el-radio><el-radio :value="false">否</el-radio></el-radio-group></el-form-item></div><el-form-item label="变更原因" required><el-input v-model="holdForm.reason" type="textarea" :rows="4" maxlength="500" show-word-limit placeholder="请输入暂扣或解除暂扣原因" /></el-form-item></el-form>
   </AppDialog>
-  <AppDialog class="admin-density-dialog" v-model="manualNodesOpen" title="人工修改节点" width="min(700px, calc(100vw - 28px))" confirm-text="保存" :loading="manualNodesLoading" :confirm-loading="actionLoading" @confirm="submitManualNodes">
+  <AppDialog class="admin-density-dialog" v-model="manualNodesOpen" title="修改节点" width="min(700px, calc(100vw - 28px))" confirm-text="保存" :loading="manualNodesLoading" :confirm-loading="actionLoading" @confirm="submitManualNodes">
     <div class="manual-node-order"><span>尾程单号</span><strong>{{ actionTarget?.orderNo || '—' }}</strong></div>
     <el-alert title="保存后该订单只显示人工节点，不再跟随柜级节点；请至少填写一个节点时间。" type="warning" :closable="false" show-icon />
     <div class="manual-node-table"><div class="manual-node-table__head"><span>节点</span><span>节点时间</span></div><div v-for="node in manualNodeDefinitions" :key="node.code" class="manual-node-table__row"><span>{{ node.label }}</span><el-date-picker v-model="manualNodeValues[node.code]" type="datetime" value-format="YYYY-MM-DDTHH:mm:ss" placeholder="年/月/日 --:--" /></div></div>

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

@@ -8,7 +8,7 @@ function source(fileName: string) {
 
 function columnKeys(fileName: string) {
   const value = source(fileName)
-  const start = value.indexOf('const columns: DataTableColumn[]')
+  const start = value.search(/const columns(?:: DataTableColumn\[\]| = computed<DataTableColumn\[\]>)/)
   const end = value.indexOf('\n]', start)
   return [...value.slice(start, end).matchAll(/\{ key: '([^']+)'/g)].map((match) => match[1])
 }
@@ -57,7 +57,7 @@ describe('overseas warehouse first-batch prototype contract', () => {
   it('keeps the operation column first on every business list', () => {
     for (const fileName of ['LastMileOrdersView.vue', 'InboundOrdersView.vue', 'DispatchesView.vue', 'InventoryView.vue', 'RelabelOrdersView.vue', 'PalletsView.vue', 'CartonsView.vue', 'ProductsView.vue']) {
       const value = source(fileName)
-      const columns = value.slice(value.indexOf('const columns: DataTableColumn[]'))
+      const columns = value.slice(value.search(/const columns(?:: DataTableColumn\[\]| = computed<DataTableColumn\[\]>)/))
       expect(columns.match(/\{\s*key: '([^']+)'/)?.[1]).toBe('actions')
     }
   })
@@ -220,7 +220,9 @@ describe('overseas warehouse first-batch prototype contract', () => {
     expect(value).toContain('type="primary" @click="openSmartDispatch"')
     expect(value).not.toContain('type="primary" :disabled="!selectedRows.length" @click="openSmartDispatch"')
     expect(value).toContain('access.can(permission.inboundOrderAppointment)')
-    expect(value).toContain('access.can(permission.inboundOrderSmartDispatch)')
+    expect(value).toContain('access.can(permission.dispatchList) && access.can(permission.dispatchCreate)')
+    expect(value).toContain('v-if="canCreateDispatch"')
+    expect(value).not.toContain('inboundOrderSmartDispatch')
     expect(value).toContain('<SmartDispatchDialog')
     expect(value).toContain("key: 'assigned', prop: 'assigned', label: '分配'")
     expect(value).toContain("key: 'mergeAllowed', prop: 'mergeAllowed', label: '合托'")
@@ -253,61 +255,19 @@ describe('overseas warehouse first-batch prototype contract', () => {
     }
   })
 
-  it('connects intelligent dispatch without a frontend customerId constraint', () => {
+  it('connects native same-warehouse multi-customer draft containers and independent resources', () => {
     const dialog = source('../components/SmartDispatchDialog.vue')
-    expect(dialog).toContain('listDispatchCandidates')
-    expect(dialog).toContain('preArrangeDispatch')
-    expect(dialog).toContain("planPalletIds: sources.filter(item => item.sourceType !== 'RETURN_RECEIPT')")
-    expect(dialog).toContain("returnReceiptIds: sources.filter(item => item.sourceType === 'RETURN_RECEIPT')")
-    expect(dialog).toContain('planPalletIds: assigned.value.map(palletId)')
-    expect(dialog).toContain("if (item.sourceStage === 'RELABEL') return String(item.warehousePalletId || '')")
-    expect(dialog).toContain('lockDispatchDraftPallet')
-    expect(dialog).toContain('unlockDispatchDraftPallet')
-    expect(dialog.match(/async function close\([\s\S]*?\n}/)?.[0]).not.toContain('releaseDispatchDraft')
-    expect(dialog).toContain('await releaseDispatchDraft(draftToken.value)')
-    expect(dialog).toContain('释放并重新选择')
-    expect(dialog).toContain('排车明细已同步到预排列表')
-    expect(dialog).toContain("router.push({ name: 'overseas-dispatches' })")
-    expect(dialog).not.toContain('customerId:')
-    expect(dialog).toContain("planIds: query.sourceStage !== 'RELABEL' && planIds.value.length ? planIds.value.join(',') : undefined")
-    expect(dialog).toContain('v-model="query.fbaWarehouseCode" clearable')
-    expect(dialog).toContain("订单号 / 换标单号 / 原入仓码")
-    expect(dialog).toContain('label="私人仓"')
-    expect(dialog).toContain('item.deliveryAddress, item.postalCode')
-    expect(dialog).not.toContain(':model-value="fbaWarehouseCode" readonly')
-    expect(dialog).toContain("sourceStage: 'RECEIVED'")
-    expect(dialog).toContain('一次排车只能装同一客户的托盘')
-    expect(dialog).toContain('该托盘尚未关联海外仓，不能排车')
-    expect(dialog).toContain('所选托盘中存在尚未关联海外仓的托盘')
-    expect(dialog).toContain('function ensureDraftToken()')
-    expect(dialog).toContain('lockDispatchDraftPallet(id, ensureDraftToken(), target.id)')
-    expect(dialog).toContain('function hydrateDraftPallets()')
-    expect(dialog).toContain('@click="removePallet(id)"')
-    expect(dialog).not.toContain('removePallet(candidates.find')
-    expect(dialog).toContain('洛杉矶')
-    expect(dialog).toContain('纽约')
-    expect(dialog).toContain("value: 'ALL', label: '全部'")
-    expect(dialog).toContain('换标下单')
-    expect(dialog).toContain('退货换标')
-    expect(dialog).toContain('本土散板')
-    expect(dialog).toContain('仓储转运')
-    expect(dialog).toContain('relabelCartonMarks(item)')
-    expect(dialog).toContain('type="warning">换标</el-tag>')
-    expect(dialog).not.toContain('function cartonMarks(')
-    expect(dialog).not.toContain('`normal-${mark}`')
-    expect(dialog).not.toContain('暂无箱唛')
-    expect(dialog).toContain('class="warehouse-tabs density-tabs"')
-    expect(dialog).toContain('dispatchVehicleSpecs')
+    for (const symbol of ['listDispatchCandidates', 'createDispatchDraft', 'lockDispatchDraftPallet', 'unlockDispatchDraftPallet', 'releaseDispatchDraft', 'convertDispatchDraft', 'requireVersion', 'draftContainerId', 'sourceVersion', 'result.complete !== true', 'validateCurrentDispatch', 'warehouse-tabs density-tabs', '洛杉矶', '纽约', '先建空单后加货', 'settings[containerId]']) expect(dialog).toContain(symbol)
+    expect(dialog).toContain('cargo: cargo.map(row => row.selection)')
+    expect(dialog).toContain('同仓可混装多个客户与目的仓')
+    expect(dialog).not.toContain('一次排车只能装同一客户')
+    expect(dialog).not.toContain('ensureDraftToken')
+    expect(dialog).not.toContain('preArrangeDispatch')
+    expect(dialog).toContain('原请求结果尚待核对')
+    expect(dialog).not.toContain('v-model="route"')
     const vehicleSpecs = source('../dispatchVehicleSpecs.ts')
     expect(vehicleSpecs).toContain("label: '大车（30托）'")
     expect(vehicleSpecs).toContain("label: '小车（15托）'")
-    expect(vehicleSpecs).not.toContain('14托')
-    expect(vehicleSpecs).not.toContain('12托')
-    expect(dialog).not.toContain('排车路线（选填）')
-    expect(dialog).not.toContain('v-model="route"')
-    const dispatches = source('DispatchesView.vue')
-    expect(dispatches).toContain('v-model="editForm.route" readonly')
-    expect(dispatches).not.toContain('route: editForm.route.trim()')
   })
 
   it('adds the prototype inventory transaction page as a read-only inventory route', () => {
@@ -318,7 +278,7 @@ describe('overseas warehouse first-batch prototype contract', () => {
     expect(transactions).toContain('业务订单号')
     expect(transactions).toContain('入库单号')
     expect(transactions).toContain('出库单号')
-    expect(transactions).toContain('不提供出库单跳转或库存变更操作')
+    expect(transactions).not.toContain('本页面仅用于查询库存流水')
     expect(transactions).not.toContain('当前流水 DTO')
     expect(transactions).toContain("router.push({ name: 'overseas-inventory' })")
     expect(transactions).not.toContain('保存')
@@ -349,9 +309,9 @@ describe('overseas warehouse first-batch prototype contract', () => {
       const value = source(fileName)
       expect(value).toContain(routeName)
       if (fileName === 'DispatchesView.vue') {
-        expect(value).toMatch(/<RowActions\b[^>]*:actions="rowActions\(row as DispatchListItem\)"/)
-        expect(value).toContain("{ key: 'detail', label: '查看', priority: 300 }")
-        expect(value).toContain("if (command === 'detail') openDetail(row)")
+        expect(value).toMatch(/<RowActions\b[^>]*:actions="rowActions\(row as DispatchListRow\)"/)
+        expect(value).toContain("{ key: 'detail', label: '详情', priority: 500 }")
+        expect(value).toContain("if (value === 'detail') return openDetail(row)")
       } else if (fileName === 'LastMileOrdersView.vue') {
         expect(value).toContain('<RowActions text-actions :actions="lastMileRowActions(row as LastMileOrderListItem)"')
         expect(value).toContain("{ key: 'detail', label: '查看', priority: 500 }")

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

@@ -79,6 +79,6 @@ describe('overseas warehouse mounted real API pages', () => {
     expect(wrapper.text()).toContain('详情缺少客户范围')
     expect(wrapper.text()).not.toContain('9007199254740995')
   })
-  it('mounts inventory ledger as localized read-only business facts without exposing internal ids', async () => { const wrapper = mount(InventoryTransactionsView, { global: { plugins: [createPinia(), ElementPlus] } }); await flushPromises(); expect(listInventoryLedger).toHaveBeenCalledWith(expect.objectContaining({ page: 1, size: 10 })); expect(listInventoryLedger).not.toHaveBeenCalledWith(expect.objectContaining({ customerId: expect.anything() })); expect(wrapper.text()).toContain('客户甲'); expect(wrapper.text()).toContain('NYEXX2608300001'); expect(wrapper.text()).not.toContain('10001'); expect(wrapper.text()).toContain('IP-1'); expect(wrapper.text()).toContain('10'); expect(wrapper.text()).toContain('入库'); expect(wrapper.text()).not.toContain('STOCK_IN'); expect(wrapper.text()).toContain('不提供出库单跳转'); expect(wrapper.text()).not.toContain('当前流水 DTO'); expect(wrapper.text()).not.toContain('操作人名称待补充') })
+  it('mounts inventory ledger as localized read-only business facts without exposing internal ids', async () => { const wrapper = mount(InventoryTransactionsView, { global: { plugins: [createPinia(), ElementPlus] } }); await flushPromises(); expect(listInventoryLedger).toHaveBeenCalledWith(expect.objectContaining({ page: 1, size: 10 })); expect(listInventoryLedger).not.toHaveBeenCalledWith(expect.objectContaining({ customerId: expect.anything() })); expect(wrapper.text()).toContain('客户甲'); expect(wrapper.text()).toContain('NYEXX2608300001'); expect(wrapper.text()).not.toContain('10001'); expect(wrapper.text()).toContain('IP-1'); expect(wrapper.text()).toContain('10'); expect(wrapper.text()).toContain('入库'); expect(wrapper.text()).not.toContain('STOCK_IN'); expect(wrapper.find('.read-only-boundary').exists()).toBe(false); expect(wrapper.text()).not.toContain('当前流水 DTO'); expect(wrapper.text()).not.toContain('操作人名称待补充') })
   it('renders complete business references with single-line ellipsis and titles', async () => { routing.route.params = { orderId: '9007199254740999' }; const wrapper = mount(LastMileOrderDetailView, { global: { plugins: [createPinia(), ElementPlus] } }); await flushPromises(); expect(getLastMileOrder).toHaveBeenCalledWith('9007199254740999'); expect(wrapper.text()).toContain('华远贸易'); expect(wrapper.text()).toContain('LMO-260827-0001'); expect(wrapper.text()).toContain('货柜节点'); expect(wrapper.text()).toContain('已清关、可提柜'); expect(wrapper.text()).not.toContain('清关状态'); expect(wrapper.get('.order-reference-text').attributes('title')).toBe('LMO-260827-0001'); const businessValues = wrapper.findAll('.detail-field-value--business'); expect(businessValues.map((item) => item.attributes('title'))).toEqual(expect.arrayContaining(['NYEXX2608280033', 'TSTU0000061'])); expect(businessValues.every((item) => item.text().length > 0)).toBe(true) })
 })

src/modules/overseas-warehouse/permissions.ts

@@ -9,10 +9,10 @@ export const overseasWarehousePermissions = {
   inboundOrderCreate: 'platform:overseas-warehouse:inbound-order:create',
   inboundOrderEdit: 'platform:overseas-warehouse:inbound-order:edit',
   inboundOrderAppointment: 'platform:overseas-warehouse:inbound-order:fba-appointment',
-  inboundOrderSmartDispatch: 'platform:overseas-warehouse:inbound-order:smart-dispatch',
   discardList: 'platform:overseas-warehouse:discard:list',
   discardApprove: 'platform:overseas-warehouse:discard:approve',
   dispatchList: 'platform:overseas-warehouse:dispatch:list',
+  dispatchCreate: 'platform:overseas-warehouse:dispatch:create',
   dispatchEdit: 'platform:overseas-warehouse:dispatch:edit',
   dispatchCancel: 'platform:overseas-warehouse:dispatch:cancel',
   dispatchTransferDelivery: 'platform:overseas-warehouse:dispatch:transfer-delivery',

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

@@ -3,8 +3,8 @@ import { matchesSmartDispatchWarehouseTab } from './smartDispatchWarehouseTab'
 
 describe('smart dispatch warehouse tabs', () => {
   it('uses the overseas warehouse code when the warehouse name is unavailable', () => {
-    const losAngeles = { overseasWarehouseCode: 'US-LAX-01', overseasWarehouseName: null }
-    const newYork = { overseasWarehouseCode: 'US-NY-01', overseasWarehouseName: null }
+    const losAngeles = { warehouseCode: 'US-LAX-01', warehouseName: '' }
+    const newYork = { warehouseCode: 'US-NY-01', warehouseName: '' }
 
     expect(matchesSmartDispatchWarehouseTab(losAngeles, 'LAX')).toBe(true)
     expect(matchesSmartDispatchWarehouseTab(losAngeles, 'NYC')).toBe(false)
@@ -13,7 +13,7 @@ describe('smart dispatch warehouse tabs', () => {
   })
 
   it('keeps the all tab unfiltered and supports warehouse names as a fallback', () => {
-    const warehouse = { overseasWarehouseCode: null, overseasWarehouseName: '洛杉矶接柜仓' }
+    const warehouse = { warehouseCode: '', warehouseName: '洛杉矶接柜仓' }
 
     expect(matchesSmartDispatchWarehouseTab(warehouse, 'ALL')).toBe(true)
     expect(matchesSmartDispatchWarehouseTab(warehouse, 'LAX')).toBe(true)

src/modules/overseas-warehouse/smartDispatchWarehouseTab.ts

@@ -1,13 +1,13 @@
-import type { DispatchPalletCandidateDto } from './api/dispatches'
+import type { Candidate } from './dispatchContracts'
 
 export type SmartDispatchWarehouseTab = 'ALL' | 'LAX' | 'NYC'
 
 export function matchesSmartDispatchWarehouseTab(
-  candidate: Pick<DispatchPalletCandidateDto, 'overseasWarehouseCode' | 'overseasWarehouseName'>,
+  candidate: Pick<Candidate, 'warehouseCode' | 'warehouseName'>,
   tab: SmartDispatchWarehouseTab,
 ) {
   if (tab === 'ALL') return true
-  const warehouse = [candidate.overseasWarehouseCode, candidate.overseasWarehouseName]
+  const warehouse = [candidate.warehouseCode, candidate.warehouseName]
     .map((value) => String(value || '').trim().toLowerCase())
     .filter(Boolean)
     .join(' ')

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

@@ -7,10 +7,13 @@ const source = readFileSync(resolve(process.cwd(), 'src/modules/overseas-warehou
 describe('overseas warehouse presentation contracts', () => {
   it('covers every formal list without freezing an API transport', () => {
     for (const name of [
-      'LastMileOrderListItem', 'InboundOrderListItem', 'DispatchListItem', 'InventoryListItem',
+      'LastMileOrderListItem', 'InboundOrderListItem', 'InventoryListItem',
       'RelabelOrderListItem', 'PalletListItem', 'CartonListItem',
       'ProductListItem', 'InventoryTransactionListItem',
     ]) expect(source).toContain(`interface ${name}`)
+    const native = readFileSync(resolve(process.cwd(), 'src/modules/overseas-warehouse/dispatchContracts.ts'), 'utf8')
+    expect(native).toContain('interface DispatchListRow')
+    expect(source).not.toContain('interface DispatchListItem')
     expect(source).not.toContain('axios')
     expect(source).not.toContain("from '@/shared/api/http'")
     expect(source).not.toMatch(/https?:\/\//)

src/modules/overseas-warehouse/types.ts

@@ -100,29 +100,6 @@ export interface InboundOrderListItem {
   version: number
 }
 
-export interface DispatchListItem {
-  actions?: import('./api/dispatches').DispatchActions
-  workflow?: import('./api/dispatches').DispatchWorkflow | null
-  id: string
-  dispatchNo: string
-  vehiclePlate: string
-  driverName: string
-  driverPhone: string
-  carrierName: string
-  orderNos: string
-  route: string
-  overseasWarehouse: string
-  departAt: string
-  fbaAppointment: string
-  vehicleAppointment: string
-  estimatedArrivalAt: string
-  status: string
-  statusCode: string
-  palletCount: number
-  packageCount: number
-  createdAt: string
-}
-
 export interface InventoryListItem {
   id: string
   customerId: string