docs: sync dynamic match timeout contract #254

fix(shopee): bound matching waits and recover drawer loading #254
2026-09-10 09:43:53 +08:00 · 2026-09-10 09:37:02 +08:00
27 changed files with 516 additions and 951 deletions
@@ -2,8 +2,8 @@
 generated: true (请先修改 Gitea Wiki，禁止直接编辑本文件)
 wiki_page: Architecture-and-Code-Map
 wiki_url: https://git.ilapage.cn/OPC/goauto/wiki/Architecture-and-Code-Map.-
-wiki_revision: d547c17924ac53422232ad9d6c55a34c8cd8d63c
-synchronized_at: 2026-09-08T07:16:20Z
+wiki_revision: e7a91d1d9c0f628297fb6ebe41b0d27d551c79ea
+synchronized_at: 2026-09-10T01:41:52Z
 <!-- gitea-wiki-mirror:end -->

 # 架构与代码地图
@@ -366,3 +366,36 @@ Server/Web、数据库和任务快照不变；旧 APK 仍有预滑动行为，
 Web 唯一展示位置为“采集采购 → SYB 同步记录”：列表状态、状态筛选及详情支持部分成功，详情保留已保存数量、错误原因与重新同步补齐提示。定时任务日志只表示异步任务受理，不等于最终业务同步成功。

 入口为 `SyncWithShopSnapshot → loadDailyList → importSyncPage`；`server/app/goauto/sybimport/sync_page.go` 封装页事务和提交后计数；`import_handler.go` 判定终态，`sync_run.go` 保存及筛选，Web 复用 `web/src/views/goauto/syb-sync-runs/index.vue`。
+
+## Android 连续临时采集收尾（#250）
+
+当前实现绑定 `37e8b56`（Agent 0.9.72 / 85），用户确认 v5 按次数返回后切回 Agent。仅 Android，无 Admin/API/权限/数据库迁移；取代 v1～v4 首页导航。
+
+- `AgentSettingsFragment` 在采集间隔后复用卡片和 SwitchMaterial；仅开启显示“返回次数”按钮，Material 单选框选择 1～5 次（默认 3），立即保存或取消。成功无常驻反馈，错误/忙碌显示原因。任务忙碌禁用，弹窗选定时再检查。
+- `AgentSettingsStore` 在私有 `goauto_agent_settings` 保存 `continuous_collection`（false）与 `continuous_collection_return_count`（3）；次数越界或读取错误回落 3，写入失败恢复旧值，无网络加载。
+- `requestCurrentPageCollection` 保留原范围判断；`executeTask` 在采集开始固定次数。`executeTaskWhileAwake` 提交结果、结束图片上传后返回 resultStatus；`ContinuousCollectionPolicy.finish` 仅对完整确认成功调用新 `PddCollectionReturnNavigator`。失败/部分成功不导航。冷却间隔不变，连续模式不启动旧 idle-return。
+- 删除 `PddCollectionHomeNavigator` 和专属首页/搜索层判据。新导航器仅使用 capture/back、当前包名、openAgentPreservingTab；1～5 次 Back，每次后 500ms，前台离开 PDD 终止剩余 Back；保留风险场景停止。最后打开 Agent 并等待 500ms 验证包名，不验证 PDD 首页。仍在原任务互斥与唤醒锁范围内完成，结束后原 finally 释放。
+- `GoAutoCollector` 日志关联 taskId、attemptNumber、deviceId、规则快照 SHA-256；记录 continuousReturn、configuredBacks、固定 reason 和 actions。原因含 count_completed、left_pdd、back_failed、unsafe_page、agent_launch_failed、agent_not_confirmed、navigation_exception、invalid_count；actions 为 Back 尝试数，不代表最终页面。无节点文字、树、截图或个人数据落盘；不扩大采购诊断存储。
+- `ContinuousCollectionTest` 覆盖范围/终态、1～5 次、无变化仍按次数、前台变化、风险、动作/启动失败、包名确认和异常；`ContinuousCollectionSettingsTest` 覆盖开关与次数持久化、默认/越界/写入失败。`:app:testDebugUnitTest :app:assembleDebug` 376 项通过。旧首页专属测试随旧行为替换，新版未安装，UI 大字体/横屏、多设备和完整采集真机链路尚未验证。
+
+## SYB 存疑规格候选解析（#251）
+
+实现绑定 `64b4205`，仅 Server `app/goauto/sybimport`；无 API 字段、数据库迁移、权限、并发模式或 UI 变化。
+
+- `parse_candidates.go: ParseWithCandidates` 先运行原 `Parse`，仅 uncertain 时解码并校验已存 SpecsJSON；复用 `closedShopeeCandidates` 提取颜色/尺码封闭候选，拒绝未知有值角色/重复角色。完整候选组合与原文归一比较唯一时确认，其他情况返回原 ParseResult。
+- `ApplyDetail` 在加载既有蝦皮商品后、写入规格前调用；`Reparse` 在保留人工/AI 确认保护后加载关联候选调用。新增 ParseResult 私有 matchedCandidates 标记，使 `mergeParsedSpec` 对已经存在的候选直接返回，避免按维度名重复合并或改变映射。
+- #198 `ProcessSpecAIParseRun → Reparse` 自然接入确定性优化，仍需 AI 的记录沿用原后续步骤，不新增异步任务/Provider 调用/接口。
+- 验证 `go test ./app/goauto/sybimport ./app/goauto/aimatching ./app/goauto/shopeeproduct ./app/goauto/purchase` 和 `go build ./...` 通过；新增候选正反/格式/组合色/单维度、歧义/空值、同步重解析一致、人工保护及无需调用 AI 测试。AI 原有置信度/失败重试测试改用仍需语义理解的合成输入，继续验证原分支。
+- 本轮只使用本地测试数据与 httptest AI，未触发真实 SYB 同步、外部 AI、采购、数据库迁移或服务重启；线上及历史数据效果尚待授权验证。
+
+
+## 蝦皮详情匹配等待与回读（#254）
+
+实现绑定 `9088e6b`（2026-09-10，分支 fix/254-match-loading）；已通过合成数据测试，尚未合并 main 或发布线上。
+
+- Server `shopeeproduct.Service.DetailWithAutoMatchBudget` 为详情 GET 附加派生的整次匹配预算，不返回 Provider、Key 等配置。`AutoMatchMappings` 读取 AI 设置 T，使用 2T+10 秒的单个父 context；颜色、尺码、保存及结果回读共用剩余时间。初始配置读取也受有界 context 约束，读取耗时从后续预算扣除。
+- 批量定时匹配调用内部 `autoMatchMappings` 并继续使用原 MaxProviderTimeout=600 秒，不随本次详情入口调整；候选建议与其他 AI 功能不改。
+- Web `ShopeeProductDetailDrawer` 在提交前以普通 GET 刷新商品与预算，仅 auto-match POST 使用 (2T+20) 秒超时。准备失败/缺少预算时不发 POST；旧 Server 必须先更新，不能只发布新版 Web。
+- 加载状态同时绑定商品加载代次和操作序号。关闭/切换立即结束该页面等待状态；同商品重开读取详情，旧响应/旧 finally 不得污染新操作。匹配期间禁止在当前抽屉编辑映射，原人工草稿放弃确认保留。
+- POST 未正常返回时只回读详情及关联 PDD，不自动重发 POST；回读失败结束转圈并保留刷新入口。GET 沿用单请求10秒超时，完整结果回读最多两次串行 GET，不是无限等待。
+- 验证：Go shopeeproduct/aimatching/clientapi 测试与 go build；Web `node --test tests/unit/shopee-match-lifecycle.test.cjs`，Playwright shopee-match-lifecycle 与 shopee-pdd-picker，受影响 ESLint 与 build:prod。
@@ -2,8 +2,8 @@
 generated: true (请先修改 Gitea Wiki，禁止直接编辑本文件)
 wiki_page: Business-Rules-and-Glossary
 wiki_url: https://git.ilapage.cn/OPC/goauto/wiki/Business-Rules-and-Glossary.-
-wiki_revision: afb3eb896e41d9aea0f15ad2682ec70b7a3924ea
-synchronized_at: 2026-09-08T07:16:32Z
+wiki_revision: c1ff5d88432826af67d3e40f58837bd98d93cfce
+synchronized_at: 2026-09-10T01:41:58Z
 <!-- gitea-wiki-mirror:end -->

 # 业务规则与术语
@@ -60,7 +60,11 @@ synchronized_at: 2026-09-08T07:16:32Z
 - “待人工核对”表示订单结果不明确，必须先人工核查并禁止自动重试；“采购成功”表示已取得 PDD 订单号和下单时间，不代表已经支付。
 - 一个 PDD 订单号只能属于一个采购任务，该唯一性在采购任务保存路径上全局强制（#241）。人工处理结果未知、取消及 lifecycle 保存路径撞号时返回 `PURCHASE_ORDER_NUMBER_ALREADY_USED`，提示订单号已属于哪个任务，由采购员人工核对，不静默覆盖原值。
 - 不可逆边界之后的 `order_created` 结果回传是上述规则的例外：此时 PDD 真单已创建，发现订单号已属于其他任务时不回滚、不判失败，而是把任务降级为 `order_result_unknown`，冲突订单号以「读到订单号 X，但该号已属于任务 CG-yy」保存在任务与 attempt 的 `error_message`，`pdd_order_no` 留空以维持唯一性，保留下单时间与不可逆时间，进入既有人工处理结果未知通道。首要目标是保住「真单已存在」这一事实，不制造无记录的真实订单。
- Agent 可按收货地址后缀 `_cg<任务号>` 批量回填订单号与下单时间（#241）。后缀只承载任务号，请求不含地址全文或收件人信息；只允许回填该设备自己的正式采购任务；页面下单时间优先，缺失时回落该任务的 `irreversible_at` 并标记时间来源，两者皆空则该条失败。
+- Agent 可按收货地址后缀 `_cg<任务号>` 批量回填订单号与下单时间（#241）。
+- Agent 侧回填为**人工触发的只读扫描**（#242）：入口在采购记录页搜索按钮右侧，输入天数（默认 2）后确认启动。天数口径为滚动 N×24 小时，基准是页面读到的下单时间。采集、采购、回填三者互斥，复用既有任务互斥锁并加原子防重入，忙碌时拒绝启动而不排队、不抢占。
+- 回填扫描不假设订单列表有序：只有连续观察到至少 5 单且下单时间严格递减、期间无缺失时间时，才允许「超过指定时间即停止」；一旦出现时间回升或缺失，改为扫至内部上限并明确标记「未完整扫描」，不得把不完整结果显示为已扫完。内部上限用于限制设备占用，不作为用户可配置的门禁。
+- 回填扫描全程只读：确认收货、申请退款、催发货、去支付、立即支付、提交订单、付款、退款、取消订单、再次购买、删除订单永久排除为点击目标；点击目标必须自身可点、子树不含上述词，且不与任何含上述词的可见控件几何重叠；不得按固定坐标盲点。遇登录、验证码或风控立即停止并报告。
+- 解析不出规范后缀的订单一律跳过，其订单数据不缓存、不上传、不入日志；上传载荷只含后缀、订单号与可选下单时间。本地缓存只采纳服务端确认的事实，并区分页面读到的真实时间与 `irreversible_at` 回落估算值。后缀只承载任务号，请求不含地址全文或收件人信息；只允许回填该设备自己的正式采购任务；页面下单时间优先，缺失时回落该任务的 `irreversible_at` 并标记时间来源，两者皆空则该条失败。
 - 已失败、已取消或演练完成的旧采购任务不单独占用主阶段；当前数据仍满足条件时恢复显示“可创建采购”，旧任务继续在采购管理留痕和按既有规则处理。
 - 未选择处理阶段时，商品列表仍先返回，当前页阶段和采购准备继续异步批量读取且不调用 AI Provider；选择阶段筛选时，服务端必须先对完整查询结果派生并筛选阶段，再计算总数和分页，不能只过滤当前页。

@@ -400,7 +404,7 @@ synchronized_at: 2026-09-08T07:16:32Z

 - 规格入口与精确规格选择统一按“重新定位唯一目标 → 执行一次无障碍点击 → 读取新页面验证”执行；不得复用旧无障碍节点，不选择相近规格，也不在多候选时默认点击第一个。
 - 无障碍点击后页面完全无变化时，只允许对解析器已确认的安全规格入口或服务端下发且唯一命中的精确规格执行一次中心手势兜底。目标必须可见、启用、边界有效，手势后仍须以规格面板强证据或精确选中证据确认结果。
- 页面发生变化但规格面板强证据不足时，不再继续手势或猜测页面，明确失败并只记录面板类型、候选数量和证据布尔值等无敏感标量。原始控件树、节点文字集合和整屏截图仍不得保存或上传。
+- 页面发生变化但规格面板强证据不足时，默认明确失败；#243 的同商品页安全入口恢复是限定例外：确认包/Activity 未变、商品标题非空且未变、入口来源与语义未变，无面板、关闭、数量、已选、支付、订单或页面异常信号时，重新定位入口并最多执行一次受控手势。整页普通动态节点变化不单独阻断该恢复；入口缺失或显式/嵌套入口歧义仍拒绝。商品标题一致是当前上下文约束，不宣称已从页面核验 goods_id。诊断只记录入口来源、点击结果/原因、恢复结果和面板数量/布尔等无敏感标量。原始控件树、节点文字集合和整屏截图仍不得保存或上传。
 - 规格已处于精确选中状态时不得重复点击。规格查找只在解析器唯一识别的规格面板容器内有限滚动，每次滚动后重新定位容器与目标；容器缺失、歧义、到边或验证失败均 fail-closed。
 - 中心手势兜底不得用于修改/保存地址、创建或提交订单、订单详情入口以及任何支付/付款目标；正式创建订单的一次性不可逆门禁与永久禁止支付规则不变。
 ## PDD 商品反向关联与继续订单采购（#161）
@@ -478,3 +482,65 @@ synchronized_at: 2026-09-08T07:16:32Z
 `orderCount` 是已验证页的原始列表读取数量；`detailCount`、`created`、`updated` 为已提交明细及其新增/覆盖数量；`daysProcessed` 是完整通过的日期数，不是已尝试日期数。失败日期/页码/阶段写入现有脱敏限长 errorMessage。部分成功不刷新店铺的完整同步统计。

 Web 唯一展示位置为“采集采购 → SYB 同步记录”：列表状态、状态筛选及详情支持部分成功，详情保留已保存数量、错误原因与重新同步补齐提示。定时任务日志只表示异步任务受理，不等于最终业务同步成功。
+
+
+## 商品页动态变化下的采购入口恢复（#243）
+
+实现 ec8b14a，Android 0.9.61/versionCode 74；已构建、未安装或真机验收。规格探测和正式采购共用入口函数，面板已打开时不新增点击；仍在同一商品上下文且安全入口存在时，一次重新定位手势恢复不再依赖整页完全静止。手势后仍未打开则报告入口无效果，不循环点击。恢复不能用于地址、创建订单、支付或未知面板，不修改面板分类器及正式下单边界。CG82/CG85 原首次点击未生效的底层原因尚待新日志和授权真机验证。
+
+
+## 同一颜色卡片重复选中节点（#244）
+
+实现 93aab6a，Android 0.9.62/versionCode 75；已构建并授权覆盖安装，真实采购效果待验收。仅在颜色维度完整精确目标已选中、但存在非目标已选候选时，识别同一卡片重复表达：卡片必须是滚动容器直接子级的可点击非滚动 android.view.ViewGroup，节点父链明确、可见启用且边界包含；其他冲突节点仅可为该卡片自身或其中的 ImageView。另一文字选项、另一张卡片、多个精确目标、目标未选中、父链/边界不明均不适用例外。额外核对内存源节点以拒绝被解析器按同名去重隐藏的跨卡片目标；不保存原始树。
+
+不删除规格数字、不模糊匹配、不改变通用解析器、尺码确认、摘要兜底、入口/滚动/地址/价格/创建订单。没有非目标选中冲突时继续原判断；仅把同卡片容器/图片的重复选中表达从冲突中排除，不新增点击。
+
+
+## 精确规格不可用与入口恢复诊断（#245）
+
+实现 ca815c3，Android 0.9.63/versionCode 76；已通过单元测试并构建，未安装、未进行真实采购验收。入口恢复沿用 #243 条件，拒绝时通过 entryRecovery=rejected;reason=<固定原因码> 区分页面身份、商品上下文、面板/支付区域、数量/摘要、标题、入口来源/文案、歧义、规则别名及可用性；不放宽条件，不新增点击。
+
+在规格面板识别出唯一完整精确候选且 available=false 时，立即返回既有 PURCHASE_SPEC_SAFE_TARGET_MISSING，提示目标颜色/尺码已售罄或当前不可选，未创建订单；已选中目标同样不能绕过不可用检查。只记录 dimension 和 exact_target_unavailable 固定结构证据，不记录规格原文或原始树。原有纵向与横向定位在此条件下本就停止，不能将本改动描述为修复“已识别售罄仍继续搜索”。未识别精确候选时继续既有有界搜索，不推断售罄，不替换规格；解析器、匹配规则、滚动预算、地址与下单流程不变。
+
+## 改地址返回后的动态提交按钮（#248）
+
+实现绑定 `c80c746`，Android 0.9.66 / versionCode 79；已通过 353 项 Android 单元测试并构建，尚未安装或进行真实采购验收。
+
+- 地址回读与最终提交按钮定位分开判断。旧“提交订单”“现在买，仅”“确认购买”识别继续优先；存在旧文案候选但歧义时不使用结构补充选择其中一个。地址确实缺失时保留既有有限恢复；地址及采购面板上下文已确认后，不因底部按钮文字变化而滚动规格列表。按钮缺失或不唯一使用 `PURCHASE_SUBMIT_TARGET_AMBIGUOUS` 提示按钮问题，不误报地址保存超时。
+- 结构补充只属于当前执行器中已完成地址修改后的返回流程，不能由其他页面或旧执行的地址证明启用。当前须为 PDD、地址后缀按既有规则回读唯一、地址入口唯一，并存在唯一数量输入或已选摘要；通过地址入口与该证据的最近共同祖先确定整个采购弹层，不把颜色/尺码滚动区域当成弹层。排除全屏大祖先、地址编辑、已知支付 Activity 及订单结果/支付页面，后续定位要求 Activity 与地址返回时一致。
+- 旧文案无候选时，只接受弹层底部固定区域内一个独立、可见启用、非滚动的可点击容器；不在规格滚动区内选择按钮，不取控件树末项，不使用固定屏幕点击坐标。文字与人民币金额子节点合并为一个按钮；支持如“复购价，”及非支付展示文字变化，但单独价格、多个操作按钮或支付/付款/地址/返回等非提交动作均不放行。
+- 地址返回检查、最终复核和提交共用目标定位。结构路径保留原文字节点为重新定位锚点，由已有无障碍点击重新查找其可点击父级；不新增下单手势兜底。最终复核成功后才允许该结构路径提交；提交前再次检查路径、类别、文字与边界，发生变化即停止；复核失败清除本地结构提交锚点。
+- 既有规格、数量、价格和地址复核，任务租约、服务端/本地不可逆边界及单次提交规则不变。结构识别不支持支付，不增加采购员操作、配置或审批；不改变 Admin、接口、数据库、规则 JSON、通用解析器及滑动执行器。原始控件树、整屏截图、地址全文和凭据不得落盘或上传。
+
+## 临时采集连续模式（#250）
+
+当前实现绑定 `37e8b56`，Agent 0.9.72 / versionCode 85。2026-09-09 用户批准 v5：按配置次数返回后切回 Agent，替代此前“识别并停留 PDD 首页”的方案；不保证 PDD 最终停在首页。代码、376 项 Android 单测及 Debug 构建通过，新版设置与完整真机闭环待验收。
+
+- 连续采集默认关闭，本机即时保存，失败恢复原值；开启后显示返回次数选择，1～5 次、默认 3，取消不改，写入失败恢复旧值。任务忙碌时开关和次数均禁用，选择提交时再次检查；无新增权限。只用于本次人工新建普通临时采集（source=agent_current_page、attemptNumber=1、无替换来源），Admin 下发、重试、替代与采购不参与。
+- 单任务执行开始固定返回次数。完整 completed、服务端提交确认且既有图片上传流程结束后，执行有限 Back，每次后等待 500ms；不要求识别商品/搜索/相机/首页，也不要求画面发生变化。图片上传仍沿用既有非致命行为，不因收尾更改结果。
+- 每次 Back 前检查前台仍为 PDD，读取页面后再次检查；离开 PDD 则停止余下 Back。次数完成、离开 PDD 或 Back 动作失败后，尝试打开 Agent 保持原 Tab，等待 500ms 并验证前台包名。动作失败不重试，不把请求启动成功直接当作切回成功。
+- 沿用风险页安全边界：登录/验证码/风控、地址编辑、订单详情或支付等证据时保留现场，不发送 Back 或强行切回；Activity 缺失、读取异常明确停止。以上例外不引入首页门禁。
+- 导航在原任务互斥和唤醒锁内完成，不变更租约/调度。返回失败只显示人工处理提示，不把成功采集改为失败或自动重采。
+- 失败、部分成功、提交未确认保留现场，不运行返回步骤，也不触发旧空闲返回倒计时。关闭开关保持原流程，采集间隔不变。
+- 不自动拍照、搜索或创建下一任务，不涉及采购/订单/付款；不使用深链、浏览器、OCR/VLM 或坐标兜底。
+
+## SYB 存疑规格候选核对（#251）
+
+实现绑定 `64b4205`，基线 main `fdd26af`；2026-09-09 代码与本地测试/构建通过，未部署、未重跑生产历史数据。
+
+- 原 Parse 的成功与失败行为不变，仅 uncertain 明细增加既有蝦皮规格候选核对。比较完整原文，沿用【备注】清理，允许全角逗号、逗号两侧空白及连续空白归一；颜色尺码可正序或倒序，使用逗号或空白分隔，只有唯一完整组合才改为 success。返回既有候选标签，不改写标签，不删除加号、不截断体重说明、不做近似匹配。
+- 单规格只有在候选确实仅包含该角色时通过；有两个角色时不能用单值补猜另一个角色。空/损坏候选、校验不通过、同角色多维、未知有值维度、多种组合或归一化碰撞，均保留原结果。候选必须已存在，不能用本次待确认输入生成候选再自我证明。
+- 同步入库 ApplyDetail、手动 Reparse 共用；成功核对不再次合并规格，因此不新增重复维度、不覆盖已有映射。人工确认仍优先，默认 Reparse 跳过人工与 AI 已确认值；原文保留。
+- #198 批处理原本先 Reparse，所以可直接复用本优化：能确定的不用调用 AI；仍不确定的按原 AI 流程处理。没有新增调度、调用额度或同步等待，不自动开启已有任务。
+- 不取消 uncertain/failed 状态，不改变采购可信度/可采购规则，不实现一键关联 PDD。部署后新同步或显式重新解析会使用新逻辑；本次没有执行生产批量更新。
+
+
+## 蝦皮详情匹配等待与回读（#254）
+
+实现绑定 `9088e6b`（2026-09-10，分支 fix/254-match-loading）；已通过合成数据测试，尚未合并 main 或发布线上。
+
+- AI 设置中的 timeoutSeconds=T 仍是单次 Provider 请求的上限。详情一键匹配的整次预算为 2T+10 秒，浏览器 POST 等待上限为 2T+20 秒；例如 T=60 时130/140秒，T=180时370/380秒。只保留现有一个 AI 设置入口，不新增时间配置框，也不自动改变管理员已保存的 T。
+- 超时上限不是固定等待。颜色/尺码串行执行且共用整次预算；正常部分匹配仍按原事务保存合格结果，AI异常在保存前返回时不提交本轮新映射。既有置信度、候选、人工确认映射保护和采购资格不变。
+- 前端超时、关闭或切换详情不代表后端已取消、未保存或已回滚；必须以回读结果为准，无法回读显示结果未确认，不自动重复匹配、不自动创建采购。
+- 单商品详情的成功/失败/超时/关闭重开都必须结束失效的等待状态；旧请求不得覆盖新商品或新操作。匹配进行期间本抽屉不能人工改映射，已有未保存草稿仍按原确认流程处理。
+- UI匹配提示的等待上限仅指POST，不含提交前GET及结果核对GET；结果核对也有限时，不能让失败提示再次陷入无限转圈。
@@ -2,8 +2,8 @@
 generated: true (请先修改 Gitea Wiki，禁止直接编辑本文件)
 wiki_page: Android-Agent-API-Contract
 wiki_url: https://git.ilapage.cn/OPC/goauto/wiki/Android-Agent-API-Contract.-
-wiki_revision: 1f5ee1b29c66773fa571d862241b63f02dae283b
-synchronized_at: 2026-09-08T07:09:23Z
+wiki_revision: 9898c6141b878407c2622c986eb9e15f0b39774d
+synchronized_at: 2026-09-10T01:42:20Z
 <!-- gitea-wiki-mirror:end -->

 # MVP 共享 API 契约
@@ -1060,3 +1060,16 @@ requestId 沿用 UUID 约定，不增加批次表或全局幂等缓存。既有
 新回填路径禁用包含绑定参数的 SQL 日志，不记录请求正文、订单号、地址或原始树；任务号和认证设备号沿既有任务关联不可变 ruleSnapshot。此接口未新增日志载荷或任务/attempt。

 本地测试覆盖事务回滚、并发服务调用和旧写入路径，使用 SQLite；MySQL 8.4 多连接/多进程的实际行锁、生产数据和真机端到端回填尚待环境验收，不以单元测试替代。
+
+
+## 蝦皮详情匹配等待与回读（#254）
+
+实现绑定 `9088e6b`（2026-09-10，分支 fix/254-match-loading）；已通过合成数据测试，尚未合并 main 或发布线上。
+
+本节是 Admin 蝦皮详情接口补充，不修改 Android 请求或采购协议。
+
+- `GET /api/admin/v1/shopee-products/:productId` 的 `data` 增加 `autoMatchTimeoutSeconds` 整数，为后端详情一键匹配整次预算 `2 × AI timeoutSeconds + 10`，配置范围3～600对应16～1210秒。它是非敏感派生预算，沿用商品详情读取权限；不是开放 AI 管理配置读取，响应不包含 Key、Provider、BaseURL 或 Model。现有客户端路由若复用本 Handler 同样仅获得这个数字。
+- `POST /api/admin/v1/shopee-products/:productId/specs/mapping/auto-match` 请求字段、业务权限、版本核对与响应映射语义不变。服务端按收到请求时的 AI 配置确定整次父预算，读取配置耗时扣除；Provider 请求仍受自身超时及父 context 剩余时间中更短者约束。
+- Admin 点击前先GET新详情取得预算，POST timeout=(autoMatchTimeoutSeconds+10)×1000毫秒；缺字段、非整数或超范围时明确拒绝开始匹配，不猜配置。前后端需配套升级。
+- 准备后配置可能变化，浏览器仍可能先超时；不要据超时响应断言事务是否提交。POST失败/断连/超时只执行有限GET回读，不自动重发POST；失败回读显示结果未知。回读结果表示当前已保存状态，不保证这次请求已经永久不再写入，也不保证全部项目都匹配成功。
+- 普通GET默认10秒；本轮未修改建议接口610秒、其他AI功能或后台批量匹配600秒预算。T=60时130/140秒、T=180时370/380秒。
@@ -2,8 +2,8 @@
 generated: true (请先修改 Gitea Wiki，禁止直接编辑本文件)
 wiki_page: Deployment-and-Operations
 wiki_url: https://git.ilapage.cn/OPC/goauto/wiki/Deployment-and-Operations.-
-wiki_revision: df033d06fd94a4b02a447a27ced8d711521342f3
-synchronized_at: 2026-09-08T02:23:08Z
+wiki_revision: 933eaf6cc02fed843a6898269fdb5f6848ac2a8a
+synchronized_at: 2026-09-10T01:42:05Z
 <!-- gitea-wiki-mirror:end -->

 # 部署与运维
@@ -41,7 +41,7 @@ GOAUTO_ALLOW_INSECURE_AGENT_HTTP=true

 ### API 长请求超时约束

-Admin 蝦皮规格 AI 匹配会同步等待外部 Provider：Provider 配置允许 3～600 秒，复合的一键匹配共享 600 秒总预算，Admin 客户端等待 610 秒。因此服务端 `settings.application.writetimeout` 必须至少为 620 秒，受版本管理的标准配置固定为 `620`；启动时低于该值必须明确失败，禁止以 2 秒等短写超时运行，否则连接会在领域错误返回前被截断并表现为代理 502。反向代理的读/发送超时也必须大于服务端窗口。
+Admin 蝦皮规格 AI 匹配会同步等待外部 Provider：Provider 配置允许 3～600 秒，旧版详情复合一键匹配共享600秒总预算，旧Admin客户端等待610秒；#254未部署前仍适用，部署后详情入口改用下节动态预算。因此服务端 `settings.application.writetimeout` 必须至少为 620 秒，受版本管理的标准配置固定为 `620`；启动时低于该值必须明确失败，禁止以 2 秒等短写超时运行，否则连接会在领域错误返回前被截断并表现为代理 502。反向代理的读/发送超时也必须大于服务端窗口。

 Provider 故障日志只允许记录调用关联 ID、操作类型、耗时、上游 HTTP 状态码或网络错误分类；不得记录 API Key、Authorization、Provider URL、模型输入、候选规格、商品原始内容或响应正文。Provider 失败时接口返回 HTTP 503 与 `AI_MATCHING_UNAVAILABLE`，供 Admin 显示安全中文提示。

@@ -93,3 +93,14 @@ Provider 故障日志只允许记录调用关联 ID、操作类型、耗时、
 - 范围明确的服务控制：`D:/supervisor/supervisord.exe -c D:/supervisor/supervisord.conf ctl status goauto-admin-api goauto-admin-ui`，启动/停止/重启将 status 分别替换为 start/stop/restart。不得为了 GoAuto 重启整个 Supervisor 或其他项目。配置内容变化后需重新读取配置；本次调用 `supervisor.reloadConfig`，再对上述两个程序定向 start，已通过进程命令行核对新目录。
 - 日志：`D:/supervisor/logs/goauto-admin-api.log`、`D:/supervisor/logs/goauto-admin-ui.log`；对外分享只能保留脱敏结构摘要。迁移输出不得暴露凭据或业务原文。
 - 管理员刷新页面后可进入 `http://127.0.0.1:9527/#/client-keys/index`；菜单缓存未更新时重新登录。已验证列表空态、创建弹窗加载 12 模块及 HTTP 风险提示；未实际创建密钥，真实客户端读写及停用闭环仍待范围明确的验证。本节为 2026-09-07 本机验证记录；线上已于 2026-09-08 另行授权发布，见上节。
+
+
+## 蝦皮详情匹配等待与回读（#254）
+
+实现绑定 `9088e6b`（2026-09-10，分支 fix/254-match-loading）；已通过合成数据测试，尚未合并 main 或发布线上。
+
+- 本次只完成代码构建与合成测试，未改线上配置、AI设置、常驻服务或Nginx；部署与重启需另行授权。
+- 详情匹配新窗口是后端 2T+10 秒、Web POST 2T+20 秒。当前默认API最低写超时校验仍为620秒，这是历史最低值，不保证容纳所有动态预算；发布前读取实际 AI timeoutSeconds、application.writetimeout 和生效代理配置核对。
+- 建议API写超时至少为 2T+30 秒，且仍满足原最低620秒；代理读/发送超时需留足对应窗口。T=60/180时原620秒足够容纳应用预算；T=600时至少需要1230秒API写超时及适当更长的代理窗口。不得仅设置较大的AI超时却忽略传输层更早截断。
+- 上述是发布核对要求，不是本单已修改/验证线上代理的结论。超大T带来长连接占用，不能用关闭超时来代替正确预算。新增失败回读不代表必须延长任何线上请求。
+- 必须配套发布 Server/Web；仅上新版Web连接旧Server时，因缺失派生预算会提示等待时间不可用并停止匹配。原Android不需升级。
@@ -202,15 +202,7 @@ func (task *PurchaseTask) BeforeCreate(_ *gorm.DB) error {
 	return task.syncPurchaseGuardSlots()
 }

-func (task *PurchaseTask) BeforeSave(tx *gorm.DB) error {
-	if err := task.syncPurchaseGuardSlots(); err != nil {
-		return err
-	}
-	if task.PDDOrderNo != nil && *task.PDDOrderNo != "" {
-		return CheckPurchaseOrderNumber(tx, task.ID, *task.PDDOrderNo)
-	}
-	return nil
-}
+func (task *PurchaseTask) BeforeSave(_ *gorm.DB) error { return task.syncPurchaseGuardSlots() }

 func (task *PurchaseTask) SetStatus(status string) error {
 	task.Status = status
@@ -1,41 +0,0 @@
-package models
-
-import (
-	"errors"
-	"fmt"
-
-	"gorm.io/gorm"
-	"gorm.io/gorm/clause"
-)
-
-var ErrPurchaseOrderNumberUsed = errors.New("purchase order number belongs to another task")
-
-type PurchaseOrderNumberUsedError struct {
-	TaskID uint64
-}
-
-func (e *PurchaseOrderNumberUsedError) Error() string {
-	return fmt.Sprintf("订单号已属于任务 CG-%d", e.TaskID)
-}
-
-func (e *PurchaseOrderNumberUsedError) Unwrap() error { return ErrPurchaseOrderNumberUsed }
-
-// CheckPurchaseOrderNumber must run inside the caller's write transaction.
-// The existing singleton setting row serializes order assignments across
-// processes, including an absent order number, without relying on gap locks or
-// a new schema constraint. Locking reads see the latest committed assignment.
-// A missing singleton fails closed. Deadlocks roll back the losing transaction.
-func CheckPurchaseOrderNumber(tx *gorm.DB, taskID uint64, orderNo string) error {
-	var setting PurchaseRuleSetting
-	if err := tx.Session(&gorm.Session{NewDB: true}).Clauses(clause.Locking{Strength: "UPDATE"}).First(&setting, 1).Error; err != nil {
-		return err
-	}
-	var others []PurchaseTask
-	if err := tx.Session(&gorm.Session{NewDB: true}).Select("id").Clauses(clause.Locking{Strength: "UPDATE"}).Where("pdd_order_no = ? AND id <> ?", orderNo, taskID).Find(&others).Error; err != nil {
-		return err
-	}
-	if len(others) != 0 {
-		return &PurchaseOrderNumberUsedError{TaskID: others[0].ID}
-	}
-	return nil
-}
@@ -542,7 +542,7 @@ func writeError(c *gin.Context, err error) {
 		status = http.StatusForbidden
 	case CodeTaskNotFound:
 		status = http.StatusNotFound
-	case CodeStateConflict, CodeCapabilityMismatch, CodeDeviceBusy, CodeTaskClaimed, CodeLeaseExpired, CodeMappingRequired, CodeResultConflict, CodeRePurchaseRequired, CodeOrderNumberUsed:
+	case CodeStateConflict, CodeCapabilityMismatch, CodeDeviceBusy, CodeTaskClaimed, CodeLeaseExpired, CodeMappingRequired, CodeResultConflict, CodeRePurchaseRequired:
 		status = http.StatusConflict
 	}
 	c.JSON(status, gin.H{"code": code, "message": msg, "retryable": retryable})
@@ -6,7 +6,6 @@ import (
 	"encoding/hex"
 	"encoding/json"
 	"errors"
-	"fmt"
 	"strings"
 	"time"

@@ -379,22 +378,6 @@ func (s *Service) SubmitResult(ctx context.Context, taskID uint64, req ResultReq
 			t.PDDOrderNo = &req.PDDOrderNo
 			t.OrderSubmittedAt = req.OrderSubmittedAt
 			t.ActualUnitPriceCent = req.ActualUnitPriceCent
-			// Keep the assignment lock until commit. A conflicting observation
-			// after the irreversible boundary must reach manual resolution,
-			// not roll back the result or claim another task's order number.
-			if e := models.CheckPurchaseOrderNumber(tx, t.ID, req.PDDOrderNo); e != nil {
-				var conflict *models.PurchaseOrderNumberUsedError
-				if !errors.As(e, &conflict) {
-					return TaskPayload{}, conflictOrInternal(e)
-				}
-				next = models.PurchaseTaskStatusOrderResultUnknown
-				t.PDDOrderNo = nil
-				failureCode := CodeOrderNumberUsed
-				message := fmt.Sprintf("读到订单号 %s，但该号已属于任务 %s", req.PDDOrderNo, taskNumber(conflict.TaskID))
-				t.ErrorCode, t.ErrorMessage = &failureCode, &message
-				a.Status = models.PurchaseAttemptStatusFailed
-				a.ErrorCode, a.ErrorMessage = &failureCode, &message
-			}
 		case "order_result_unknown":
 			if t.ExecutionMode != models.PurchaseExecutionModeLive || t.Status != models.PurchaseTaskStatusOrderSubmitStarted {
 				return TaskPayload{}, fail(CodeStateConflict, "当前任务不能标记订单结果未知")
@@ -542,10 +525,7 @@ func (s *Service) applySpecDecision(ctx context.Context, taskID uint64, req Spec
 		}
 		t.StatusVersion++
 		t.StatusChangedAt = s.Now()
-		if e := tx.Save(&t).Error; e != nil {
-			return conflictOrInternal(e)
-		}
-		return nil
+		return tx.Save(&t).Error
 	})
 	return t, replayed, err
 }
@@ -748,10 +728,6 @@ func purchaseNotFound(err error) error {
 	return internal(err)
 }
 func conflictOrInternal(err error) error {
-	var conflict *models.PurchaseOrderNumberUsedError
-	if errors.As(err, &conflict) {
-		return fail(CodeOrderNumberUsed, conflict.Error())
-	}
 	if isDuplicate(err) {
 		return fail(CodeDeviceBusy, "设备或拼多多账号已有运行任务")
 	}
@@ -80,10 +80,7 @@ func (s *Service) SelectWriteback(ctx context.Context, id uint64, req ManualRequ
 		}
 		out.WritebackStatus = models.PurchaseWritebackStatusPending
 		out.WritebackSelectRequestID = &req.RequestID
-		if e := tx.Save(&out).Error; e != nil {
-			return conflictOrInternal(e)
-		}
-		return nil
+		return tx.Save(&out).Error
 	})
 	return out, replayed, err
 }
@@ -169,10 +166,7 @@ func (s *Service) manual(ctx context.Context, id uint64, req ManualRequest, appl
 				return internal(e)
 			}
 		}
-		if e := tx.Save(&out).Error; e != nil {
-			return conflictOrInternal(e)
-		}
-		return nil
+		return tx.Save(&out).Error
 	})
 	return out, replayed, err
 }
@@ -1,202 +0,0 @@
-package purchase
-
-import (
-	"context"
-	"errors"
-	"strings"
-	"time"
-	"unicode/utf8"
-
-	"go-admin/app/goauto/device"
-	"go-admin/app/goauto/models"
-	"go-admin/app/goauto/purchasecontract"
-
-	"github.com/google/uuid"
-	"gorm.io/gorm"
-	"gorm.io/gorm/clause"
-	"gorm.io/gorm/logger"
-)
-
-const (
-	MaxOrderBackfillItems     = 50
-	CodeBackfillSuffix        = "PURCHASE_BACKFILL_SUFFIX_INVALID"
-	CodeBackfillDevice        = "PURCHASE_BACKFILL_DEVICE_MISMATCH"
-	CodeBackfillOrderConflict = "PURCHASE_BACKFILL_ORDER_CONFLICT"
-	CodeBackfillBatchConflict = "PURCHASE_BACKFILL_BATCH_CONFLICT"
-	CodeBackfillOrderUsed     = "PURCHASE_BACKFILL_ORDER_ALREADY_USED"
-)
-
-type OrderBackfillRequest struct {
-	RequestID string              `json:"requestId"`
-	Items     []OrderBackfillItem `json:"items"`
-}
-
-type OrderBackfillItem struct {
-	AddressSuffix string `json:"addressSuffix"`
-	PDDOrderNo    string `json:"pddOrderNo"`
-	// A string keeps an invalid page timestamp local to this item.
-	OrderSubmittedAt *string `json:"orderSubmittedAt,omitempty"`
-}
-
-type OrderBackfillResult struct {
-	Index            int        `json:"index"`
-	TaskID           uint64     `json:"taskId,omitempty"`
-	Result           string     `json:"result"`
-	Code             string     `json:"code"`
-	Status           string     `json:"status,omitempty"`
-	StatusVersion    uint64     `json:"statusVersion,omitempty"`
-	PDDOrderNo       *string    `json:"pddOrderNo,omitempty"`
-	OrderSubmittedAt *time.Time `json:"orderSubmittedAt,omitempty"`
-	TimeSource       string     `json:"timeSource,omitempty"`
-	Retryable        bool       `json:"retryable"`
-}
-
-type OrderBackfillResponse struct {
-	RequestID string                `json:"requestId"`
-	Items     []OrderBackfillResult `json:"items"`
-}
-
-func (s *Service) BackfillOrders(ctx context.Context, req OrderBackfillRequest, token string) (OrderBackfillResponse, error) {
-	out := OrderBackfillResponse{RequestID: req.RequestID}
-	d, err := device.NewService(s.DB).Authenticate(ctx, token)
-	if err != nil {
-		return out, err
-	}
-	if _, err := uuid.Parse(req.RequestID); err != nil || len(req.Items) == 0 || len(req.Items) > MaxOrderBackfillItems {
-		return out, fail(CodeInvalidRequest, "requestId 必须为 UUID，items 必须包含 1 到 50 条")
-	}
-	ids := make([]uint64, len(req.Items))
-	orders := make(map[uint64]string)
-	conflicts := make(map[uint64]bool)
-	for i, item := range req.Items {
-		id, err := purchasecontract.ParseAddressSuffix(item.AddressSuffix)
-		if err != nil {
-			continue
-		}
-		ids[i] = id
-		if previous, ok := orders[id]; ok && previous != item.PDDOrderNo {
-			conflicts[id] = true
-		}
-		orders[id] = item.PDDOrderNo
-	}
-	out.Items = make([]OrderBackfillResult, len(req.Items))
-	for i, item := range req.Items {
-		r := OrderBackfillResult{Index: i, TaskID: ids[i], Result: "failed"}
-		if ids[i] == 0 {
-			r.Code = CodeBackfillSuffix
-		} else {
-			r = s.backfillOrder(ctx, d.ID, ids[i], req.RequestID, item, conflicts[ids[i]])
-			r.Index = i
-		}
-		out.Items[i] = r
-	}
-	return out, nil
-}
-
-func (s *Service) backfillOrder(ctx context.Context, deviceID, taskID uint64, requestID string, item OrderBackfillItem, batchConflict bool) OrderBackfillResult {
-	r := OrderBackfillResult{TaskID: taskID, Result: "failed"}
-	var task models.PurchaseTask
-	// SQL errors must not print bound order numbers or the task's address snapshot.
-	db := s.DB.Session(&gorm.Session{Logger: logger.Default.LogMode(logger.Silent)}).WithContext(ctx)
-	err := db.Transaction(func(tx *gorm.DB) error {
-		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&task, taskID).Error; err != nil {
-			return purchaseNotFound(err)
-		}
-		if task.DeviceID == nil || *task.DeviceID != deviceID {
-			return fail(CodeBackfillDevice, "任务不属于当前设备")
-		}
-		if batchConflict {
-			return fail(CodeBackfillBatchConflict, "同批任务有不同订单号")
-		}
-		if task.ExecutionMode != models.PurchaseExecutionModeLive || (task.Status != models.PurchaseTaskStatusOrderResultUnknown && task.Status != models.PurchaseTaskStatusOrderCreated) {
-			return fail(CodeStateConflict, "当前任务不允许回填")
-		}
-		if item.PDDOrderNo == "" || strings.TrimSpace(item.PDDOrderNo) != item.PDDOrderNo || utf8.RuneCountInString(item.PDDOrderNo) > 100 || strings.ContainsAny(item.PDDOrderNo, "\r\n\t") {
-			return fail(CodeInvalidRequest, "订单号无效")
-		}
-		if task.PDDOrderNo != nil && *task.PDDOrderNo != "" && *task.PDDOrderNo != item.PDDOrderNo {
-			return fail(CodeBackfillOrderConflict, "已有不同订单号")
-		}
-		// The shared model guard also protects manual resolution and late results.
-		if err := models.CheckPurchaseOrderNumber(tx, taskID, item.PDDOrderNo); err != nil {
-			return err
-		}
-		if task.Status == models.PurchaseTaskStatusOrderCreated {
-			if task.PDDOrderNo == nil || *task.PDDOrderNo != item.PDDOrderNo {
-				return fail(CodeStateConflict, "已创建订单缺少匹配订单号")
-			}
-			r.Result, r.Code = "already_backfilled", "ALREADY_BACKFILLED"
-			return nil
-		}
-		var submitted time.Time
-		source := "page"
-		if item.OrderSubmittedAt != nil {
-			var err error
-			submitted, err = time.Parse(time.RFC3339Nano, *item.OrderSubmittedAt)
-			if err != nil || submitted.IsZero() || submitted.Year() < 1000 || submitted.Year() > 9999 {
-				return fail(CodeOrderTimeInvalid, "下单时间必须为 RFC3339")
-			}
-		} else {
-			if task.IrreversibleAt == nil || task.IrreversibleAt.IsZero() {
-				return fail(CodeOrderTimeMissing, "下单时间和不可逆时间均缺失")
-			}
-			submitted, source = *task.IrreversibleAt, "irreversible_at"
-		}
-		submitted = submitted.UTC()
-		task.PDDOrderNo, task.OrderSubmittedAt = &item.PDDOrderNo, &submitted
-		if err := task.SetStatus(models.PurchaseTaskStatusOrderCreated); err != nil {
-			return internal(err)
-		}
-		task.StatusVersion++
-		task.StatusChangedAt = s.Now()
-		task.ErrorCode, task.ErrorMessage = nil, nil
-		task.LeaseExpiresAt = nil
-		// Reuse the existing resolution request slot. Scope a batch UUID to a
-		// task, and retain provenance without a schema change or replay cache.
-		marker := "backfill:" + source + ":" + uuid.NewSHA1(uuid.NameSpaceOID, []byte(requestID+":"+item.AddressSuffix)).String()
-		task.UnknownResolveRequestID = &marker
-		if err := tx.Save(&task).Error; err != nil {
-			return err
-		}
-		r.Result, r.Code = "backfilled", "BACKFILLED"
-		return nil
-	})
-	if err != nil {
-		r.Result, r.Code = "failed", CodeInternal
-		r.Retryable = true
-		var se *ServiceError
-		if errors.As(err, &se) {
-			r.Code, r.Retryable = se.Code, se.Retryable
-		}
-		if errors.Is(err, models.ErrPurchaseOrderNumberUsed) {
-			r.Code, r.Retryable = CodeBackfillOrderUsed, false
-		}
-		if r.Code == CodeBackfillBatchConflict || r.Code == CodeBackfillOrderConflict || r.Code == CodeBackfillOrderUsed {
-			r.Result = "conflict"
-		}
-	}
-	// Return only this device's committed facts, including on a rejected item.
-	// Never return in-memory changes from a rolled back transaction.
-	saved := task
-	readable := err == nil
-	if !readable {
-		saved = models.PurchaseTask{}
-		readable = db.Where("id = ? AND device_id = ?", taskID, deviceID).First(&saved).Error == nil
-	}
-	if readable {
-		r.Status, r.StatusVersion = saved.Status, saved.StatusVersion
-		r.PDDOrderNo, r.OrderSubmittedAt = saved.PDDOrderNo, saved.OrderSubmittedAt
-		if saved.OrderSubmittedAt != nil {
-			r.TimeSource = "existing_unknown"
-			if saved.UnknownResolveRequestID != nil {
-				if strings.HasPrefix(*saved.UnknownResolveRequestID, "backfill:page:") {
-					r.TimeSource = "page"
-				}
-				if strings.HasPrefix(*saved.UnknownResolveRequestID, "backfill:irreversible_at:") {
-					r.TimeSource = "irreversible_at"
-				}
-			}
-		}
-	}
-	return r
-}
@@ -1,25 +0,0 @@
-package purchase
-
-import (
-	"net/http"
-
-	"github.com/gin-gonic/gin"
-)
-
-func (h Handler) BackfillOrders(c *gin.Context) {
-	var req OrderBackfillRequest
-	if !decode(c, &req) {
-		return
-	}
-	s, ok := h.service(c)
-	if !ok {
-		return
-	}
-	out, err := s.BackfillOrders(c.Request.Context(), req, bearer(c.GetHeader("Authorization")))
-	if err != nil {
-		writeError(c, err)
-		return
-	}
-	c.Header("Cache-Control", "no-store")
-	c.JSON(http.StatusOK, gin.H{"data": out})
-}
@@ -1,498 +0,0 @@
-package purchase
-
-import (
-	"context"
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"reflect"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-
-	"go-admin/app/goauto/device"
-	"go-admin/app/goauto/models"
-	"go-admin/app/goauto/purchasecontract"
-
-	"github.com/gin-gonic/gin"
-	"github.com/google/uuid"
-	"gorm.io/gorm"
-)
-
-func backfillTask(t *testing.T, db *gorm.DB, f fixture, status string) models.PurchaseTask {
-	t.Helper()
-	now := testService(db).Now()
-	task := models.PurchaseTask{TaskType: models.PurchaseTaskTypeStock, ExecutionMode: models.PurchaseExecutionModeLive,
-		Status: status, DeviceID: &f.device.ID, PDDProductID: f.pdd.ID, Quantity: 1, Currency: "CNY",
-		CreateRequestID: uuid.NewString(), RuleSnapshot: string(purchasecontract.DefaultLiveRule()),
-		SpecDecisionSnapshot: `{}`, RequiredCapabilitiesJSON: `[]`, IrreversibleAt: &now,
-		ErrorCode: strptr("ORIGINAL_ERROR"), ErrorMessage: strptr("original failure")}
-	if err := db.Create(&task).Error; err != nil {
-		t.Fatal(err)
-	}
-	return task
-}
-
-func strptr(s string) *string { return &s }
-
-func backfillItem(id uint64, order string) OrderBackfillItem {
-	return OrderBackfillItem{AddressSuffix: purchasecontract.AddressSuffix(id), PDDOrderNo: order}
-}
-
-func runBackfill(t *testing.T, s *Service, token, requestID string, items ...OrderBackfillItem) []OrderBackfillResult {
-	t.Helper()
-	out, err := s.BackfillOrders(context.Background(), OrderBackfillRequest{RequestID: requestID, Items: items}, token)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(out.Items) != len(items) || out.RequestID != requestID {
-		t.Fatalf("bad envelope: %+v", out)
-	}
-	return out.Items
-}
-
-func loadBackfillTask(t *testing.T, db *gorm.DB, id uint64) models.PurchaseTask {
-	t.Helper()
-	var task models.PurchaseTask
-	if err := db.First(&task, id).Error; err != nil {
-		t.Fatal(err)
-	}
-	return task
-}
-
-func TestOrderBackfillMixedBatchAndReplay(t *testing.T) {
-	db := testDB(t)
-	f := seed(t, db, liveCaps(), true)
-	s := testService(db)
-	a := backfillTask(t, db, f, models.PurchaseTaskStatusOrderResultUnknown)
-	a.TaskType, a.SYBProductID = models.PurchaseTaskTypeSYBOrder, &f.syb.ID
-	if err := db.Save(&a).Error; err != nil {
-		t.Fatal(err)
-	}
-	b := backfillTask(t, db, f, models.PurchaseTaskStatusOrderResultUnknown)
-	c := backfillTask(t, db, f, models.PurchaseTaskStatusOrderResultUnknown)
-	if err := db.Model(&c).Update("irreversible_at", nil).Error; err != nil {
-		t.Fatal(err)
-	}
-	page := backfillItem(b.ID, "ORDER-B")
-	page.OrderSubmittedAt = strptr("2026-09-08T20:30:00+08:00")
-	rid := uuid.NewString()
-	items := []OrderBackfillItem{backfillItem(a.ID, "ORDER-A"), {AddressSuffix: "_cg0", PDDOrderNo: "bad"}, page, backfillItem(c.ID, "ORDER-C"), backfillItem(99999, "missing")}
-	results := runBackfill(t, s, f.token, rid, items...)
-	want := []string{"BACKFILLED", CodeBackfillSuffix, "BACKFILLED", CodeOrderTimeMissing, CodeTaskNotFound}
-	for i, r := range results {
-		if r.Code != want[i] || r.Index != i {
-			t.Fatalf("item %d: %+v", i, r)
-		}
-	}
-	if results[0].TimeSource != "irreversible_at" || !results[0].OrderSubmittedAt.Equal(*a.IrreversibleAt) {
-		t.Fatalf("fallback: %+v", results[0])
-	}
-	if results[2].TimeSource != "page" || results[2].OrderSubmittedAt.Format(time.RFC3339) != "2026-09-08T12:30:00Z" {
-		t.Fatalf("page: %+v", results[2])
-	}
-	saved := loadBackfillTask(t, db, a.ID)
-	if saved.StatusVersion != a.StatusVersion+1 || saved.ErrorCode != nil || saved.ErrorMessage != nil || saved.DeviceRunSlot != nil || saved.AccountRunSlot != nil || saved.ActiveSlot == nil || saved.Status != models.PurchaseTaskStatusOrderCreated {
-		t.Fatalf("state metadata: %+v", saved)
-	}
-	if saved.PaymentReviewStatus != a.PaymentReviewStatus || saved.LogisticsStatus != a.LogisticsStatus || saved.WritebackStatus != a.WritebackStatus || saved.RuleSnapshot != a.RuleSnapshot {
-		t.Fatal("unrelated business facts changed")
-	}
-	for _, replayID := range []string{rid, uuid.NewString()} {
-		item := items[0]
-		item.OrderSubmittedAt = strptr("2026-09-09T00:00:00Z")
-		r := runBackfill(t, s, f.token, replayID, item)[0]
-		if r.Result != "already_backfilled" || r.TimeSource != "irreversible_at" {
-			t.Fatalf("replay: %+v", r)
-		}
-		if got := loadBackfillTask(t, db, a.ID); !reflect.DeepEqual(saved, got) {
-			t.Fatal("replay changed persisted task")
-		}
-	}
-	if got := loadBackfillTask(t, db, c.ID); got.PDDOrderNo != nil || got.StatusVersion != c.StatusVersion {
-		t.Fatal("missing time wrote data")
-	}
-}
-
-func TestOrderBackfillRejectsOwnershipStatesAndInvalidTime(t *testing.T) {
-	db := testDB(t)
-	f := seed(t, db, liveCaps(), true)
-	s := testService(db)
-	for _, status := range []string{models.PurchaseTaskStatusPending, models.PurchaseTaskStatusRunning, models.PurchaseTaskStatusOrderSubmitStarted, models.PurchaseTaskStatusSpecProbePending, models.PurchaseTaskStatusFailed, models.PurchaseTaskStatusCancelled, models.PurchaseTaskStatusRehearsalCompleted} {
-		task := backfillTask(t, db, f, status)
-		before := loadBackfillTask(t, db, task.ID)
-		r := runBackfill(t, s, f.token, uuid.NewString(), backfillItem(task.ID, "ORDER"))[0]
-		if r.Code != CodeStateConflict {
-			t.Fatalf("%s: %+v", status, r)
-		}
-		if got := loadBackfillTask(t, db, task.ID); !reflect.DeepEqual(got, before) {
-			t.Fatal("rejection wrote data")
-		}
-		// Release the fixture's device slot before testing the next running state.
-		if err := task.SetStatus(models.PurchaseTaskStatusCancelled); err != nil {
-			t.Fatal(err)
-		}
-		if err := db.Save(&task).Error; err != nil {
-			t.Fatal(err)
-		}
-	}
-	task := backfillTask(t, db, f, models.PurchaseTaskStatusOrderResultUnknown)
-	if err := db.Model(&task).Update("device_id", nil).Error; err != nil {
-		t.Fatal(err)
-	}
-	r := runBackfill(t, s, f.token, uuid.NewString(), backfillItem(task.ID, "ORDER"))[0]
-	if r.Code != CodeBackfillDevice || r.Status != "" || r.PDDOrderNo != nil {
-		t.Fatalf("ownership leaked: %+v", r)
-	}
-	other, err := device.NewService(db).Register(context.Background(), device.RegisterRequest{RequestID: uuid.NewString(), InstallID: uuid.NewString(), Name: "Other", Manufacturer: "Test", Model: "Test", AndroidVersion: "15", AgentVersion: "1", PDDVersion: "7", Capabilities: liveCaps()}, "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := db.Model(&task).Update("device_id", other.DeviceID).Error; err != nil {
-		t.Fatal(err)
-	}
-	if r := runBackfill(t, s, f.token, uuid.NewString(), backfillItem(task.ID, "ORDER"))[0]; r.Code != CodeBackfillDevice {
-		t.Fatalf("cross device: %+v", r)
-	}
-	if err := db.Model(&task).Updates(map[string]any{"device_id": f.device.ID, "execution_mode": models.PurchaseExecutionModeRehearsal}).Error; err != nil {
-		t.Fatal(err)
-	}
-	if r := runBackfill(t, s, f.token, uuid.NewString(), backfillItem(task.ID, "ORDER"))[0]; r.Code != CodeStateConflict {
-		t.Fatalf("rehearsal: %+v", r)
-	}
-	if err := db.Model(&task).Update("execution_mode", models.PurchaseExecutionModeLive).Error; err != nil {
-		t.Fatal(err)
-	}
-	for _, raw := range []string{"", "2026-09-08 12:00:00", "0001-01-01T00:00:00Z", "garbage"} {
-		item := backfillItem(task.ID, "ORDER")
-		item.OrderSubmittedAt = &raw
-		if r := runBackfill(t, s, f.token, uuid.NewString(), item)[0]; r.Code != CodeOrderTimeInvalid {
-			t.Fatalf("invalid time: %+v", r)
-		}
-	}
-}
-
-func TestOrderBackfillConflictsNeverOverwrite(t *testing.T) {
-	db := testDB(t)
-	f := seed(t, db, liveCaps(), true)
-	s := testService(db)
-	a := backfillTask(t, db, f, models.PurchaseTaskStatusOrderResultUnknown)
-	b := backfillTask(t, db, f, models.PurchaseTaskStatusOrderResultUnknown)
-	rid := uuid.NewString()
-	r := runBackfill(t, s, f.token, rid, backfillItem(a.ID, "A"), backfillItem(a.ID, "B"), backfillItem(b.ID, "B"))
-	if r[0].Code != CodeBackfillBatchConflict || r[1].Code != CodeBackfillBatchConflict || r[2].Code != "BACKFILLED" {
-		t.Fatalf("batch: %+v", r)
-	}
-	r = runBackfill(t, s, f.token, rid, backfillItem(a.ID, "B"), backfillItem(b.ID, "C"))
-	if r[0].Code != CodeBackfillOrderUsed || r[1].Code != CodeBackfillOrderConflict {
-		t.Fatalf("changed requestId payload bypassed checks: %+v", r)
-	}
-	if got := loadBackfillTask(t, db, b.ID); *got.PDDOrderNo != "B" || got.StatusVersion != b.StatusVersion+1 {
-		t.Fatal("conflict overwrote")
-	}
-	if got := loadBackfillTask(t, db, a.ID); got.PDDOrderNo != nil {
-		t.Fatal("conflict wrote data")
-	}
-	// Even an unknown task with an existing conflicting value must preserve it.
-	a.PDDOrderNo = strptr("OLD")
-	if err := db.Save(&a).Error; err != nil {
-		t.Fatal(err)
-	}
-	if r := runBackfill(t, s, f.token, uuid.NewString(), backfillItem(a.ID, "NEW"))[0]; r.Code != CodeBackfillOrderConflict {
-		t.Fatalf("unknown existing: %+v", r)
-	}
-}
-
-func TestOrderBackfillConcurrentResolveUnknown(t *testing.T) {
-	db := testDB(t)
-	f := seed(t, db, liveCaps(), true)
-	s := testService(db)
-	// SQLite serializes transactions through one connection. These concurrent
-	// service calls verify both winner orders; they do not certify MySQL locks.
-	sqlDB, _ := db.DB()
-	sqlDB.SetMaxOpenConns(1)
-	for i := 0; i < 12; i++ {
-		task := backfillTask(t, db, f, models.PurchaseTaskStatusOrderResultUnknown)
-		start := make(chan struct{})
-		var wg sync.WaitGroup
-		wg.Add(2)
-		var out OrderBackfillResponse
-		var backErr, manualErr error
-		go func() {
-			defer wg.Done()
-			<-start
-			out, backErr = s.BackfillOrders(context.Background(), OrderBackfillRequest{RequestID: uuid.NewString(), Items: []OrderBackfillItem{backfillItem(task.ID, "BACK-"+purchasecontract.AddressSuffix(task.ID))}}, f.token)
-		}()
-		go func() {
-			defer wg.Done()
-			<-start
-			_, _, manualErr = s.ResolveUnknown(context.Background(), task.ID, ManualRequest{RequestID: uuid.NewString(), OperatorID: 1, Status: models.PurchaseTaskStatusOrderCreated, PDDOrderNo: "MANUAL-" + purchasecontract.AddressSuffix(task.ID), OrderSubmittedAt: task.IrreversibleAt})
-		}()
-		close(start)
-		wg.Wait()
-		if backErr != nil {
-			t.Fatal(backErr)
-		}
-		got := loadBackfillTask(t, db, task.ID)
-		if got.StatusVersion != task.StatusVersion+1 || got.Status != models.PurchaseTaskStatusOrderCreated {
-			t.Fatal("competing writes changed version twice")
-		}
-		if manualErr == nil {
-			if out.Items[0].Code != CodeBackfillOrderConflict || !strings.HasPrefix(*got.PDDOrderNo, "MANUAL-") {
-				t.Fatalf("manual winner: %+v", out)
-			}
-		} else if code(manualErr) != CodeStateConflict || out.Items[0].Code != "BACKFILLED" || !strings.HasPrefix(*got.PDDOrderNo, "BACK-") {
-			t.Fatalf("backfill winner: %+v %v", out, manualErr)
-		}
-	}
-}
-
-func TestOrderBackfillConcurrentLateResultAndOtherTask(t *testing.T) {
-	db := testDB(t)
-	f := seed(t, db, liveCaps(), true)
-	s := testService(db)
-	sqlDB, _ := db.DB()
-	sqlDB.SetMaxOpenConns(1)
-	a := backfillTask(t, db, f, models.PurchaseTaskStatusOrderResultUnknown)
-	attempt := models.PurchaseTaskAttempt{TaskID: a.ID, AttemptID: uuid.NewString(), AttemptNumber: 1, Phase: models.PurchaseAttemptPhasePurchase, Status: models.PurchaseAttemptStatusFailed, DeviceID: &f.device.ID, RuleSnapshotHash: purchaseRuleSnapshotHash(a.RuleSnapshot), SpecDecisionSnapshot: `{}`}
-	if err := db.Omit("Task").Create(&attempt).Error; err != nil {
-		t.Fatal(err)
-	}
-	if err := db.First(&attempt, attempt.ID).Error; err != nil {
-		t.Fatal(err)
-	}
-	start := make(chan struct{})
-	var wg sync.WaitGroup
-	wg.Add(2)
-	var out OrderBackfillResponse
-	var backErr, lateErr error
-	go func() {
-		defer wg.Done()
-		<-start
-		out, backErr = s.BackfillOrders(context.Background(), OrderBackfillRequest{RequestID: uuid.NewString(), Items: []OrderBackfillItem{backfillItem(a.ID, "BACK")}}, f.token)
-	}()
-	go func() {
-		defer wg.Done()
-		<-start
-		_, lateErr = s.SubmitResult(context.Background(), a.ID, ResultRequest{RequestID: uuid.NewString(), TaskAttemptID: attempt.AttemptID, ResultType: "order_created", PDDOrderNo: "LATE", OrderSubmittedAt: a.IrreversibleAt}, f.token)
-	}()
-	close(start)
-	wg.Wait()
-	if backErr != nil || out.Items[0].Code != "BACKFILLED" || code(lateErr) != CodeStateConflict {
-		t.Fatalf("late race: %+v %v %v", out, backErr, lateErr)
-	}
-	var savedAttempt models.PurchaseTaskAttempt
-	if err := db.First(&savedAttempt, attempt.ID).Error; err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(savedAttempt, attempt) {
-		t.Fatal("backfill rewrote attempt")
-	}
-	b := backfillTask(t, db, f, models.PurchaseTaskStatusOrderResultUnknown)
-	_, _, err := s.ResolveUnknown(context.Background(), b.ID, ManualRequest{RequestID: uuid.NewString(), OperatorID: 1, Status: models.PurchaseTaskStatusOrderCreated, PDDOrderNo: "BACK", OrderSubmittedAt: b.IrreversibleAt})
-	if err == nil {
-		t.Fatal("manual path assigned another task's order")
-	}
-	if got := loadBackfillTask(t, db, b.ID); got.PDDOrderNo != nil || got.StatusVersion != b.StatusVersion {
-		t.Fatal("other task changed on conflict")
-	}
-}
-
-func TestOrderBackfillHTTPBoundary(t *testing.T) {
-	db := testDB(t)
-	f := seed(t, db, liveCaps(), true)
-	task := backfillTask(t, db, f, models.PurchaseTaskStatusOrderResultUnknown)
-	gin.SetMode(gin.TestMode)
-	r := gin.New()
-	r.POST("/order-backfill", device.RequireAgentHTTPS(false, false), (Handler{DB: db}).BackfillOrders)
-	body, _ := json.Marshal(OrderBackfillRequest{RequestID: uuid.NewString(), Items: []OrderBackfillItem{backfillItem(task.ID, "HTTP")}})
-	for _, test := range []struct {
-		body, token string
-		status      int
-	}{
-		{string(body), "", http.StatusUnauthorized},
-		{`{"requestId":"bad","items":[]}`, f.token, http.StatusUnprocessableEntity},
-		{`{"requestId":"x","address":"forbidden"}`, f.token, http.StatusUnprocessableEntity},
-		{string(body), f.token, http.StatusOK},
-	} {
-		req := httptest.NewRequest(http.MethodPost, "/order-backfill", strings.NewReader(test.body))
-		req.Header.Set("Authorization", "Bearer "+test.token)
-		w := httptest.NewRecorder()
-		r.ServeHTTP(w, req)
-		if w.Code != test.status {
-			t.Fatalf("HTTP %d: %s", w.Code, w.Body.String())
-		}
-	}
-	_, err := testService(db).BackfillOrders(context.Background(), OrderBackfillRequest{RequestID: uuid.NewString(), Items: make([]OrderBackfillItem, 51)}, f.token)
-	if code(err) != CodeInvalidRequest {
-		t.Fatalf("batch limit: %v", err)
-	}
-}
-
-func TestOrderBackfillConcurrentSameOrderDifferentTasks(t *testing.T) {
-	db := testDB(t)
-	f := seed(t, db, liveCaps(), true)
-	s := testService(db)
-	sqlDB, _ := db.DB()
-	sqlDB.SetMaxOpenConns(1)
-	a := backfillTask(t, db, f, models.PurchaseTaskStatusOrderResultUnknown)
-	b := backfillTask(t, db, f, models.PurchaseTaskStatusOrderResultUnknown)
-	start := make(chan struct{})
-	results := make(chan OrderBackfillResponse, 2)
-	errors := make(chan error, 2)
-	for _, id := range []uint64{a.ID, b.ID} {
-		go func(id uint64) {
-			<-start
-			out, err := s.BackfillOrders(context.Background(), OrderBackfillRequest{RequestID: uuid.NewString(), Items: []OrderBackfillItem{backfillItem(id, "SAME")}}, f.token)
-			results <- out
-			errors <- err
-		}(id)
-	}
-	close(start)
-	codes := make(map[string]int)
-	for i := 0; i < 2; i++ {
-		out := <-results
-		if err := <-errors; err != nil {
-			t.Fatal(err)
-		}
-		codes[out.Items[0].Code]++
-	}
-	if codes["BACKFILLED"] != 1 || codes[CodeBackfillOrderUsed] != 1 {
-		t.Fatalf("concurrent assignments: %+v", codes)
-	}
-	var count int64
-	if err := db.Model(&models.PurchaseTask{}).Where("pdd_order_no = ?", "SAME").Count(&count).Error; err != nil || count != 1 {
-		t.Fatalf("duplicate order: %d %v", count, err)
-	}
-}
-
-func TestOrderBackfillRejectsLateAssignmentOfSameOrder(t *testing.T) {
-	db := testDB(t)
-	f := seed(t, db, liveCaps(), true)
-	s := testService(db)
-	a := backfillTask(t, db, f, models.PurchaseTaskStatusOrderResultUnknown)
-	if r := runBackfill(t, s, f.token, uuid.NewString(), backfillItem(a.ID, "SHARED"))[0]; r.Code != "BACKFILLED" {
-		t.Fatal(r)
-	}
-	b := backfillTask(t, db, f, models.PurchaseTaskStatusOrderSubmitStarted)
-	lease := s.Now().Add(time.Minute)
-	b.LeaseExpiresAt = &lease
-	if err := db.Save(&b).Error; err != nil {
-		t.Fatal(err)
-	}
-	attempt := models.PurchaseTaskAttempt{TaskID: b.ID, AttemptID: uuid.NewString(), AttemptNumber: 1, Phase: models.PurchaseAttemptPhasePurchase, Status: models.PurchaseAttemptStatusRunning, DeviceID: &f.device.ID, RuleSnapshotHash: purchaseRuleSnapshotHash(b.RuleSnapshot), SpecDecisionSnapshot: `{}`}
-	if err := db.Omit("Task").Create(&attempt).Error; err != nil {
-		t.Fatal(err)
-	}
-	req := ResultRequest{RequestID: uuid.NewString(), TaskAttemptID: attempt.AttemptID, ResultType: "order_created", PDDOrderNo: "SHARED", OrderSubmittedAt: b.IrreversibleAt}
-	out, err := s.SubmitResult(context.Background(), b.ID, req, f.token)
-	if err != nil || out.Status != models.PurchaseTaskStatusOrderResultUnknown {
-		t.Fatalf("conflicting result must commit as unknown: %+v %v", out, err)
-	}
-	got := loadBackfillTask(t, db, b.ID)
-	if got.Status != models.PurchaseTaskStatusOrderResultUnknown || got.StatusVersion != b.StatusVersion+1 || got.PDDOrderNo != nil {
-		t.Fatalf("duplicate assignment was not safely downgraded: %+v", got)
-	}
-	wantMessage := "读到订单号 SHARED，但该号已属于任务 " + taskNumber(a.ID)
-	if got.ErrorCode == nil || *got.ErrorCode != CodeOrderNumberUsed || got.ErrorMessage == nil || *got.ErrorMessage != wantMessage {
-		t.Fatalf("conflict evidence missing: %+v", got)
-	}
-	if got.OrderSubmittedAt == nil || !got.OrderSubmittedAt.Equal(*req.OrderSubmittedAt) || got.IrreversibleAt == nil || got.LeaseExpiresAt != nil || got.DeviceRunSlot != nil || got.AccountRunSlot != nil {
-		t.Fatalf("boundary evidence or released lease missing: %+v", got)
-	}
-	var saved models.PurchaseTaskAttempt
-	if err := db.First(&saved, attempt.ID).Error; err != nil {
-		t.Fatal(err)
-	}
-	if saved.Status != models.PurchaseAttemptStatusFailed || saved.ResultRequestID == nil || *saved.ResultRequestID != req.RequestID || saved.ResultHash == nil || saved.ResultType == nil || *saved.ResultType != "order_created" || saved.FinishedAt == nil || saved.ErrorCode == nil || *saved.ErrorCode != CodeOrderNumberUsed || saved.ErrorMessage == nil || *saved.ErrorMessage != wantMessage {
-		t.Fatalf("attempt result and conflict evidence missing: %+v", saved)
-	}
-	out, err = s.SubmitResult(context.Background(), b.ID, req, f.token)
-	if err != nil || !out.Replayed || out.Status != models.PurchaseTaskStatusOrderResultUnknown || loadBackfillTask(t, db, b.ID).StatusVersion != got.StatusVersion {
-		t.Fatalf("unknown result replay failed: %+v %v", out, err)
-	}
-	owner := loadBackfillTask(t, db, a.ID)
-	if owner.PDDOrderNo == nil || *owner.PDDOrderNo != "SHARED" || owner.Status != models.PurchaseTaskStatusOrderCreated {
-		t.Fatalf("existing owner changed: %+v", owner)
-	}
-	var count int64
-	if err := db.Model(&models.PurchaseTask{}).Where("pdd_order_no = ?", "SHARED").Count(&count).Error; err != nil || count != 1 {
-		t.Fatalf("duplicate order: %d %v", count, err)
-	}
-	resolved, _, err := s.ResolveUnknown(context.Background(), b.ID, ManualRequest{RequestID: uuid.NewString(), OperatorID: 1, Status: models.PurchaseTaskStatusOrderCreated, PDDOrderNo: "CORRECTED", OrderSubmittedAt: req.OrderSubmittedAt})
-	if err != nil || resolved.Status != models.PurchaseTaskStatusOrderCreated {
-		t.Fatalf("manual resolution unavailable: %+v %v", resolved, err)
-	}
-}
-
-func TestOrderBackfillHTTPTransportPolicy(t *testing.T) {
-	gin.SetMode(gin.TestMode)
-	for _, allow := range []string{"false", "true"} {
-		t.Setenv("GOAUTO_ALLOW_INSECURE_AGENT_HTTP", allow)
-		r := gin.New()
-		r.POST("/order-backfill", device.RequireAgentHTTPS(true, false), (Handler{}).BackfillOrders)
-		w := httptest.NewRecorder()
-		r.ServeHTTP(w, httptest.NewRequest(http.MethodPost, "/order-backfill", strings.NewReader(`{}`)))
-		if allow == "false" && w.Code != http.StatusUpgradeRequired {
-			t.Fatalf("HTTPS bypass: %d", w.Code)
-		}
-		if allow == "true" && w.Code == http.StatusUpgradeRequired {
-			t.Fatal("HTTP compatibility broken")
-		}
-	}
-}
-
-func TestOrderBackfillMultiConnectionResolveRace(t *testing.T) {
-	db := testDB(t)
-	f := seed(t, db, liveCaps(), true)
-	s := testService(db)
-	sqlDB, err := db.DB()
-	if err != nil {
-		t.Fatal(err)
-	}
-	sqlDB.SetMaxOpenConns(4)
-	task := backfillTask(t, db, f, models.PurchaseTaskStatusOrderResultUnknown)
-	start := make(chan struct{})
-	var wg sync.WaitGroup
-	wg.Add(2)
-	var back OrderBackfillResponse
-	var backErr, manualErr error
-	req := OrderBackfillRequest{RequestID: uuid.NewString(), Items: []OrderBackfillItem{backfillItem(task.ID, "BACK")}}
-	go func() { defer wg.Done(); <-start; back, backErr = s.BackfillOrders(context.Background(), req, f.token) }()
-	go func() {
-		defer wg.Done()
-		<-start
-		_, _, manualErr = s.ResolveUnknown(context.Background(), task.ID, ManualRequest{RequestID: uuid.NewString(), OperatorID: 1, Status: models.PurchaseTaskStatusOrderCreated, PDDOrderNo: "MANUAL", OrderSubmittedAt: task.IrreversibleAt})
-	}()
-	close(start)
-	wg.Wait()
-	// SQLite returns table-lock errors rather than waiting on FOR UPDATE.
-	// Only that documented DB contention or a domain conflict is acceptable;
-	// after the competing calls finish, replay must converge without overwrite.
-	if backErr != nil && !strings.Contains(backErr.Error(), "locked") {
-		t.Fatal(backErr)
-	}
-	if manualErr != nil && code(manualErr) != CodeStateConflict && !strings.Contains(manualErr.Error(), "locked") {
-		t.Fatal(manualErr)
-	}
-	if backErr == nil && back.Items[0].Code != "BACKFILLED" && back.Items[0].Code != CodeBackfillOrderConflict && !(back.Items[0].Code == CodeInternal && back.Items[0].Retryable) {
-		t.Fatalf("unexpected race result: %+v", back)
-	}
-	before := loadBackfillTask(t, db, task.ID)
-	replay := runBackfill(t, s, f.token, req.RequestID, req.Items...)[0]
-	after := loadBackfillTask(t, db, task.ID)
-	if before.PDDOrderNo != nil && !reflect.DeepEqual(before, after) {
-		t.Fatal("replay overwrote the concurrent winner")
-	}
-	if after.StatusVersion != task.StatusVersion+1 || after.Status != models.PurchaseTaskStatusOrderCreated {
-		t.Fatal("race did not converge to a single transition")
-	}
-	if manualErr == nil {
-		if *after.PDDOrderNo != "MANUAL" || replay.Code != CodeBackfillOrderConflict {
-			t.Fatal("manual winner overwritten")
-		}
-	} else if *after.PDDOrderNo != "BACK" || (replay.Code != "BACKFILLED" && replay.Code != "ALREADY_BACKFILLED") {
-		t.Fatalf("backfill did not converge: %+v", replay)
-	}
-}
@@ -1,74 +0,0 @@
-package purchase
-
-import (
-	"context"
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-	"time"
-
-	"go-admin/app/goauto/models"
-
-	"github.com/gin-gonic/gin"
-	"github.com/google/uuid"
-	"gorm.io/gorm"
-)
-
-func TestOrderNumberConflictBusinessErrors(t *testing.T) {
-	for _, path := range []string{"resolve_unknown", "cancel", "lifecycle"} {
-		t.Run(path, func(t *testing.T) {
-			db := testDB(t)
-			f := seed(t, db, liveCaps(), true)
-			s := testService(db)
-			owner := backfillTask(t, db, f, models.PurchaseTaskStatusOrderResultUnknown)
-			if r := runBackfill(t, s, f.token, uuid.NewString(), backfillItem(owner.ID, "SHARED"))[0]; r.Code != "BACKFILLED" {
-				t.Fatal(r)
-			}
-			status := models.PurchaseTaskStatusOrderResultUnknown
-			if path == "lifecycle" {
-				status = models.PurchaseTaskStatusRunning
-			}
-			task := backfillTask(t, db, f, status)
-			if path != "resolve_unknown" {
-				// Model legacy duplicate data predating the global save guard.
-				if err := db.Session(&gorm.Session{SkipHooks: true}).Model(&models.PurchaseTask{}).Where("id = ?", task.ID).Updates(map[string]any{"pdd_order_no": "SHARED", "lease_expires_at": s.Now().Add(time.Minute)}).Error; err != nil {
-					t.Fatal(err)
-				}
-			}
-			req := ManualRequest{RequestID: uuid.NewString(), OperatorID: 1, Status: models.PurchaseTaskStatusOrderCreated, PDDOrderNo: "SHARED", OrderSubmittedAt: task.IrreversibleAt, Reason: "人工取消"}
-			var err error
-			switch path {
-			case "resolve_unknown":
-				_, _, err = s.ResolveUnknown(context.Background(), task.ID, req)
-			case "cancel":
-				_, _, err = s.Cancel(context.Background(), task.ID, req)
-			case "lifecycle":
-				attempt := models.PurchaseTaskAttempt{TaskID: task.ID, AttemptID: uuid.NewString(), AttemptNumber: 1, Phase: models.PurchaseAttemptPhasePurchase, Status: models.PurchaseAttemptStatusRunning, DeviceID: &f.device.ID, RuleSnapshotHash: purchaseRuleSnapshotHash(task.RuleSnapshot), SpecDecisionSnapshot: `{}`}
-				if e := db.Omit("Task").Create(&attempt).Error; e != nil {
-					t.Fatal(e)
-				}
-				_, err = s.MarkOrderSubmitStarted(context.Background(), task.ID, ActionRequest{RequestID: req.RequestID}, f.token)
-			}
-			want := "订单号已属于任务 " + taskNumber(owner.ID)
-			if code(err) != CodeOrderNumberUsed || err.Error() != want {
-				t.Fatalf("unmapped conflict: %v", err)
-			}
-			w := httptest.NewRecorder()
-			c, _ := gin.CreateTestContext(w)
-			writeError(c, err)
-			var body struct {
-				Code      string `json:"code"`
-				Message   string `json:"message"`
-				Retryable bool   `json:"retryable"`
-			}
-			if e := json.Unmarshal(w.Body.Bytes(), &body); e != nil || w.Code != http.StatusConflict || body.Code != CodeOrderNumberUsed || body.Message != want || body.Retryable {
-				t.Fatalf("unexpected HTTP error: %d %s (%v)", w.Code, w.Body.String(), e)
-			}
-			got := loadBackfillTask(t, db, task.ID)
-			if got.Status != status || got.StatusVersion != task.StatusVersion || got.UnknownResolveRequestID != nil || got.CancelRequestID != nil || got.OrderSubmitRequestID != nil {
-				t.Fatalf("rejected mutation persisted: %+v", got)
-			}
-		})
-	}
-}
@@ -18,7 +18,6 @@ func InitRouter(engine *gin.Engine, auth *jwt.GinJWTMiddleware) {
 	agent := engine.Group("/api/agent/v1/purchase-tasks").Use(device.RequireAgentHTTPS(config.ApplicationConfig.Mode == "prod", trust))
 	agent.GET("", h.AgentHistory)
 	agent.GET("/next", h.Next)
-	agent.POST("/order-backfill", h.BackfillOrders)
 	agent.GET("/:taskId", h.AgentHistoryDetail)
 	agent.POST("/:taskId/retry", h.AgentRetry)
 	agent.POST("/:taskId/reset", h.AgentReset)
@@ -22,7 +22,6 @@ const (
 	CodeRetryStale          = "PURCHASE_RETRY_STALE"
 	CodeSpecReprobeRejected = "PURCHASE_SPEC_REPROBE_REJECTED"
 	CodeOrderResultUnknown  = "PURCHASE_ORDER_RESULT_UNKNOWN"
-	CodeOrderNumberUsed     = "PURCHASE_ORDER_NUMBER_ALREADY_USED"
 	CodeOrderEmptyTimeout   = "PURCHASE_ORDER_EMPTY_TIMEOUT"
 	CodeOrderChooserBack    = "PURCHASE_ORDER_CHOOSER_BACK_FAILED"
 	CodeOrderWechatRestore  = "PURCHASE_ORDER_WECHAT_RESTORE_FAILED"
@@ -1,17 +0,0 @@
-package purchasecontract
-
-import "testing"
-
-func TestParseAddressSuffix(t *testing.T) {
-	for _, id := range []uint64{7, 72, ^uint64(0)} {
-		got, err := ParseAddressSuffix(AddressSuffix(id))
-		if err != nil || got != id {
-			t.Fatalf("id=%d got=%d err=%v", id, got, err)
-		}
-	}
-	for _, raw := range []string{"", "_cg", "_cg0", "_cg00", "_cg07", "_cg+7", "_cg-7", "_cg18446744073709551616", "_CG7", "_cg7x", "_cg7_cg72", "address_cg7", " _cg7", "_cg7 ", "_cg７", "_cg7\n"} {
-		if id, err := ParseAddressSuffix(raw); err == nil || id != 0 {
-			t.Errorf("accepted %q: %d", raw, id)
-		}
-	}
-}
@@ -9,7 +9,6 @@ import (
 	"math"
 	"regexp"
 	"sort"
-	"strconv"
 	"strings"
 	"unicode/utf8"
 )
@@ -361,18 +360,6 @@ func RequiredCapabilities(rule RuleSnapshot) []string {

 func AddressSuffix(taskID uint64) string { return fmt.Sprintf("_cg%d", taskID) }

-// ParseAddressSuffix accepts only the exact canonical suffix, never an address.
-func ParseAddressSuffix(suffix string) (uint64, error) {
-	if !strings.HasPrefix(suffix, "_cg") {
-		return 0, errors.New("invalid address suffix")
-	}
-	id, err := strconv.ParseUint(strings.TrimPrefix(suffix, "_cg"), 10, 64)
-	if err != nil || id == 0 || AddressSuffix(id) != suffix {
-		return 0, errors.New("invalid address suffix")
-	}
-	return id, nil
-}
-
 func ensureEOF(decoder *json.Decoder) error {
 	var extra any
 	if err := decoder.Decode(&extra); err != io.EOF {
@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"strings"
+	"time"

 	"go-admin/app/goauto/aimatching"
 	"go-admin/app/goauto/models"
@@ -48,7 +49,20 @@ type autoMatchRef struct {
 // before the transaction; the transaction rechecks the complete spec context
 // and PDD candidate set so a stale decision can never be written.
 func (service *Service) AutoMatchMappings(ctx context.Context, id uint64, request AutoMatchRequest) (AutoMatchResponse, error) {
-	ctx, cancel := context.WithTimeout(ctx, aimatching.MaxProviderTimeout)
+	started := time.Now()
+	// Bound the initial settings lookup too. This budget is specific to this
+	// composite endpoint; other AI operations retain their existing limits.
+	ctx, cancel := context.WithTimeout(ctx, 1210*time.Second)
+	defer cancel()
+	seconds, err := service.autoMatchTimeout(ctx)
+	if err != nil {
+		return AutoMatchResponse{}, err
+	}
+	return service.autoMatchMappings(ctx, id, request, time.Duration(seconds)*time.Second-time.Since(started))
+}
+
+func (service *Service) autoMatchMappings(ctx context.Context, id uint64, request AutoMatchRequest, budget time.Duration) (AutoMatchResponse, error) {
+	ctx, cancel := context.WithTimeout(ctx, budget)
 	defer cancel()

 	requestID := strings.TrimSpace(request.RequestID)
@@ -248,6 +262,21 @@ func (service *Service) AutoMatchMappings(ctx context.Context, id uint64, reques
 	return response, nil
 }

+func autoMatchBudgetSeconds(providerSeconds int) int {
+	if providerSeconds < 3 || providerSeconds > 600 {
+		providerSeconds = 15 // same default as AI settings; never allow unbounded waits
+	}
+	return providerSeconds*2 + 10
+}
+
+func (service *Service) autoMatchTimeout(ctx context.Context) (int, error) {
+	settings, err := aimatching.NewService(service.DB).Settings(ctx)
+	if err != nil {
+		return 0, internalError(err)
+	}
+	return autoMatchBudgetSeconds(settings.TimeoutSeconds), nil
+}
+
 func autoMatchRefs(specs []SpecDimension, role string) []autoMatchRef {
 	refs := make([]autoMatchRef, 0)
 	for _, dimension := range specs {
@@ -10,6 +10,7 @@ import (
 	"strings"
 	"time"

+	"go-admin/app/goauto/aimatching"
 	"go-admin/app/goauto/models"

 	"github.com/google/uuid"
@@ -166,7 +167,7 @@ func (service *Service) ProcessAutoMatchRun(ctx context.Context, runID uint64) e
 		}
 		processed++
 		service.renewAutoMatchRun(run)
-		response, matchErr := service.AutoMatchMappings(ctx, product.ID, AutoMatchRequest{RequestID: uuid.NewString(), SpecContextVersion: fingerprint[:64]})
+		response, matchErr := service.autoMatchMappings(ctx, product.ID, AutoMatchRequest{RequestID: uuid.NewString(), SpecContextVersion: fingerprint[:64]}, aimatching.MaxProviderTimeout)
 		// fingerprint begins with the 64-character context version.
 		postFingerprint := fingerprint
 		if next, _, nextErr := service.autoMatchEligibility(ctx, product); nextErr == nil && next != "" {
@@ -0,0 +1,91 @@
+package shopeeproduct
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+)
+
+func TestAutoMatchBudgetFollowsProviderSetting(t *testing.T) {
+	for _, tc := range []struct{ ai, total int }{{3, 16}, {60, 130}, {180, 370}, {600, 1210}, {0, 40}, {601, 40}} {
+		if got := autoMatchBudgetSeconds(tc.ai); got != tc.total {
+			t.Fatalf("AI %d: got %d want %d", tc.ai, got, tc.total)
+		}
+	}
+	db := openTestDB(t)
+	setting := seedEnabledAISetting(t, "https://example.invalid", 0.9)
+	setting.TimeoutSeconds = 60
+	if err := db.Create(&setting).Error; err != nil {
+		t.Fatal(err)
+	}
+	s := NewService(db)
+	created, err := s.Create(context.Background(), CreateRequest{RequestID: uuid.NewString(), ShopeeItemID: "budget-test"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	detail, err := s.DetailWithAutoMatchBudget(context.Background(), created.Product.ID)
+	if err != nil || detail.AutoMatchTimeoutSeconds != 130 {
+		t.Fatalf("budget detail: %d %v", detail.AutoMatchTimeoutSeconds, err)
+	}
+	body, _ := json.Marshal(detail)
+	if strings.Contains(string(body), "apiKey") || strings.Contains(string(body), "example.invalid") {
+		t.Fatal("AI configuration leaked")
+	}
+	if err := db.Model(&setting).Update("timeout_seconds", 180).Error; err != nil {
+		t.Fatal(err)
+	}
+	detail, err = s.DetailWithAutoMatchBudget(context.Background(), created.Product.ID)
+	if err != nil || detail.AutoMatchTimeoutSeconds != 370 {
+		t.Fatalf("fresh budget: %d %v", detail.AutoMatchTimeoutSeconds, err)
+	}
+}
+
+func TestAutoMatchCompositeBudgetCancelsWithoutSaving(t *testing.T) {
+	var calls atomic.Int32
+	responder := chatCompletionResponder(`{"suggestions":[{"sourceId":"s1","candidateId":"c1","confidence":0.96,"reason":"unique match"}]}`)
+	provider := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if calls.Add(1) == 1 {
+			responder(w, r)
+			return
+		}
+		select {
+		case <-r.Context().Done():
+		case <-time.After(time.Second):
+		}
+	}))
+	defer provider.Close()
+	db := openTestDB(t)
+	pdd := seedPDDProduct(t, db, "active")
+	setting := seedEnabledAISetting(t, provider.URL, 0.9)
+	if err := db.Create(&setting).Error; err != nil {
+		t.Fatal(err)
+	}
+	s := NewService(db)
+	created, err := s.Create(context.Background(), CreateRequest{RequestID: uuid.NewString(), ShopeeItemID: "budget-cancel", PDDProductID: &pdd.ID,
+		Specs: []SpecDimension{{Name: "颜色", Role: RoleColor, Values: []SpecValue{{Name: "深黑", Source: ValueSourceImport}}}, {Name: "尺码", Role: RoleSize, Values: []SpecValue{{Name: "加大码", Source: ValueSourceImport}}}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	started := time.Now()
+	_, err = s.autoMatchMappings(context.Background(), created.Product.ID, AutoMatchRequest{RequestID: uuid.NewString(), SpecContextVersion: created.Product.SpecContextVersion}, 100*time.Millisecond)
+	if err == nil || time.Since(started) > time.Second {
+		t.Fatalf("budget not enforced: %v", err)
+	}
+	if calls.Load() != 2 {
+		t.Fatalf("expected sequential color and size calls, got %d", calls.Load())
+	}
+	detail, err := s.Detail(context.Background(), created.Product.ID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if detail.Product.Specs[0].Values[0].Mapping != nil {
+		t.Fatal("timed-out operation saved mappings")
+	}
+}
@@ -64,7 +64,7 @@ func (handler Handler) Detail(c *gin.Context) {
 	if !ok {
 		return
 	}
-	response, err := service.Detail(c.Request.Context(), id)
+	response, err := service.DetailWithAutoMatchBudget(c.Request.Context(), id)
 	respond(c, response, err)
 }

@@ -76,8 +76,9 @@ type ProductView struct {
 }

 type SaveResponse struct {
-	Product  ProductView `json:"product"`
-	Replayed bool        `json:"replayed,omitempty"`
+	Product                 ProductView `json:"product"`
+	Replayed                bool        `json:"replayed,omitempty"`
+	AutoMatchTimeoutSeconds int         `json:"autoMatchTimeoutSeconds,omitempty"`
 }

 type ListItemView struct {
@@ -156,6 +157,16 @@ func (service *Service) Create(ctx context.Context, request CreateRequest) (Save
 	return SaveResponse{Product: view}, err
 }

+// DetailWithAutoMatchBudget exposes only a derived time budget, never AI settings.
+func (service *Service) DetailWithAutoMatchBudget(ctx context.Context, id uint64) (SaveResponse, error) {
+	response, err := service.Detail(ctx, id)
+	if err != nil {
+		return SaveResponse{}, err
+	}
+	response.AutoMatchTimeoutSeconds, err = service.autoMatchTimeout(ctx)
+	return response, err
+}
+
 // ---------------------------------------------------------------- update (archive fields only)

 type UpdateRequest struct {
@@ -8,8 +8,8 @@ export function createShopeeProduct(data) {
  return request({ url: '/api/admin/v1/shopee-products', method: 'post', data })
 }

-export function getShopeeProduct(productId) {
-  return request({ url: `/api/admin/v1/shopee-products/${productId}`, method: 'get' })
+export function getShopeeProduct(productId, options = {}) {
+  return request({ url: `/api/admin/v1/shopee-products/${productId}`, method: 'get', ...options })
 }

 export function updateShopeeProduct(productId, data) {
@@ -66,8 +66,11 @@ export function suggestShopeeSizeMappings(productId, data) {
  return request({ url: `/api/admin/v1/shopee-products/${productId}/specs/mapping/suggest-sizes`, method: 'post', data, timeout: aiSuggestTimeoutMs })
 }

-export function autoMatchShopeeSpecMappings(productId, data) {
-  return request({ url: `/api/admin/v1/shopee-products/${productId}/specs/mapping/auto-match`, method: 'post', data, timeout: aiSuggestTimeoutMs })
+export function autoMatchShopeeSpecMappings(productId, data, timeoutSeconds) {
+  if (!Number.isInteger(timeoutSeconds) || timeoutSeconds < 16 || timeoutSeconds > 1210) {
+    return Promise.reject(new Error('匹配等待时间不可用，请刷新页面后重试'))
+  }
+  return request({ url: `/api/admin/v1/shopee-products/${productId}/specs/mapping/auto-match`, method: 'post', data, timeout: (timeoutSeconds + 10) * 1000, suppressErrorMessage: true })
 }

 export function startShopeeSpecAutoMatchRun(data) {
@@ -13,8 +13,8 @@
        <template #default><el-button link type="primary" @click="reload">重新加载</el-button></template>
      </el-alert>
      <template v-if="detail.product">
-        <div class="drawer-actions"><el-tag :type="mappingMeta(detail.product).type">{{ mappingMeta(detail.product).label }}</el-tag><el-button type="primary" @click="openEdit">编辑档案</el-button></div>
-        <el-descriptions :column="2" border>
+        <div class="drawer-actions"><el-tag :type="mappingMeta(detail.product).type">{{ mappingMeta(detail.product).label }}</el-tag><el-button type="primary" :disabled="detail.aiMatching" @click="openEdit">编辑档案</el-button></div>
+        <el-descriptions :column="2" border :inert="detail.aiMatching">
          <el-descriptions-item label="虾皮商品ID">{{ detail.product.shopeeItemId }}</el-descriptions-item>
          <el-descriptions-item label="店铺">{{ detail.product.shopName || '未填写' }}</el-descriptions-item>
          <el-descriptions-item label="标题" :span="2">{{ detail.product.title || '未填写' }}</el-descriptions-item>
@@ -27,7 +27,10 @@
        <el-alert title="成功匹配会直接保存并可用于采购；未通过置信度或候选校验的项目保持未匹配。不会修改蝦皮或 PDD 的原始颜色和尺码。" type="info" :closable="false" show-icon class="notice" />
        <el-alert v-if="!detail.product.pddProductId" title="请先关联 PDD 商品，再进行规格匹配。" type="warning" :closable="false" show-icon class="notice" />
        <el-alert v-else-if="detail.pddLoaded && !pddSpecValues('color').length && !pddSpecValues('size').length" title="关联的 PDD 商品暂无可用规格，请先完成商品采集。" type="warning" :closable="false" show-icon class="notice" />
-        <el-tabs v-model="detail.activeSpecTab" class="mapping-tabs">
+        <el-alert v-if="detail.matchMessage" :title="detail.matchMessage" :type="detail.matchMessageType" :closable="false" show-icon class="notice" role="status" aria-live="polite">
+          <template #default><el-button v-if="!detail.aiMatching" link type="primary" @click="reload">刷新查看</el-button></template>
+        </el-alert>
+        <el-tabs v-model="detail.activeSpecTab" class="mapping-tabs" :inert="detail.aiMatching">
          <el-tab-pane label="颜色匹配" name="color">
            <el-empty v-if="!specRows('color').length" description="虾皮商品暂无颜色规格" />
            <el-table v-else :data="specRows('color')" :row-class-name="mappingRowClass" border size="small">
@@ -48,10 +51,10 @@
          </el-tab-pane>
        </el-tabs>
        <div class="section-heading"><h3>添加规格值</h3></div>
-        <div class="quick-row"><span class="quick-label">维度</span><el-select v-model="addValueForm.role" size="small" style="width:110px"><el-option label="颜色" value="color" /><el-option label="尺码" value="size" /><el-option label="其他" value="other" /></el-select><el-input v-model="addValueForm.dimension" size="small" placeholder="维度名称，如 颜色 / 尺码" style="width:160px" /><el-input v-model="addValueForm.name" size="small" placeholder="规格值名称" style="width:160px" /><el-button size="small" type="primary" @click="submitAddValue">+ 添加规格值</el-button></div>
+        <div class="quick-row" :inert="detail.aiMatching"><span class="quick-label">维度</span><el-select v-model="addValueForm.role" size="small" style="width:110px"><el-option label="颜色" value="color" /><el-option label="尺码" value="size" /><el-option label="其他" value="other" /></el-select><el-input v-model="addValueForm.dimension" size="small" placeholder="维度名称，如 颜色 / 尺码" style="width:160px" /><el-input v-model="addValueForm.name" size="small" placeholder="规格值名称" style="width:160px" /><el-button size="small" type="primary" @click="submitAddValue">+ 添加规格值</el-button></div>
      </template>
    </div>
-    <template #footer><el-button @click="closeDetail">关闭</el-button><el-button type="primary" :loading="detail.saving" :disabled="!hasMappingChanges" @click="saveAllMappings">保存修改</el-button></template>
+    <template #footer><el-button @click="closeDetail">关闭</el-button><el-button type="primary" :loading="detail.saving" :disabled="detail.aiMatching || !hasMappingChanges" @click="saveAllMappings">保存修改</el-button></template>
  </el-drawer>

  <el-dialog v-model="pddPicker.open" title="搜索并选择 PDD 商品" width="860px" append-to-body :close-on-click-modal="false">
@@ -95,7 +98,7 @@ export default {
  emits: ['update:modelValue', 'product-updated', 'mapping-updated', 'pdd-linked', 'purchase-created', 'switch-cancelled'],
  data() {
    return {
-      detailDrawerOpen: false, detail: this.emptyDetail(), loadError: '', requestGeneration: 0, loadedProductId: null,
+      detailDrawerOpen: false, detail: this.emptyDetail(), loadError: '', requestGeneration: 0, loadedProductId: null, matchOperation: 0,
      pddPicker: { open: false, loading: false, keyword: '', items: [] }, pddDetail: { open: false, productId: null },
      edit: { open: false, saving: false, productId: null }, editData: { title: '', shopName: '', imageUrl: '', salePriceCent: null },
      addValueForm: { dimension: '', role: 'other', name: '' }
@@ -105,7 +108,7 @@ export default {
    allSpecRows() { return this.detail.product ? this.detail.product.specs.flatMap(d => d.values) : [] },
    hasMappingChanges() { return this.allSpecRows.some(row => (row.pddValueDraft || '') !== (row.originalPddValue || '')) },
    mappingProgressText() { const rows = this.allSpecRows.filter(row => row.role === 'color' || row.role === 'size'); const valid = rows.filter(row => row.pddValueDraft && this.pddValueExists(row.role, row.pddValueDraft)).length; return rows.length ? `${valid}/${rows.length} 已匹配` : '暂无可匹配规格' },
-    canAutoMatch() { return this.detail.pddLoaded && !this.hasMappingChanges && ['color', 'size'].some(role => this.specRows(role).length > 0 && this.pddSpecValues(role).length > 0) }
+    canAutoMatch() { return !this.detail.aiMatching && !this.detail.loading && !this.detail.saving && !this.edit.open && !this.pddPicker.open && !this.pddDetail.open && this.detail.pddLoaded && !this.hasMappingChanges && ['color', 'size'].some(role => this.specRows(role).length > 0 && this.pddSpecValues(role).length > 0) }
  },
  watch: {
    modelValue: { immediate: true, handler(open) { if (open) this.requestSwitch(this.productId); else this.closeInternals() } },
@@ -114,17 +117,17 @@ export default {
    action(value) { if (value === 'link_pdd' && this.detail.product && !this.pddPicker.open) this.openPddPicker() }
  },
  methods: {
-    emptyDetail() { return { loading: false, saving: false, aiMatching: false, product: null, pddProduct: null, pddLoaded: false, activeSpecTab: 'color', highlightColor: '' } },
+    emptyDetail() { return { loading: false, saving: false, aiMatching: false, matchMessage: '', matchMessageType: 'info', product: null, pddProduct: null, pddLoaded: false, activeSpecTab: 'color', highlightColor: '' } },
    validProductId(id) { return Number.isInteger(Number(id)) && Number(id) > 0 },
-    isCurrent(generation, id) { return this.modelValue && generation === this.requestGeneration && Number(this.productId) === Number(id) },
+    isCurrent(generation, id) { return this.modelValue && this.detailDrawerOpen && generation === this.requestGeneration && Number(this.productId) === Number(id) },
    async confirmDiscard() { if (!this.hasMappingChanges) return true; return this.$confirm('当前有未保存的规格匹配，确定放弃吗？', '放弃修改？', { type: 'warning', confirmButtonText: '放弃修改', cancelButtonText: '继续编辑' }).then(() => true).catch(() => false) },
    async requestSwitch(id) {
      if (!this.validProductId(id)) { this.loadError = '虾皮商品编号无效'; this.detailDrawerOpen = true; return }
-      if (this.loadedProductId === Number(id) && this.detail.product) { this.detailDrawerOpen = true; return }
      if (this.detail.product && !await this.confirmDiscard()) { this.$emit('switch-cancelled', this.loadedProductId); return }
      await this.loadProduct(Number(id))
    },
    async loadProduct(id) {
+      this.finishMatchView()
      const generation = ++this.requestGeneration
      this.loadedProductId = null; this.detailDrawerOpen = true; this.detail = { ...this.emptyDetail(), loading: true, highlightColor: String(this.targetColor || '').trim() }; this.loadError = ''; this.pddPicker.open = false; this.pddDetail.open = false
      try {
@@ -138,13 +141,14 @@ export default {
        this.loadError = error?.response?.data?.message || error?.response?.data?.msg || '虾皮商品详情加载失败，请稍后重试'
      } finally { if (this.isCurrent(generation, id)) this.detail.loading = false }
    },
-    reload() { return this.loadProduct(Number(this.productId)) },
-    closeInternals() { this.requestGeneration++; this.detailDrawerOpen = false; this.pddPicker.open = false; this.pddDetail.open = false; this.edit.open = false },
-    async beforeCloseDetail(done) { if (this.pddDetail.open) return; if (!await this.confirmDiscard()) return; done(); this.requestGeneration++; this.$emit('update:modelValue', false) },
+    async reload() { if (this.detail.aiMatching || !await this.confirmDiscard()) return; return this.loadProduct(Number(this.productId)) },
+    finishMatchView() { this.matchOperation++; this.detail.aiMatching = false; this.detail.matchMessage = '' },
+    closeInternals() { this.finishMatchView(); this.requestGeneration++; this.detailDrawerOpen = false; this.pddPicker.open = false; this.pddDetail.open = false; this.edit.open = false },
+    async beforeCloseDetail(done) { if (this.pddDetail.open) return; if (!await this.confirmDiscard()) return; this.finishMatchView(); done(); this.requestGeneration++; this.$emit('update:modelValue', false) },
    closeDetail() { this.beforeCloseDetail(() => { this.detailDrawerOpen = false }) },
    withDraftMappings(product) { return { ...product, specs: (product.specs || []).map(d => ({ ...d, values: d.values.map(v => ({ ...v, dimensionName: d.name, role: d.role, pddValueDraft: v.mapping ? v.mapping.pddValue : '', originalPddValue: v.mapping ? v.mapping.pddValue : '', draftSource: v.mapping ? v.mapping.source : 'manual', previewReason: '', draftConfidence: null })) })) } },
    async loadLinkedPdd(pddId, generation = this.requestGeneration, productId = this.loadedProductId) { this.detail.pddLoaded = false; this.detail.pddProduct = null; try { const r = await getPddProduct(pddId); if (!this.isCurrent(generation, productId)) return; this.detail.pddProduct = r.data.product } finally { if (this.isCurrent(generation, productId)) this.detail.pddLoaded = true } },
-    async refreshDetail(eventName = 'mapping-updated') { const id = this.loadedProductId; const generation = this.requestGeneration; const r = await getShopeeProduct(id); if (!this.isCurrent(generation, id)) return; this.detail.product = this.withDraftMappings(r.data.product); if (this.detail.product.pddProductId) await this.loadLinkedPdd(this.detail.product.pddProductId, generation, id); this.$emit(eventName, { id, product: this.detail.product }) },
+    async refreshDetail(eventName = 'mapping-updated') { const id = this.loadedProductId; const generation = this.requestGeneration; const r = await getShopeeProduct(id, { suppressErrorMessage: this.detail.aiMatching }); if (!this.isCurrent(generation, id)) return; this.detail.product = this.withDraftMappings(r.data.product); if (this.detail.product.pddProductId) await this.loadLinkedPdd(this.detail.product.pddProductId, generation, id); if (this.isCurrent(generation, id)) this.$emit(eventName, { id, product: this.detail.product }) },
    priceText(row) { if (row.salePriceCent === null || row.salePriceCent === undefined) return '—'; return `${row.currency || ''} ${(row.salePriceCent / 100).toFixed(2)}` },
    mappingMeta(product) { if (!product) return { label: '-', type: 'info' }; if (!product.pddProductId) return { label: '未关联 PDD 商品', type: 'info' }; const values = (product.specs || []).flatMap(d => d.values); if (!values.length) return { label: '待完善', type: 'warning' }; const confirmed = values.filter(v => v.mapping && v.mapping.status === 'confirmed' && (!this.detail.pddLoaded || this.pddValueExists(v.role || '', v.mapping.pddValue))).length; return confirmed === values.length ? { label: '可采购', type: 'success' } : { label: `待完善 · ${confirmed}/${values.length} 已确认`, type: 'warning' } },
    openPddPicker() { this.pddPicker = { open: true, loading: false, keyword: '', items: [] }; this.searchPddPicker() },
@@ -161,7 +165,60 @@ export default {
    markManual(row) { row.draftSource = 'manual'; row.previewReason = ''; row.draftConfidence = null },
    clearDraft(row) { row.pddValueDraft = ''; row.draftSource = 'manual'; row.previewReason = ''; row.draftConfidence = null },
    mappingRowClass({ row }) { return this.detail.highlightColor && row.role === 'color' && row.name === this.detail.highlightColor ? 'mapping-row-highlight' : '' },
-    async autoMatchMappings() { const id = this.loadedProductId; const generation = this.requestGeneration; this.detail.aiMatching = true; try { const r = await autoMatchShopeeSpecMappings(id, { requestId: createRequestId(), specContextVersion: this.detail.product.specContextVersion }); if (!this.isCurrent(generation, id)) return; const confirmed = Number(r.data.confirmedCount || 0); const preserved = Number(r.data.preservedCount || 0); const unmatched = Number(r.data.unmatchedCount || 0); await this.refreshDetail(); const message = `新匹配并确认 ${confirmed} 项，保留已确认 ${preserved} 项，未匹配 ${unmatched} 项`; if (unmatched > 0) ElMessage.warning(message); else ElMessage.success(message) } finally { if (this.isCurrent(generation, id)) this.detail.aiMatching = false } },
+    async autoMatchMappings() {
+      if (!this.canAutoMatch) return
+      const id = this.loadedProductId
+      const generation = this.requestGeneration
+      const operation = ++this.matchOperation
+      const current = () => this.isCurrent(generation, id) && operation === this.matchOperation
+      this.detail.aiMatching = true
+      this.detail.matchMessage = '正在读取最新规格与等待时间'
+      this.detail.matchMessageType = 'info'
+      let submitted = false
+      let received = false
+      try {
+        const prepared = await getShopeeProduct(id, { suppressErrorMessage: true })
+        if (!current()) return
+        const seconds = prepared.data.autoMatchTimeoutSeconds
+        if (!Number.isInteger(seconds) || seconds < 16 || seconds > 1210) throw new Error('匹配等待时间不可用，请确认服务端已更新后刷新重试')
+        this.detail.product = this.withDraftMappings(prepared.data.product)
+        this.detail.matchMessage = `正在匹配并保存，最多等待 ${seconds + 10} 秒`
+        submitted = true
+        const r = await autoMatchShopeeSpecMappings(id, { requestId: createRequestId(), specContextVersion: prepared.data.product.specContextVersion }, seconds)
+        if (!current()) return
+        received = true
+        this.detail.matchMessage = '匹配请求已完成，正在读取保存结果'
+        await this.refreshDetail()
+        if (!current()) return
+        const unmatched = Number(r.data.unmatchedCount || 0)
+        const message = `新匹配并确认 ${Number(r.data.confirmedCount || 0)} 项，保留已确认 ${Number(r.data.preservedCount || 0)} 项，未匹配 ${unmatched} 项`
+        this.detail.matchMessage = message
+        this.detail.matchMessageType = unmatched ? 'warning' : 'success'
+        if (unmatched) ElMessage.warning(message); else ElMessage.success(message)
+      } catch (error) {
+        if (!current()) return
+        this.detail.matchMessageType = 'warning'
+        if (!submitted) {
+          this.detail.matchMessage = error?.message || '读取匹配设置失败，请刷新后重试'
+          return
+        }
+        // A lost response is not proof of a rollback. Read once, never retry POST.
+        if (received) {
+          this.detail.matchMessage = '匹配请求已完成，但结果暂未确认，请刷新查看'
+          return
+        }
+        this.detail.matchMessage = '匹配请求超时或未正常返回，正在核对保存结果'
+        try {
+          await this.refreshDetail()
+          if (!current()) return
+          this.detail.matchMessage = '已刷新当前保存结果；原请求未正常返回，请检查未匹配项后再操作'
+        } catch {
+          if (current()) this.detail.matchMessage = '结果暂未确认，请刷新查看；不要重复提交匹配'
+        }
+      } finally {
+        if (current()) this.detail.aiMatching = false
+      }
+    },
    async confirmPendingMapping(row) { await confirmShopeeSpecMapping(this.loadedProductId, { requestId: createRequestId(), dimension: row.dimensionName, valueName: row.name }); await this.refreshDetail() },
    async saveAllMappings() { const changes = this.allSpecRows.filter(row => (row.pddValueDraft || '') !== (row.originalPddValue || '')); if (!changes.length) return; const invalid = changes.find(row => row.pddValueDraft && !this.pddValueExists(row.role, row.pddValueDraft)); if (invalid) { ElMessage.warning(`PDD 规格“${invalid.pddValueDraft}”已不存在，请重新选择`); return } this.detail.saving = true; try { for (const row of changes) { if (!row.pddValueDraft) { if (row.originalPddValue) await clearShopeeSpecMapping(this.loadedProductId, { requestId: createRequestId(), dimension: row.dimensionName, valueName: row.name }); continue } const source = ['exact_match', 'ai_match'].includes(row.draftSource) ? row.draftSource : 'manual'; const payload = { requestId: createRequestId(), dimension: row.dimensionName, valueName: row.name, pddValue: row.pddValueDraft, source }; if (source === 'ai_match') { if (row.draftConfidence !== null && row.draftConfidence !== undefined) payload.confidence = row.draftConfidence; if (row.previewReason) payload.reason = row.previewReason } await setShopeeSpecMapping(this.loadedProductId, payload); if (source === 'exact_match') await confirmShopeeSpecMapping(this.loadedProductId, { requestId: createRequestId(), dimension: row.dimensionName, valueName: row.name }) } ElMessage.success('规格匹配已保存'); await this.refreshDetail() } finally { this.detail.saving = false } },
    async submitAddValue() { const dimension = this.addValueForm.dimension.trim(); const name = this.addValueForm.name.trim(); if (!dimension || !name) { ElMessage.warning('请填写维度名称和规格值'); return } await addShopeeSpecValue(this.loadedProductId, { requestId: createRequestId(), dimension, role: this.addValueForm.role, name }); this.addValueForm = { dimension: '', role: 'other', name: '' }; await this.refreshDetail() },
@@ -0,0 +1,67 @@
+import { expect, test, Page } from '@playwright/test'
+
+const routes = [{ path: '/collection-purchase', component: 'Layout', menuName: 'GoAutoCollectionPurchase', title: '采集采购', visible: '0', children: [{ path: '/shopee-products', component: '/goauto/shopee-products/index', menuName: 'GoAutoShopeeProducts', title: '虾皮商品', visible: '0' }] }]
+
+async function fixture(page: Page, mode: 'pending' | 'lost' | 'read-failed') {
+  const releases: Array<() => void> = []
+  let posts = 0, saved = false
+  await page.context().addCookies([{ name: 'Admin-Token', value: 'synthetic-test-only', domain: 'localhost', path: '/' }])
+  const product = () => ({ id: 9, shopeeItemId: 'S9', title: '匹配等待测试', pddProductId: 17, specContextVersion: 'context-254', specs: [{ name: '颜色', role: 'color', values: [{ name: '深黑', source: 'import', mapping: saved ? { pddValue: '黑色', source: 'ai_match', status: 'confirmed' } : null }] }] })
+  await page.route('**/api/**', async route => {
+    const path = new URL(route.request().url()).pathname
+    if (path.startsWith('/src/api/')) return route.continue()
+    if (path.endsWith('/api/v1/getinfo')) return route.fulfill({ json: { code: 200, data: { roles: ['purchaser'], name: '测试采购员', avatar: '', introduction: '', permissions: [] } } })
+    if (path.endsWith('/api/v1/menurole')) return route.fulfill({ json: { code: 200, data: routes } })
+    if (path.endsWith('/api/admin/v1/shopee-products')) return route.fulfill({ json: { code: 200, data: { items: [product()], total: 1, page: 1, pageSize: 20 } } })
+    if (path.endsWith('/specs/mapping/auto-match')) {
+      posts++
+      if (mode === 'pending') await new Promise<void>(resolve => releases.push(resolve))
+      saved = true
+      if (mode !== 'pending') return route.abort('timedout')
+      return route.fulfill({ json: { code: 200, data: { confirmedCount: 1, preservedCount: 0, unmatchedCount: 0 } } })
+    }
+    if (path.endsWith('/shopee-products/9')) {
+      if (posts && mode === 'read-failed') return route.abort('failed')
+      return route.fulfill({ json: { code: 200, data: { product: product(), autoMatchTimeoutSeconds: 130 } } })
+    }
+    if (path.endsWith('/pdd-products/17')) return route.fulfill({ json: { code: 200, data: { product: { id: 17, goodsId: '17', specs: [{ name: '颜色', role: 'color', values: [{ name: '黑色', selectable: true }] }] } } } })
+    return route.fulfill({ json: { code: 200, data: [] } })
+  })
+  await page.goto('/#/shopee-products')
+  await page.getByRole('button', { name: '详情', exact: true }).click()
+  const match = page.getByRole('button', { name: '一键匹配颜色和尺码', exact: true })
+  await expect(match).toBeEnabled()
+  return { match, releases, posts: () => posts }
+}
+
+test('关闭重开与迟到响应不污染新匹配，显示动态140秒预算', async ({ page }) => {
+  const f = await fixture(page, 'pending')
+  await f.match.click()
+  await expect(page.getByText('正在匹配并保存，最多等待 140 秒', { exact: true })).toBeVisible()
+  await expect(page.getByRole('button', { name: '编辑档案', exact: true })).toBeDisabled()
+  await expect(f.match).toBeDisabled()
+  await page.screenshot({ path: 'test-results/254-waiting.png', fullPage: true })
+  await page.getByRole('button', { name: '关闭', exact: true }).click()
+  await page.getByRole('button', { name: '详情', exact: true }).click()
+  await expect(f.match).toBeEnabled()
+  await f.match.click()
+  await expect.poll(f.posts).toBe(2)
+  f.releases[0]()
+  await expect(f.match).toBeDisabled()
+  f.releases[1]()
+  await expect(f.match).toBeEnabled()
+  await expect(page.getByText('新匹配并确认 1 项，保留已确认 0 项，未匹配 0 项', { exact: true }).first()).toBeVisible()
+})
+
+for (const mode of ['lost', 'read-failed'] as const) {
+  test(`${mode}：结束等待且不重试POST`, async ({ page }) => {
+    const f = await fixture(page, mode)
+    await f.match.click()
+    const text = mode === 'lost' ? '已刷新当前保存结果；原请求未正常返回，请检查未匹配项后再操作' : '结果暂未确认，请刷新查看；不要重复提交匹配'
+    await expect(page.getByText(text, { exact: true })).toBeVisible()
+    await expect(f.match).toBeEnabled()
+    expect(f.posts()).toBe(1)
+    await expect(page.getByRole('button', { name: '刷新查看', exact: true })).toBeVisible()
+    await page.screenshot({ path: `test-results/254-${mode}.png`, fullPage: true })
+  })
+}
@@ -67,7 +67,7 @@ test('虾皮详情一键匹配颜色尺码后直接使用并可原地叠加 PDD
      return route.fulfill({ json: { code: 200, data: { confirmedCount: 2, preservedCount: 0, unmatchedCount: 0, items: [] }}})
    }
    if (url.pathname.endsWith('/api/admin/v1/shopee-products/9')) {
-      return route.fulfill({ json: { code: 200, data: { product: { id: 9, shopeeItemId: 'S9', title: '叠加抽屉商品', shopName: '测试店', pddProductId: 17, specContextVersion: 'context-3', specs: [{ name: '颜色', role: 'color', values: [{ name: '藏青色', source: 'import', mapping: autoMatched ? { pddValue: '黑色', source: 'ai_match', status: 'confirmed', confidence: 0.96, reason: '颜色含义唯一一致' } : null }] }, { name: '尺码', role: 'size', values: [{ name: 'XL', source: 'import', mapping: autoMatched ? { pddValue: 'XL', source: 'exact_match', status: 'confirmed', reason: '格式统一后唯一匹配' } : null }] }] }}}})
+      return route.fulfill({ json: { code: 200, data: { autoMatchTimeoutSeconds: 130, product: { id: 9, shopeeItemId: 'S9', title: '叠加抽屉商品', shopName: '测试店', pddProductId: 17, specContextVersion: 'context-3', specs: [{ name: '颜色', role: 'color', values: [{ name: '藏青色', source: 'import', mapping: autoMatched ? { pddValue: '黑色', source: 'ai_match', status: 'confirmed', confidence: 0.96, reason: '颜色含义唯一一致' } : null }] }, { name: '尺码', role: 'size', values: [{ name: 'XL', source: 'import', mapping: autoMatched ? { pddValue: 'XL', source: 'exact_match', status: 'confirmed', reason: '格式统一后唯一匹配' } : null }] }] }}}})
    }
    if (url.pathname.endsWith('/api/admin/v1/pdd-products/17/related-syb-products')) return route.fulfill({ json: { code: 200, data: { items: [], total: 0 }}})
    if (url.pathname.endsWith('/api/admin/v1/pdd-products/17')) return route.fulfill({ json: { code: 200, data: { product: { id: 17, goodsId: 'P17', title: 'PDD 叠加详情', shopName: 'PDD 店', status: 'active', url: 'https://mobile.yangkeduo.com/goods.html?goods_id=17', specs: [{ name: '颜色分类', role: 'color', values: [{ name: '黑色', selectable: true, priceCent: 1299 }] }, { name: '尺码', role: 'size', values: [{ name: 'XL', selectable: true }] }], colorImages: [] }, relatedShopeeProducts: [] }}})
@@ -0,0 +1,93 @@
+// Run with node --test. Exercise the real SFC methods without a browser or API.
+const { test } = require('node:test')
+const assert = require('node:assert/strict')
+const fs = require('node:fs')
+const path = require('node:path')
+const { parse } = require('@vue/compiler-sfc')
+const source = fs.readFileSync(path.join(__dirname, '../../src/views/goauto/shopee-products/ShopeeProductDetailDrawer.vue'), 'utf8')
+const script = parse(source).descriptor.script.content.replace(/import[\s\S]*?from ['"][^'"]+['"]/g, '').replace('export default', 'return')
+const product = id => ({ id, specContextVersion: 'v1', specs: [{ name: '颜色', role: 'color', values: [{ name: '黑', source: 'import' }] }] })
+const reply = id => ({ data: { product: product(id), autoMatchTimeoutSeconds: 130 } })
+const deferred = () => { let resolve, reject; const promise = new Promise((yes, no) => { resolve = yes; reject = no }); return { promise, resolve, reject } }
+function instance(get = async id => reply(id), post = async () => ({ data: {} })) {
+  const options = new Function('getShopeeProduct', 'autoMatchShopeeSpecMappings', 'createRequestId', 'ElMessage', 'PddProductDetailDrawer', script)(get, post, () => 'id', { success() {}, warning() {} }, {})
+  const vm = { modelValue: true, productId: 1, $emit() {}, $confirm: async () => {}, ...options.methods }
+  Object.assign(vm, options.data.call(vm))
+  Object.assign(vm, { loadedProductId: 1, detailDrawerOpen: true })
+  vm.detail.product = product(1); vm.detail.pddLoaded = true
+  // Focus method lifecycle, not the already-covered candidate predicates.
+  Object.defineProperty(vm, 'canAutoMatch', { get: () => !vm.detail.aiMatching && !vm.hasMappingChanges })
+  vm.hasMappingChanges = false
+  return vm
+}
+const tick = () => new Promise(resolve => setImmediate(resolve))
+
+test('close/reopen same product refreshes, old result/finally cannot clear a new operation', async () => {
+  const first = deferred(), second = deferred(); let calls = 0, reads = 0
+  const vm = instance(async id => { reads++; return reply(id) }, () => (++calls === 1 ? first.promise : second.promise))
+  const old = vm.autoMatchMappings(); await tick()
+  vm.modelValue = false; vm.closeInternals()
+  assert.equal(vm.detail.aiMatching, false)
+  vm.modelValue = true; await vm.requestSwitch(1)
+  assert.equal(reads, 2)
+  const fresh = vm.autoMatchMappings(); await tick()
+  first.resolve({ data: { confirmedCount: 99 } }); await old
+  assert.equal(vm.detail.aiMatching, true)
+  assert.equal(vm.detail.matchMessage.includes('99'), false)
+  second.resolve({ data: { confirmedCount: 1 } }); await fresh
+  assert.equal(vm.detail.aiMatching, false)
+})
+test('duplicate clicks do not send a second POST and dynamic budget is forwarded', async () => {
+  const result = deferred(); let calls = 0, seconds
+  const vm = instance(undefined, (id, data, budget) => { calls++; seconds = budget; return result.promise })
+  const running = vm.autoMatchMappings(); await tick(); await vm.autoMatchMappings()
+  assert.equal(calls, 1); assert.equal(seconds, 130)
+  result.resolve({ data: {} }); await running; assert.equal(vm.detail.aiMatching, false)
+})
+for (const reason of ['timeout', 'Network Error', 'business failure']) {
+  test(`${reason}: one readback, no automatic POST retry`, async () => {
+    let reads = 0, posts = 0
+    const vm = instance(async id => { reads++; return reply(id) }, async () => { posts++; throw new Error(reason) })
+    await vm.autoMatchMappings()
+    assert.equal(reads, 2); assert.equal(posts, 1); assert.equal(vm.detail.aiMatching, false)
+    assert.match(vm.detail.matchMessage, /已刷新当前保存结果/)
+  })
+}
+test('readback failure ends busy with explicit unknown result', async () => {
+  let reads = 0
+  const vm = instance(async id => { if (++reads > 1) throw new Error('offline'); return reply(id) }, async () => { throw new Error('timeout') })
+  await vm.autoMatchMappings(); assert.equal(vm.detail.aiMatching, false); assert.match(vm.detail.matchMessage, /结果暂未确认/)
+})
+test('prepare failure or missing budget does not POST', async () => {
+  for (const get of [async () => { throw new Error('offline') }, async id => ({ data: { product: product(id) } })]) {
+    let posts = 0; const vm = instance(get, async () => { posts++ })
+    await vm.autoMatchMappings(); assert.equal(posts, 0); assert.equal(vm.detail.aiMatching, false)
+  }
+})
+test('switch while readback is pending never writes old data or messages', async () => {
+  const pending = deferred(); let reads = 0
+  const vm = instance(async id => { if (++reads === 2) return pending.promise; return reply(id) })
+  const old = vm.autoMatchMappings(); await tick()
+  vm.productId = 2; await vm.requestSwitch(2)
+  pending.resolve(reply(1)); await old
+  assert.equal(vm.detail.product.id, 2); assert.equal(vm.detail.matchMessage, ''); assert.equal(vm.detail.aiMatching, false)
+})
+test('manual drafts prevent matching and refused discard prevents refresh', async () => {
+  let calls = 0; const vm = instance(async id => { calls++; return reply(id) })
+  vm.hasMappingChanges = true; vm.$confirm = async () => { throw new Error('cancel') }
+  await vm.autoMatchMappings(); await vm.reload(); assert.equal(calls, 0)
+})
+
+test('API uses derived time plus margin only for auto-match; suggestions stay unchanged', async () => {
+  const apiSource = fs.readFileSync(path.join(__dirname, '../../src/api/goauto/shopee-products.js'), 'utf8').replace(/import[^\n]+\n/g, '').replace(/export function/g, 'function')
+  const calls = []
+  const api = new Function('request', apiSource + '\nreturn { autoMatchShopeeSpecMappings, suggestShopeeColorMappings, suggestShopeeSizeMappings };')(config => { calls.push(config); return Promise.resolve({}) })
+  for (const seconds of [16, 130, 370, 1210]) {
+    await api.autoMatchShopeeSpecMappings(1, {}, seconds)
+    assert.equal(calls.at(-1).timeout, (seconds + 10) * 1000)
+  }
+  await assert.rejects(api.autoMatchShopeeSpecMappings(1, {}, undefined))
+  assert.equal(calls.length, 4)
+  await api.suggestShopeeColorMappings(1, {}); assert.equal(calls.at(-1).timeout, 610000)
+  await api.suggestShopeeSizeMappings(1, {}); assert.equal(calls.at(-1).timeout, 610000)
+})
Author	SHA1	Message	Date
QiuSW	08d939a9b8	docs: sync dynamic match timeout contract #254	2026-09-10 09:43:53 +08:00
QiuSW	9088e6b734	fix(shopee): bound matching waits and recover drawer loading #254	2026-09-10 09:37:02 +08:00