docs: mirror candidate-assisted SYB parsing rules #251

docs/02-architecture-and-code-map.md

@@ -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: 0b9d4e6e0e97f495d19a53e1aa0ecea3a66ba495
-synchronized_at: 2026-09-07T09:27:49Z
+wiki_revision: eb9608c98fa117d4fcc2019ed6ae60b6a3670f42
+synchronized_at: 2026-09-09T09:24:10Z
 <!-- gitea-wiki-mirror:end -->
 
 # 架构与代码地图
@@ -68,6 +68,8 @@ Android Portal/Agent
 | `pdd_account` | 可选的账号调度引用，只保存名称和状态，不保存凭据 |
 | `purchase_task` | 商品外键和不可变快照、执行模式、状态/租约 guard、价格边界、订单、人工支付复核、物流与回填事实 |
 | `purchase_task_attempt` | `task_id + attempt_id` 幂等执行记录、阶段、规则哈希、固化规格决策和结构化错误 |
+
+> #241 新增：`server/app/goauto/purchase/order_backfill.go` 与 `order_backfill_handler.go` 提供 `POST /api/agent/v1/purchase-tasks/order-backfill`（Device Token 鉴权，逐条事务、逐条结果）；`server/app/goauto/models/purchase_order_guard.go` 在 `PurchaseTask.BeforeSave` 上全局强制订单号唯一，以 `purchase_rule_setting` 单例行串行化订单号分配，避免新增唯一索引迁移；`purchasecontract.ParseAddressSuffix` 为 `AddressSuffix` 的反解，通过回比而非负向前瞻实现（Go RE2 不支持前瞻）。
 | `ai_matching_setting` | 唯一单例的启用状态、OpenAI-compatible Base URL、模型、超时、内部部署明文 API Key 和更新人；仅管理员设置接口可以读取该字段 |
 
 `collection_task` 的状态仅为 `pending`、`running`、`completed`、`completed_partial`、`failed`。设备身份和心跳表属于 Agent 领取任务的必要基础，不承载 PDD 业务数据。
@@ -336,7 +338,7 @@ PddProductDetailCollector
 
 ## 客户端密钥访问架构（#237）
 
-代码基线 `71f7751`（含用户确认的默认 HTTP/HTTPS 兼容），2026-09-07 完成 Server/Web 代码与隔离测试；实际迁移、权限写入和部署尚未执行，不表示现有线上能力。
+代码基线 `71f7751`（含用户确认的默认 HTTP/HTTPS 兼容），2026-09-07 完成 Server/Web 代码与隔离测试；本机迁移、管理员菜单写入与 Server/Web 启动已于 2026-09-07 授权完成，真实 HTTP 管理列表和模块目录加载通过；线上仍未部署。
 
 - `server/app/goauto/clientkey` 管理独立密钥、授权及审计；`clientapi/routes.go` 的显式 Inventory 将 `/api/client/v1` 映射到既有业务处理器，绝不转发任意 Admin 路由。
 - `clientapi/gateway.go` 默认接受 HTTP 与 HTTPS，无协议开关或转发协议头门禁，按 Bearer 密钥、模块及能力顺序校验，每次请求读取数据库，无授权缓存。`common/clientprincipal` 传递独立客户端身份，不生成或伪装管理员 JWT。
@@ -344,3 +346,44 @@ PddProductDetailCollector
 - 编辑与停用采用启用状态和 version 条件更新，并与变更审计同事务提交；冲突返回 409。业务执行前先持久化请求审计意图，失败则不执行业务。完成后更新状态；更新失败或进程中断可能留下 status=0，表示结果待核对，不能据此自动重放。
 - 部分既有业务操作人字段使用该密钥最近授权管理员的 ID 兼容现有外键；实际调用方以独立审计的 key_id 为准，不能把业务字段当成人工操作证据。
 - Admin 页面 `web/src/views/goauto/client-keys/index.vue` 复用创建/编辑授权弹窗；菜单位于“采采管理”，仅管理员可见。新追加迁移 `1788798000000_client_api_key.go` 创建两表及管理员菜单，不改 Android。
+
+## 采购规格面板预滑动兼容（#238）
+
+代码基线 `58a6c1c`，Android 0.9.60 / versionCode 73（构建完成不等同于已安装/发布）。`PurchaseRehearsalExecutor.applyPostAction` 对 `openSpecPanel.swipeAfter` 只兼容解析、不执行机械预滑动，`waitAfterMs` 保留；首趟继续原 `probeSpecs` 遍历，第二趟继续原 `selectSpec` 精确查找与容器内有界滚动。其他动作的后置滑动仍沿用既有执行语义，失败不会被统一忽略。
+
+`GoAutoAccessibilityService.swipePurchase` 的失败分类由 `PurchaseSwipeFailureReason` 枚举提供；共享 `swipeNode` 仅增加可选分类回调，不改变手势目标、轨迹、1500ms 回调等待或其他调用者行为。`GoAutoPurchasePanel` 日志经 `AgentForegroundService` 关联 task、attempt、device 与规则快照哈希，新增预滑动跳过/必需滑动失败标量；不记录节点文字、坐标、原始控件树、截图或凭据。
+
+Server/Web、数据库和任务快照不变；旧 APK 仍有预滑动行为，必须更新 Agent 才生效。相关验证在 `PurchaseRehearsalExecutorTest`，Android 全量测试与 APK 构建入口不变。
+
+## SYB 逐页保存与部分成功（#239）
+
+实现绑定 c6a962d；代码已实现不代表当前线上已部署。每页完整明细在外部请求结束后按页事务保存；页回滚不累计明细/新增/覆盖数，已提交页保留。日期局部读取失败继续下一日期，全局数据库/进度/会话/取消故障停止。当天漂移不在一次运行内重扫；后续运行重新扫描并幂等补齐。
+
+同步状态增加 `partial_success`（部分成功，15 字符，复用现有 varchar(16)，无需迁移）。有错误且 created+updated>0 为部分成功；有错误无已提交明细为 failed；完整且无错误为 succeeded（包括无符合店铺的数据）。中断仍为 interrupted，不把中断追认为成功。所有终态沿用活动槽释放规则。
+
+`orderCount` 是已验证页的原始列表读取数量；`detailCount`、`created`、`updated` 为已提交明细及其新增/覆盖数量；`daysProcessed` 是完整通过的日期数，不是已尝试日期数。失败日期/页码/阶段写入现有脱敏限长 errorMessage。部分成功不刷新店铺的完整同步统计。
+
+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、采购、数据库迁移或服务重启；线上及历史数据效果尚待授权验证。

docs/03-business-rules-and-glossary.md

@@ -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: 17e346d6e9398abe2188280112fc04d88fd10d88
-synchronized_at: 2026-09-07T09:27:54Z
+wiki_revision: cf6bd9fb5dd727417a3ed612ddcf52eb2d8d868d
+synchronized_at: 2026-09-09T09:24:15Z
 <!-- gitea-wiki-mirror:end -->
 
 # 业务规则与术语
@@ -58,6 +58,13 @@ synchronized_at: 2026-09-07T09:27:54Z
 - 对采购人员展示的阶段固定为：待人工处理、未关联 PDD、PDD 待采集、PDD 采集中、PDD 采集失败、规格待匹配、可创建采购、已创建任务、采购成功、待人工核对。
 - 主阶段优先级为：待人工核对 → 采购成功 → 已创建任务 → 待人工处理 → 未关联 PDD → PDD 待采集/采集中/采集失败 → 规格待匹配 → 可创建采购。每行只显示一个阶段和对应下一步。
 - “待人工核对”表示订单结果不明确，必须先人工核查并禁止自动重试；“采购成功”表示已取得 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）。
+- Agent 侧回填为**人工触发的只读扫描**（#242）：入口在采购记录页搜索按钮右侧，输入天数（默认 2）后确认启动。天数口径为滚动 N×24 小时，基准是页面读到的下单时间。采集、采购、回填三者互斥，复用既有任务互斥锁并加原子防重入，忙碌时拒绝启动而不排队、不抢占。
+- 回填扫描不假设订单列表有序：只有连续观察到至少 5 单且下单时间严格递减、期间无缺失时间时，才允许「超过指定时间即停止」；一旦出现时间回升或缺失，改为扫至内部上限并明确标记「未完整扫描」，不得把不完整结果显示为已扫完。内部上限用于限制设备占用，不作为用户可配置的门禁。
+- 回填扫描全程只读：确认收货、申请退款、催发货、去支付、立即支付、提交订单、付款、退款、取消订单、再次购买、删除订单永久排除为点击目标；点击目标必须自身可点、子树不含上述词，且不与任何含上述词的可见控件几何重叠；不得按固定坐标盲点。遇登录、验证码或风控立即停止并报告。
+- 解析不出规范后缀的订单一律跳过，其订单数据不缓存、不上传、不入日志；上传载荷只含后缀、订单号与可选下单时间。本地缓存只采纳服务端确认的事实，并区分页面读到的真实时间与 `irreversible_at` 回落估算值。后缀只承载任务号，请求不含地址全文或收件人信息；只允许回填该设备自己的正式采购任务；页面下单时间优先，缺失时回落该任务的 `irreversible_at` 并标记时间来源，两者皆空则该条失败。
 - 已失败、已取消或演练完成的旧采购任务不单独占用主阶段；当前数据仍满足条件时恢复显示“可创建采购”，旧任务继续在采购管理留痕和按既有规则处理。
 - 未选择处理阶段时，商品列表仍先返回，当前页阶段和采购准备继续异步批量读取且不调用 AI Provider；选择阶段筛选时，服务端必须先对完整查询结果派生并筛选阶段，再计算总数和分页，不能只过滤当前页。
 
@@ -67,7 +74,7 @@ synchronized_at: 2026-09-07T09:27:54Z
 - 版本迁移会对历史存活店铺回填 `normalized_name = Normalize(display_name)`；回填只改匹配键且可重复执行。若两个存活店铺回填后会得到同一键，迁移必须整体失败并保留原数据，管理员先人工消除歧义后再执行，不能静默合并、删除或改变店铺启用状态。
 - 店铺可以从 SYB 真实货运单列表发现，也允许管理员手工补充。只有管理员可以新增、改名、启停和软删除，采购员等其他角色只读。
 - 没有任何启用店铺时，导入必须在读取凭据、建立会话、验证码 OCR 和任意 SYB 网络请求之前失败，并给出“请先启用店铺”的可读提示。
-- 同步必须先拉取并校验当天原始全量列表的总数、分页和唯一 ID，再按本次同步开始时固定的启用店铺快照过滤；过滤不能降低完整性校验的请求范围或容量上限。
+- 同步先预检全范围总数及上限，每页校验原始列表条数、合法 ID 和重复，再按冻结店铺快照获取明细并页事务保存；整日结束核对总数。过滤不能降低完整性校验范围，已保存不能冒充整日完整（#239，c6a962d，已于 2026-09-08 随 d403f3b 部署线上）。
 - 只有列表与明细响应的店铺名都非空且命中启用快照时才允许写入。明细店铺名为空、变化为未启用店铺或无法匹配时跳过，并计入跳过数量。
 - 停用或软删除店铺只影响后续导入，不删除历史 SYB 商品、虾皮商品或任务数据。已有错误导入数据的清理必须先给出精确 SQL 和影响行数，再由用户单独确认。
 
@@ -397,7 +404,7 @@ synchronized_at: 2026-09-07T09:27:54Z
 
 - 规格入口与精确规格选择统一按“重新定位唯一目标 → 执行一次无障碍点击 → 读取新页面验证”执行；不得复用旧无障碍节点，不选择相近规格，也不在多候选时默认点击第一个。
 - 无障碍点击后页面完全无变化时，只允许对解析器已确认的安全规格入口或服务端下发且唯一命中的精确规格执行一次中心手势兜底。目标必须可见、启用、边界有效，手势后仍须以规格面板强证据或精确选中证据确认结果。
-- 页面发生变化但规格面板强证据不足时，不再继续手势或猜测页面，明确失败并只记录面板类型、候选数量和证据布尔值等无敏感标量。原始控件树、节点文字集合和整屏截图仍不得保存或上传。
+- 页面发生变化但规格面板强证据不足时，默认明确失败；#243 的同商品页安全入口恢复是限定例外：确认包/Activity 未变、商品标题非空且未变、入口来源与语义未变，无面板、关闭、数量、已选、支付、订单或页面异常信号时，重新定位入口并最多执行一次受控手势。整页普通动态节点变化不单独阻断该恢复；入口缺失或显式/嵌套入口歧义仍拒绝。商品标题一致是当前上下文约束，不宣称已从页面核验 goods_id。诊断只记录入口来源、点击结果/原因、恢复结果和面板数量/布尔等无敏感标量。原始控件树、节点文字集合和整屏截图仍不得保存或上传。
 - 规格已处于精确选中状态时不得重复点击。规格查找只在解析器唯一识别的规格面板容器内有限滚动，每次滚动后重新定位容器与目标；容器缺失、歧义、到边或验证失败均 fail-closed。
 - 中心手势兜底不得用于修改/保存地址、创建或提交订单、订单详情入口以及任何支付/付款目标；正式创建订单的一次性不可逆门禁与永久禁止支付规则不变。
 ## PDD 商品反向关联与继续订单采购（#161）
@@ -447,7 +454,7 @@ synchronized_at: 2026-09-07T09:27:54Z
 
 ## 客户端密钥与可编辑模块授权（#237）
 
-以下为提交 `71f7751` 已实现、尚待实际迁移与部署的规则。
+以下为提交 `71f7751` 已实现的规则；2026-09-07 本机已迁移并验证管理页面可用，2026-09-08 已随 d403f3b 完成线上迁移与部署，真实客户端密钥执行闭环尚未验证。
 
 - 仅管理员创建、查看、编辑授权或停用密钥。首版不提供密钥改名、到期、轮换、恢复启用、删除或任意接口授权。
 - 模块选择复用“采集采购/采采管理”现有 12 个业务模块；分组勾选只影响当前子模块，新菜单不会自动获得授权。客户端密钥管理、系统账号权限及支付不在可授权模块中。
@@ -458,3 +465,71 @@ synchronized_at: 2026-09-07T09:27:54Z
 - 客户端与 Admin 登录 JWT、Agent Device Token 独立。响应排除凭据及原始载荷字段；AI 设置只返回 enabled，不开放 Provider 配置读写或连接测试。设备仅开放列表，不开放身份重置、令牌或解锁接口。
 - 执行动作复用既有业务门禁、幂等参数及状态机；客户端采购 batch-retry 沿用 Admin 原有语义，不等同于 Agent 就地 reset。授权重采购、支付复核、取消订单等未列入接口不开放；永久禁止付款。
 - 创建响应丢失时不可找回完整密钥，应核对列表并停用可能已创建的记录，再明确创建新密钥，不能盲目自动重试。完整密钥只在创建结果弹窗内存中显示，关闭或离开页面清空，不写浏览器持久存储。
+
+## 打开采购规格面板后按需滚动（#238）
+
+- Android 0.9.60 / versionCode 73，代码 `58a6c1c` 起，规则 `openSpecPanel.swipeAfter` 保留格式校验与旧快照兼容，但不执行打开面板后的固定次数预滑动；不以“必须滑两次成功”作为进入规格探测/选择的条件。动作后的 `waitAfterMs` 仍生效。
+- 首趟规格探测和第二趟精确选择仍使用各自既有的按需横向/纵向、有界与稳定终止策略。取消预滑动不等于不探测隐藏规格，也不等于只看首屏。目标不存在、歧义、页面证据不足或必要的有界查找失败时仍明确失败。
+- 此调整覆盖所有已经安全识别打开的面板，不再仅特判 NON_SCROLLABLE_CONFIRMATION；不弱化面板验证、精确选中、地址、价格、任务租约、创建订单边界或禁止支付规则。
+- 其他动作的后置滑动沿用原行为，必需滑动失败仍返回 RULE_ACTION_FAILED。旧规则 JSON 不回写、不迁移；原任务 ID、历史 attempt、商品与规格快照不变。旧 APK 行为不变，需升级 Agent；本单未改线上规则或执行 CG68 真机采购。
+
+## SYB 逐页保存与部分成功（#239）
+
+实现绑定 c6a962d；2026-09-08 已随 d403f3b 部署线上，未手动触发真实同步验收；#240 上游尾页超时尚未修复。每页完整明细在外部请求结束后按页事务保存；页回滚不累计明细/新增/覆盖数，已提交页保留。日期局部读取失败继续下一日期，全局数据库/进度/会话/取消故障停止。当天漂移不在一次运行内重扫；后续运行重新扫描并幂等补齐。
+
+同步状态增加 `partial_success`（部分成功，15 字符，复用现有 varchar(16)，无需迁移）。有错误且 created+updated>0 为部分成功；有错误无已提交明细为 failed；完整且无错误为 succeeded（包括无符合店铺的数据）。中断仍为 interrupted，不把中断追认为成功。所有终态沿用活动槽释放规则。
+
+`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。部署后新同步或显式重新解析会使用新逻辑；本次没有执行生产批量更新。

docs/08-agent-api-contract.md

@@ -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: 36f6f6081f0cfdfd8a4a395a27eaef0a6cd88cda
-synchronized_at: 2026-09-07T09:28:25Z
+wiki_revision: 217239a85b50c880e004ecc19a559fb5e03555e1
+synchronized_at: 2026-09-08T01:38:42Z
 <!-- gitea-wiki-mirror:end -->
 
 # MVP 共享 API 契约
@@ -77,7 +77,7 @@ PATCH /api/admin/v1/syb-products/{productId}/correction
 
 `import` 允许已认证的管理员（admin）和采购员（purchaser）调用（#236），仍须通过 Casbin 权限校验；其他角色返回 403。采购员的 POST 权限由既有启动权限对账写入，不需要新增数据库迁移。操作人取已认证 claims，不接受客户端冒名。请求体提交 `dateFrom`、`dateTo` 后创建持久化后台任务并立即以 `202` 返回 `runId` 和 `status=running`；关闭弹窗、刷新或离开页面不影响任务。没有启用店铺时必须在读取凭据、登录、验证码 OCR 和任意 SYB 网络请求之前返回 `422`。任意时刻只能有一条 `running` 记录，内存锁与数据库唯一执行槽共同阻止单进程和跨进程重复导入；冲突时返回正在执行任务的日期范围。
 
-`sync-runs` 列表支持 `page`、`pageSize`、`status`、`dateFrom`、`dateTo`，详情返回日期范围、状态（`running` / `succeeded` / `failed` / `interrupted`）、处理天数、货运单/明细/新增/覆盖数量、店铺准入与跳过数量、店铺筛选快照哈希、按店铺的 `accepted` / `skipped` 统计、操作人和起止时间。列表和详情对已登录角色只读开放。服务启动时遗留的 `running` 任务改为 `interrupted`；中途失败或中断已经写入的数据保留，重新导入仍按唯一键覆盖。
+`sync-runs` 列表支持 `page`、`pageSize`、`status`、`dateFrom`、`dateTo`，详情返回日期范围、状态（`running` / `succeeded` / `partial_success` / `failed` / `interrupted`）、处理天数、货运单/明细/新增/覆盖数量、店铺准入与跳过数量、店铺筛选快照哈希、按店铺的 `accepted` / `skipped` 统计、操作人和起止时间。列表和详情对已登录角色只读开放。服务启动时遗留的 `running` 任务改为 `interrupted`；中途失败或中断已经写入的数据保留，重新导入仍按唯一键覆盖。
 
 列表返回结构化字段（`orderCode`、`shopeeItemId`、`productTitle`、`targetColor`、`targetSize`、`quantity`、`unitPriceCent`、`imageUrl`、`parseStatus`、`parseNote`、`manuallyConfirmed`），不含原始 JSON；`keyword` 匹配订单号、虾皮商品ID 或商品标题，`parseStatus` 筛选 `success`/`uncertain`/`failed`。详情额外返回 `rawJson`（原始 `details[]` 元素，未做任何改写）。
 
@@ -472,7 +472,7 @@ POST /api/agent/v1/tasks/{taskId}/fail
 |---|---:|---:|---:|---:|
 | `openProduct` | 是 | 是 | 是 | 否 |
 | `verifyProduct` | 是 | 是 | 否 | 否 |
-| `openSpecPanel` | 是 | 是 | 是 | 否 |
+| `openSpecPanel` | 是 | 是 | 兼容读取、不执行（0.9.60+，见 #238） | 否 |
 | `selectSpec` | 是 | 是 | 是 | 否 |
 | `setQuantity` | 是 | 是 | 否 | 否 |
 | `verifyUnitPrice` | 是 | 是 | 否 | 否 |
@@ -486,7 +486,7 @@ POST /api/agent/v1/tasks/{taskId}/fail
 - 文字候选按控件文字或内容描述**精确匹配**；候选合并后必须唯一命中。点击动作只允许点击唯一文字节点或其最近的可点击父容器，不允许模糊匹配、猜测相近候选、改点兄弟节点。
 - 动作 `textAliases` 不能包含地址修改、创建/提交订单、订单号或支付相关文字，防止用安全 action 绕过危险动作类型和能力门禁。只读识别字段使用独立校验：允许订单和支付证据，仍拒绝修改地址、收货地址，并沿用各字段声明的数量、长度、去重和空白限制。
 - `waitAfterMs` 表示动作成功后的等待时间，范围为 0～30000 毫秒；省略时为 0。
-- `swipeAfter` 表示动作成功后执行一个有限滑动计划。`direction` 只能为 `up` / `down` / `left` / `right`，`count` 为 1～10，`durationMs` 为 100～2000，`intervalMs` 为 0～5000 且省略时为 0。
+- `swipeAfter` 通常表示动作成功后执行一个有限滑动计划；Android 0.9.60+ 的 `openSpecPanel` 例外，只兼容读取而不执行预滑动（见 #238）。`direction` 只能为 `up` / `down` / `left` / `right`，`count` 为 1～10，`durationMs` 为 100～2000，`intervalMs` 为 0～5000 且省略时为 0。
 - 未在矩阵中授权的 action/参数组合、未知字段、空候选和越界值一律拒绝。`updateShippingAddress`、`createOrder`、`readOrderResult` 等正式动作在其独立高风险契约完成前不接受上述参数。
 - 旧的仅含 `actions[].type` 的规则继续有效：候选使用 Agent 内置语义，等待为 0，不执行动作后滑动。
 - 服务端保存创建任务时收到的完整原始规则快照；规则后来更新为规则 B，不会改变已有任务中的规则 A 快照。
@@ -870,7 +870,7 @@ Agent 携带既有 Token（可已失效）及恢复码重新调用注册接口
 
 ## 客户端 API 与管理员密钥管理（#237）
 
-实现基线 `71f7751`；以下接口已通过隔离测试，尚未完成真实迁移/部署联调。Android 接口不变。
+实现基线 `71f7751`；以下接口已通过隔离测试；2026-09-07 本机 MySQL 迁移及管理员通过 HTTP 读取列表、模块目录已验证，真实密钥创建/编辑/停用及业务访问仍未联调，线上尚未部署。Android 接口不变。
 
 ### 管理接口
 
@@ -966,3 +966,22 @@ Agent 携带既有 Token（可已失效）及恢复码重新调用注册接口
 | POST | `/purchase-tasks/batch-retry` | purchase_tasks | purchase |
 | POST | `/purchase-tasks/stock` | purchase_tasks | purchase |
 | GET | `/ai-matching-settings` | ai_matching | read |
+
+### openSpecPanel 后置滑动兼容与诊断（#238）
+
+版本边界：Android 0.9.60 / versionCode 73，代码 `58a6c1c`。不修改 JSON schema、能力标识、任务接口或已有快照哈希。`openSpecPanel.swipeAfter` 仍按 direction/count/durationMs/intervalMs 原约束校验；解析成功后不执行该准备性滑动，`waitAfterMs` 保留。其他动作后置滑动沿用旧执行语义。旧 Server 可继续下发原快照；旧 APK 仍按原策略执行，不能将本契约描述当作旧设备已获得兼容。
+
+规格探测与精确选择自行负责按需有界滚动，原始候选、精确点击和选中复核不变。跳过预滑动不作为规格探测成功或订单创建证据。
+
+本地 `GoAutoPurchasePanel` 脱敏结构日志关联 task、attempt、device、rule（规则 SHA-256），不上传原始页面。新增事件：`postSwipe=skipped;action=openSpecPanel;reason=spec_panel_on_demand;panel=<枚举>`；其他必需滑动失败为 `postSwipe=failed;action=<动作枚举>;direction=<方向枚举>;swipeIndex=<本动作内第几次滑动>;reason=<固定分类>`。
+固定失败分类：unknown、root_unavailable、no_scrollable、invalid_bounds、gesture_unsupported、gesture_rejected、gesture_cancelled、gesture_timeout。日志不含规格值、节点文本、坐标、地址、订单、凭据、原始树或截图；结果错误码仍为 RULE_ACTION_FAILED，现有结果提交字段不变。
+
+## SYB 逐页保存与部分成功（#239）
+
+实现绑定 c6a962d；代码已实现不代表当前线上已部署。每页完整明细在外部请求结束后按页事务保存；页回滚不累计明细/新增/覆盖数，已提交页保留。日期局部读取失败继续下一日期，全局数据库/进度/会话/取消故障停止。当天漂移不在一次运行内重扫；后续运行重新扫描并幂等补齐。
+
+同步状态增加 `partial_success`（部分成功，15 字符，复用现有 varchar(16)，无需迁移）。有错误且 created+updated>0 为部分成功；有错误无已提交明细为 failed；完整且无错误为 succeeded（包括无符合店铺的数据）。中断仍为 interrupted，不把中断追认为成功。所有终态沿用活动槽释放规则。
+
+`orderCount` 是已验证页的原始列表读取数量；`detailCount`、`created`、`updated` 为已提交明细及其新增/覆盖数量；`daysProcessed` 是完整通过的日期数，不是已尝试日期数。失败日期/页码/阶段写入现有脱敏限长 errorMessage。部分成功不刷新店铺的完整同步统计。
+
+Web 唯一展示位置为“采集采购 → SYB 同步记录”：列表状态、状态筛选及详情支持部分成功，详情保留已保存数量、错误原因与重新同步补齐提示。定时任务日志只表示异步任务受理，不等于最终业务同步成功。

docs/12-syb-erp-interface.md

@@ -2,8 +2,8 @@
 generated: true (请先修改 Gitea Wiki，禁止直接编辑本文件)
 wiki_page: SYB-ERP-Interface-Contract
 wiki_url: https://git.ilapage.cn/OPC/goauto/wiki/SYB-ERP-Interface-Contract.-
-wiki_revision: a4f4ab200af052bab7ffbabe267238528bcd7cf9
-synchronized_at: 2026-09-07T07:02:57Z
+wiki_revision: 214485db630141aeb03d4b49b22a65e572fb592a
+synchronized_at: 2026-09-08T02:24:10Z
 <!-- gitea-wiki-mirror:end -->
 
 # 12 顺云宝（SYB）ERP 接口契约
@@ -220,22 +220,13 @@ Admin 默认 `max_matches = 10000`，可以在配置中调整；上限针对整
 有限重试：单次 HTTP 总超时 60 秒，最多执行 3 次，重试前分别等待 1 秒、2 秒，等待须
 响应 context 取消。HTTP 401/403、明确会话失效、业务失败、接口数据完整性错误和本地
 校验失败不得重试；登录、验证码、单件码写入和任何回填请求也不得使用该机制。重试
-耗尽后返回最后一次错误，外层继续保留日期、页码和已获取数量上下文并将同步标为失败。
+耗尽后返回最后一次错误，外层保留日期、页码和已获取数量上下文，按最终已保存成果将同步标为失败或部分成功。
 
-今天的货运单会在同步期间持续新增。只有 UTC+8 下的今天发生上述快照漂移时，
-允许只重试今天的列表分页，最多 3 次；已经完成的历史日期不得重复拉取，每次尝试
-也必须使用独立 ID 集合。第三次仍不稳定时，可以对最后一次取得的合法唯一 ID
-读取完整明细并按既有 upsert 保存，但本次同步仍记为失败、明确提示当天未形成
-稳定快照且不推进游标，下一次继续覆盖今天。任何尝试都不得突破 `max_matches`；
-网络/业务错误、非法 ID 或不完整明细不属于可放宽的快照漂移。
-`[必须，#235]` 当天跨页重复 ID 纳入上述最多 3 次列表快照尝试（含首次），
-不增加另一层重试次数。发现跨页重复后丢弃本次列表，从预检总数和第一页重新开始，
-使用全新 ID 集合；最后一次仍重复时直接失败，不得去重后按成功或降级数据保存。
-已经完成的历史日期保持其已有结果，不重复拉取；历史日期重复不适用此恢复。
-每页先检查非法 ID 和页内重复，再检查跨页重叠；同页同时存在页内重复和跨页重叠时
-仍作为硬错误停止。原有总数漂移/短页的合法唯一列表降级保存条件保持不变。
-重复诊断只记录日期、当天尝试序号、首次/当前页码与行号、start、pageSize、
-expectedTotal 和已获取唯一数量，不记录真实重复 ID、原始响应或个人数据。
+自 #239（实现提交 c6a962d，已于 2026-09-08 随 d403f3b 部署线上）起，改为按页验证和保存：每页先验证条数、合法 ID、页内/跨页重复，再按冻结店铺快照获取并验证全部明细；外部请求完成后才开启页事务。页内任一入库失败回滚整页，已提交的前页保留，计数在事务提交后累计。
+
+当天和历史日期统一处理：分页/明细失败或最终总数漂移时停止该日期并继续后续日期，不在同次运行中重新扫描当天，以避免重复写入和计数。数据库故障、进度持久化失败、明确会话失效、上下文取消或总任务超时停止整个范围。下一次人工或定时同步重新扫描日期，按 (order_code, detail_id) 幂等覆盖并保留人工确认。跨页重复不去重后冒充完整数据；最终日期完整性校验仍覆盖所有店铺。此流程替代此前 #235 的当天三次整日快照重扫。
+
+重复诊断只记录日期、首次/当前页码和行号、start、pageSize、expectedTotal、已获取唯一数量，不记录真实重复 ID、原始响应或个人数据。
 
 ### 4.4 统一日期范围同步与覆盖游标
 
@@ -258,7 +249,7 @@ GoAuto 同步记录页的立即同步允许管理员和采购员（purchaser）
 或超过 `max_matches` 时不推进游标。
 
 `[必须]` 每批明细响应必须与请求的货运单 ID 一一对应。缺失、重复、出现未请求
-ID，或某张货运单返回空商品明细，都视为不完整并停止同步；已经写入的幂等数据
+ID，或某张货运单返回空商品明细，都视为不完整并停止当前日期，继续后续日期；已经写入的幂等数据
 可以保留，但只有所有日期全部成功才推进游标。
 
 `[必须]` 登录和验证码只是同步前置步骤。日期范围经过自动 OCR 降级、手工
@@ -500,9 +491,9 @@ POST /am/stock/detail/updateDetailCode?t=0&id={stockID}&detailId={detailID}&code
 > 以下「店铺准入」已由 GoAuto #49 采纳并实现；店铺规范化还包括全角/半角统一和忽略大小写。
 
 `[必须]` **同步先校验原始全量，再做店铺准入。** 顺序固定为：按日期查询原始总数
-并执行单次容量熔断 → 拉完当天原始列表并核对分页前后总数、页长和唯一 ID → 按
+并执行单次容量熔断 → 逐页核对页长和唯一 ID，整日结束复核总数 → 按
 `shopName` 去除首尾空白后与启用店铺精确匹配 → 只为接受的货运单请求明细和入库。
-不能先过滤再做完整性校验，否则非目标店铺的分页漂移会被掩盖。
+店铺过滤只决定明细获取和入库，不能减少原始列表完整性校验范围；已保存不代表整日完整。
 
 `[必须]` 同步开始时只读取一次启用店铺，整次运行使用同一个快照。列表允许但明细
 响应中的 `shopName` 变为空或非允许店铺时再次拦截。没有启用店铺时在会话/OCR/
@@ -657,3 +648,13 @@ settings:
 - 客户端实现：`server/app/goauto/sybclient/`
 - 落库与解析：`server/app/goauto/sybimport/`
 - 相关工单：[#48 客户端移植](https://git.ilapage.cn/OPC/goauto/issues/48)、[#41 SYB 货运单商品导入](https://git.ilapage.cn/OPC/goauto/issues/41)、[#37 物流调度与货运宝回填](https://git.ilapage.cn/OPC/goauto/issues/37)
+
+## SYB 逐页保存与部分成功（#239）
+
+实现绑定 c6a962d；2026-09-08 已随 d403f3b 部署线上，未手动触发真实同步验收；#240 上游尾页超时尚未修复。每页完整明细在外部请求结束后按页事务保存；页回滚不累计明细/新增/覆盖数，已提交页保留。日期局部读取失败继续下一日期，全局数据库/进度/会话/取消故障停止。当天漂移不在一次运行内重扫；后续运行重新扫描并幂等补齐。
+
+同步状态增加 `partial_success`（部分成功，15 字符，复用现有 varchar(16)，无需迁移）。有错误且 created+updated>0 为部分成功；有错误无已提交明细为 failed；完整且无错误为 succeeded（包括无符合店铺的数据）。中断仍为 interrupted，不把中断追认为成功。所有终态沿用活动槽释放规则。
+
+`orderCount` 是已验证页的原始列表读取数量；`detailCount`、`created`、`updated` 为已提交明细及其新增/覆盖数量；`daysProcessed` 是完整通过的日期数，不是已尝试日期数。失败日期/页码/阶段写入现有脱敏限长 errorMessage。部分成功不刷新店铺的完整同步统计。
+
+Web 唯一展示位置为“采集采购 → SYB 同步记录”：列表状态、状态筛选及详情支持部分成功，详情保留已保存数量、错误原因与重新同步补齐提示。定时任务日志只表示异步任务受理，不等于最终业务同步成功。

docs/13-deployment-and-operations.md

@@ -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: e936b9e3a5850dea31c139c09e8aca8584d9a6dd
-synchronized_at: 2026-09-07T09:28:03Z
+wiki_revision: df033d06fd94a4b02a447a27ced8d711521342f3
+synchronized_at: 2026-09-08T02:23:08Z
 <!-- gitea-wiki-mirror:end -->
 
 # 部署与运维
@@ -73,12 +73,23 @@ Provider 故障日志只允许记录调用关联 ID、操作类型、耗时、
 
 ## 客户端密钥部署与验证（#237）
 
-实现基线 `71f7751`；2026-09-07 仅完成代码及隔离测试，尚未执行实际数据库迁移、权限写入、服务重启或部署。
+实现基线 `71f7751`；2026-09-07 已按用户授权完成本机 MySQL 迁移、管理员菜单写入和 Server/Web 构建重启；管理页面 HTTP 列表与模块加载已验证。2026-09-08 经用户授权，线上已发布 Server/Web 基线 `d403f3b`，执行迁移 `1788798000000` 并重启 GoAuto/Nginx；迁移记录、两张密钥表、仅管理员菜单关联已回读。HTTP 页面与健康检查通过；未登录管理请求 HTTP 200、业务码 401。真实密钥创建及客户端业务读写闭环尚未验证。
 
 - 发布前须单独授权追加迁移 `server/cmd/migrate/migration/version-local/1788798000000_client_api_key.go`，按既有迁移流程创建 client_api_key、client_api_key_audit 和“采采管理/客户端密钥”管理员菜单。前置父菜单必须存在；不应以赋予普通用户管理员角色代替迁移或权限核验。
-- 用户于 2026-09-07 明确确认默认兼容 HTTP/HTTPS、不设开关并接受明文风险；部署本版本并执行迁移后，现有 `http://185.216.248.75:9527` 可以使用客户端密钥管理及客户端 API。当前并未实际部署，不能据此宣称线上已经可用。HTTP 会明文传输密钥和业务数据，仍建议使用 HTTPS。
+- 用户于 2026-09-07 明确确认默认兼容 HTTP/HTTPS、不设开关并接受明文风险；部署本版本并执行迁移后，现有 `http://185.216.248.75:9527` 可以使用客户端密钥管理及客户端 API。2026-09-08 线上部署及未登录拒绝检查已通过，真实密钥读写验收仍待进行。HTTP 会明文传输密钥和业务数据，仍建议使用 HTTPS。
 - 客户端密钥功能不依赖 GOAUTO_TRUST_FORWARDED_PROTO、X-Forwarded-Proto 或 Agent HTTP 例外。既有其他路由的协议和代理配置保持不变；不伪造协议头，不新增明文放行开关。
 - 代理、APM、应用日志均不得记录 Authorization、创建响应 secret 或原始业务载荷。应用对两类客户端密钥路由跳过旧请求/响应正文日志，使用专用元数据审计；实际代理日志脱敏仍须部署验收。
 - 请求审计 status=0 可能表示在途、进程中断或结果审计更新失败；先按请求关联号核对业务结果，不自动重试采购、采集、同步等操作。停用阻止后续认证，不保证取消已开始的业务操作。
 - 隔离验证：Server `go test ./app/goauto/clientkey ./app/goauto/clientapi ./cmd/migrate/migration/version-local`；Web `pnpm exec jest tests/unit/client-keys.spec.js --runInBand` 与 `pnpm run build:prod`。浏览器模拟入口 `/tests/fixtures/client-keys.html` 仅由本地 Vite 开发服务承载，使用内存模拟请求和无效示例密钥，不连接真实数据库，不证明线上鉴权已验收。
 - 真实部署验收须另行验证实际 HTTP/HTTPS 入口、管理员创建/编辑/停用、普通用户拒绝、读写/独立动作隔离、停用后的后续请求拒绝及日志无密钥；任何真实业务执行继续按独立授权范围进行。
+
+
+## Windows 本机运行目录与 #237 迁移验证（2026-09-07）
+
+- Supervisor 实际配置 `D:/supervisor/programs/goauto.conf`；程序仅 `goauto-admin-api` 和 `goauto-admin-ui`。从已有干净工作区 `D:/OPC/goauto-worktrees/main-runtime` 的 main 分支运行；源码运行基线 `ac3c63e`，版本化启动模板更新提交 `9a10d82`。
+- 原目录 `D:/OPC/goauto` 的用户改动保持原样；本机敏感配置继续读取 `D:/OPC/goauto/config.yaml`，不复制凭据到运行工作区或版本库。数据库 `127.0.0.1:3307/goauto`，API `http://127.0.0.1:8010`，Web `http://127.0.0.1:9527`。
+- API 命令：`pwsh.exe -NoLogo -NoProfile -File "D:/OPC/goauto-worktrees/main-runtime/scripts/start-server.ps1" -ConfigPath "D:/OPC/goauto/config.yaml" -SkipMigration`；Web 同目录 `scripts/start-web.ps1` 与相同 ConfigPath。已验证无需 ExecutionPolicy Bypass。
+- 真实迁移必须单独授权并先确认唯一待执行版本；常驻 API 加 `-SkipMigration`，日常重启不自动执行未来待审核迁移。#237 迁移 `1788798000000_client_api_key.go` 已执行，sys_migration 记录 `1788798000000`、两张密钥表及管理员菜单已回读；其他角色未新增菜单关联。任务启停状态未改。
+- 范围明确的服务控制：`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 另行授权发布，见上节。

scripts/supervisor/goauto.conf

@@ -1,6 +1,6 @@
 [program:goauto-admin-api]
-command=pwsh.exe -NoLogo -NoProfile -ExecutionPolicy Bypass -File "D:/OPC/goauto/scripts/start-server.ps1" -ConfigPath "D:/OPC/goauto/config.yaml"
-directory=D:/OPC/goauto
+command=pwsh.exe -NoLogo -NoProfile -File "D:/OPC/goauto-worktrees/main-runtime/scripts/start-server.ps1" -ConfigPath "D:/OPC/goauto/config.yaml" -SkipMigration
+directory=D:/OPC/goauto-worktrees/main-runtime
 autostart=true
 autorestart=true
 startsecs=3
@@ -14,8 +14,8 @@ stdout_logfile_maxbytes=50MB
 stdout_logfile_backups=5
 
 [program:goauto-admin-ui]
-command=pwsh.exe -NoLogo -NoProfile -ExecutionPolicy Bypass -File "D:/OPC/goauto/scripts/start-web.ps1" -ConfigPath "D:/OPC/goauto/config.yaml"
-directory=D:/OPC/goauto
+command=pwsh.exe -NoLogo -NoProfile -File "D:/OPC/goauto-worktrees/main-runtime/scripts/start-web.ps1" -ConfigPath "D:/OPC/goauto/config.yaml"
+directory=D:/OPC/goauto-worktrees/main-runtime
 autostart=true
 autorestart=true
 startsecs=3

server/app/goauto/sybimport/ai_parse_batch_test.go

@@ -44,6 +44,30 @@ func seedAIParseCandidate(t *testing.T, db *gorm.DB, serverURL string, detailID
 	return applied.SYBProduct
 }
 
+func TestScheduledParseUsesUniqueCandidatesBeforeCallingAI(t *testing.T) {
+	var calls atomic.Int32
+	provider := httptest.NewServer(http.HandlerFunc(func(response http.ResponseWriter, request *http.Request) {
+		calls.Add(1)
+		response.WriteHeader(http.StatusInternalServerError)
+	}))
+	defer provider.Close()
+	db := openTestDB(t)
+	record := seedAIParseCandidate(t, db, provider.URL, 25102, "黑色 XL")
+	run, _, err := sybimport.StartSpecAIParseRun(context.Background(), db, uuid.NewString(), 20)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := sybimport.ProcessSpecAIParseRun(context.Background(), db, run.ID); err != nil {
+		t.Fatal(err)
+	}
+	if err := db.First(&record, record.ID).Error; err != nil {
+		t.Fatal(err)
+	}
+	if record.ParseStatus != models.SYBParseStatusSuccess || record.TargetColor != "黑色" || record.TargetSize != "XL" || record.AIConfirmed || calls.Load() != 0 {
+		t.Fatalf("unique candidate must resolve deterministically, status=%s ai=%v calls=%d", record.ParseStatus, record.AIConfirmed, calls.Load())
+	}
+}
+
 func TestScheduledAIParseConfirmsClosedCandidatesAndDoesNotRepeat(t *testing.T) {
 	var calls atomic.Int32
 	provider := httptest.NewServer(http.HandlerFunc(func(response http.ResponseWriter, request *http.Request) {
@@ -53,7 +77,7 @@ func TestScheduledAIParseConfirmsClosedCandidatesAndDoesNotRepeat(t *testing.T)
 	}))
 	defer provider.Close()
 	db := openTestDB(t)
-	record := seedAIParseCandidate(t, db, provider.URL, 19801, "黑色 XL")
+	record := seedAIParseCandidate(t, db, provider.URL, 19801, "黑 XL")
 	rawBefore := record.RawJSON
 	run, created, err := sybimport.StartSpecAIParseRun(context.Background(), db, uuid.NewString(), 20)
 	if err != nil || !created {
@@ -98,7 +122,7 @@ func TestScheduledAIParseLeavesLowConfidenceUnmatchedForSameFingerprint(t *testi
 	}))
 	defer provider.Close()
 	db := openTestDB(t)
-	record := seedAIParseCandidate(t, db, provider.URL, 19802, "黑色 XL")
+	record := seedAIParseCandidate(t, db, provider.URL, 19802, "黑 XL")
 	for i := 0; i < 2; i++ {
 		run, created, err := sybimport.StartSpecAIParseRun(context.Background(), db, uuid.NewString(), 20)
 		if err != nil || !created {
@@ -175,7 +199,7 @@ func TestScheduledAIParseRetriesProviderFailureAtMostThreeTimes(t *testing.T) {
 	}))
 	defer provider.Close()
 	db := openTestDB(t)
-	record := seedAIParseCandidate(t, db, provider.URL, 19805, "黑色 XL")
+	record := seedAIParseCandidate(t, db, provider.URL, 19805, "黑 XL")
 	for attempt := 1; attempt <= 4; attempt++ {
 		run, created, err := sybimport.StartSpecAIParseRun(context.Background(), db, uuid.NewString(), 20)
 		if err != nil || !created {

server/app/goauto/sybimport/apply.go

@@ -96,6 +96,9 @@ func ApplyDetail(ctx context.Context, db *gorm.DB, order OrderInput, detail Deta
 		if err != nil {
 			return err
 		}
+		if shopeeProduct != nil {
+			parsed = ParseWithCandidates(detail.ProductSpec, shopeeProduct.SpecsJSON)
+		}
 		if parsed.Status == models.SYBParseStatusSuccess && shopeeProduct != nil {
 			if err := mergeParsedSpec(tx, shopeeProduct.ID, parsed); err != nil {
 				return err
@@ -271,6 +274,9 @@ func fillEmptyArchiveFields(tx *gorm.DB, product *models.ShopeeProduct, detail D
 // review but are never pushed into the shared archive, so a messy raw string
 // never pollutes the spec list other screens read from.
 func mergeParsedSpec(tx *gorm.DB, shopeeProductID uint64, parsed ParseResult) error {
+	if parsed.matchedCandidates {
+		return nil
+	}
 	var product models.ShopeeProduct
 	if err := tx.First(&product, shopeeProductID).Error; err != nil {
 		return err

server/app/goauto/sybimport/import_handler.go

@@ -171,6 +171,9 @@ func runImport(db *gorm.DB, runID uint64, request ImportRequest, settings config
 	status := SyncRunSucceeded
 	if err != nil {
 		status = SyncRunFailed
+		if report.Created+report.Updated > 0 {
+			status = SyncRunPartial
+		}
 	}
 	finishCtx, finishCancel := context.WithTimeout(context.Background(), 10*time.Second)
 	defer finishCancel()

server/app/goauto/sybimport/pagination_overlap_test.go

@@ -4,44 +4,9 @@ import (
 	"context"
 	"strings"
 	"testing"
-	"time"
 )
 
-func freezePaginationToday(t *testing.T) {
-	t.Helper()
-	previous := syncNow
-	syncNow = func() time.Time { return time.Date(2026, 8, 29, 12, 0, 0, 0, time.FixedZone("Asia/Shanghai", 8*60*60)) }
-	t.Cleanup(func() { syncNow = previous })
-}
-
-func TestTodayCrossPageOverlapRestartsWithIndependentIDs(t *testing.T) {
-	freezePaginationToday(t)
-	f := &fakeSYB{perDay: map[string]int{"2026-08-29": 4}}
-	f.pageIDs = func(_ string, start, call int) []int64 {
-		if call == 2 {
-			return []int64{1001, 1002}
-		}
-		if call > 2 {
-			return []int64{int64(2000 + start), int64(2001 + start)}
-		}
-		return nil
-	}
-	rows, err := loadDailyListWithRecovery(context.Background(), newSyncClient(t, f), "2026-08-29", 2, 4, 100)
-	if err != nil || len(rows) != 4 || f.listTotalCalls != 2 {
-		t.Fatalf("rows=%d totals=%d err=%v", len(rows), f.listTotalCalls, err)
-	}
-	if got := strings.Join(f.listCalls, ","); got != "2026-08-29:0,2026-08-29:2,2026-08-29:0,2026-08-29:2" {
-		t.Fatalf("did not restart at first page: %s", got)
-	}
-	for index, row := range rows {
-		if row.ID != int64(2000+index) {
-			t.Fatal("rows leaked from abandoned attempt")
-		}
-	}
-}
-
-func TestTodayPersistentOverlapPreservesYesterdayButDoesNotImportToday(t *testing.T) {
-	freezePaginationToday(t)
+func TestTodayOverlapPreservesCommittedPagesWithoutImportingOverlappingPage(t *testing.T) {
 	f := &fakeSYB{perDay: map[string]int{"2026-08-28": 2, "2026-08-29": 4}}
 	f.pageIDs = func(date string, start, _ int) []int64 {
 		if date == "2026-08-29" && start == 2 {
@@ -54,7 +19,7 @@ func TestTodayPersistentOverlapPreservesYesterdayButDoesNotImportToday(t *testin
 	if err == nil {
 		t.Fatal("overlap was treated as successful sync")
 	}
-	for _, token := range []string{"连续 3 次", "跨页重复", "firstPage=1", "firstRow=2", "page=2", "row=1", "start=2", "pageSize=2", "expectedTotal=4", "unique=2"} {
+	for _, token := range []string{"跨页重复", "firstPage=1", "firstRow=2", "page=2", "row=1", "start=2", "pageSize=2", "expectedTotal=4", "unique=2"} {
 		if !strings.Contains(err.Error(), token) {
 			t.Fatalf("missing %s in %v", token, err)
 		}
@@ -62,7 +27,7 @@ func TestTodayPersistentOverlapPreservesYesterdayButDoesNotImportToday(t *testin
 	if strings.Contains(err.Error(), "1001") || strings.Contains(err.Error(), "已保存") {
 		t.Fatalf("unsafe diagnosis/degraded save: %v", err)
 	}
-	if len(f.listCalls) != 7 || f.detailCalls != 1 || report.OrderCount != 2 {
+	if len(f.listCalls) != 3 || f.detailCalls != 2 || report.OrderCount != 4 || report.Created != 2 || report.Updated != 2 {
 		t.Fatalf("unexpected retry/import boundary: pages=%d details=%d orders=%d", len(f.listCalls), f.detailCalls, report.OrderCount)
 	}
 	var count int64
@@ -72,7 +37,6 @@ func TestTodayPersistentOverlapPreservesYesterdayButDoesNotImportToday(t *testin
 }
 
 func TestPaginationHardErrorsDoNotUseOverlapRecovery(t *testing.T) {
-	freezePaginationToday(t)
 	for _, tc := range []struct {
 		name, date, message string
 		page                int
@@ -92,7 +56,7 @@ func TestPaginationHardErrorsDoNotUseOverlapRecovery(t *testing.T) {
 				}
 				return nil
 			}
-			rows, err := loadDailyListWithRecovery(context.Background(), newSyncClient(t, f), tc.date, 2, 4, 100)
+			rows, err := loadDailyList(context.Background(), newSyncClient(t, f), tc.date, 2, 4)
 			if rows != nil || err == nil || !strings.Contains(err.Error(), tc.message) || len(f.listCalls) != tc.calls || f.listTotalCalls != 0 {
 				t.Fatalf("unexpected recovery: rows=%d pages=%d totals=%d err=%v", len(rows), len(f.listCalls), f.listTotalCalls, err)
 			}

server/app/goauto/sybimport/parse.go

@@ -34,6 +34,8 @@ type ParseResult struct {
 	Size   string
 	Status string
 	Note   string
+	// Already present in the archive; do not re-merge or modify mappings.
+	matchedCandidates bool
 }
 
 // Parse implements the #41/#216 rule: split on the last comma, strip 【...】

server/app/goauto/sybimport/parse_candidates.go

@@ -0,0 +1,69 @@
+package sybimport
+
+import (
+	"strings"
+
+	"go-admin/app/goauto/models"
+	"go-admin/app/goauto/shopeeproduct"
+)
+
+// ParseWithCandidates only rescues uncertain parses against previously stored
+// Shopee labels. It never uses the current unconfirmed input as its own evidence.
+func ParseWithCandidates(raw, specsJSON string) ParseResult {
+	baseline := Parse(raw)
+	if baseline.Status != models.SYBParseStatusUncertain {
+		return baseline
+	}
+	specs, err := shopeeproduct.Unmarshal(specsJSON)
+	if err != nil || shopeeproduct.Validate(specs) != nil {
+		return baseline
+	}
+	for _, dimension := range specs {
+		if dimension.Role != shopeeproduct.RoleColor && dimension.Role != shopeeproduct.RoleSize && len(dimension.Values) > 0 {
+			return baseline
+		}
+	}
+	colors, sizes, ambiguous := closedShopeeCandidates(specs)
+	if ambiguous || len(colors)+len(sizes) == 0 {
+		return baseline
+	}
+	if len(colors) == 0 {
+		colors = []string{""}
+	}
+	if len(sizes) == 0 {
+		sizes = []string{""}
+	}
+	input := normalizeCandidateSpec(stripBrackets(raw))
+	type pair struct{ color, size string }
+	matches := map[pair]bool{}
+	for _, color := range colors {
+		for _, size := range sizes {
+			variants := []string{color + "," + size, size + "," + color, color + " " + size, size + " " + color}
+			if color == "" || size == "" {
+				variants = []string{color + size}
+			}
+			for _, variant := range variants {
+				if input == normalizeCandidateSpec(variant) {
+					matches[pair{color, size}] = true
+				}
+			}
+		}
+	}
+	if len(matches) != 1 {
+		return baseline
+	}
+	for match := range matches {
+		return ParseResult{Color: match.color, Size: match.size, Status: models.SYBParseStatusSuccess,
+			Note: "已按蝦皮既有规格候选唯一核对", matchedCandidates: true}
+	}
+	return baseline
+}
+
+func normalizeCandidateSpec(value string) string {
+	value = strings.ReplaceAll(value, "，", ",")
+	parts := strings.Split(value, ",")
+	for i, part := range parts {
+		parts[i] = strings.Join(strings.Fields(part), " ")
+	}
+	return strings.Join(parts, ",")
+}

server/app/goauto/sybimport/parse_candidates_test.go

@@ -0,0 +1,121 @@
+package sybimport_test
+
+import (
+	"context"
+	"encoding/json"
+	"testing"
+
+	"go-admin/app/goauto/models"
+	"go-admin/app/goauto/shopeeproduct"
+	"go-admin/app/goauto/sybimport"
+)
+
+func candidateSpecs(colors, sizes []string) string {
+	dimensions := []shopeeproduct.SpecDimension{}
+	for _, input := range []struct {
+		role   string
+		values []string
+	}{{"color", colors}, {"size", sizes}} {
+		if len(input.values) == 0 {
+			continue
+		}
+		dimension := shopeeproduct.SpecDimension{Name: input.role, Role: input.role}
+		for _, value := range input.values {
+			dimension.Values = append(dimension.Values, shopeeproduct.SpecValue{Name: value, Source: shopeeproduct.ValueSourceImport})
+		}
+		dimensions = append(dimensions, dimension)
+	}
+	encoded, _ := json.Marshal(dimensions)
+	return string(encoded)
+}
+
+func TestCandidateParseRescuesOnlyUniqueWholeInput(t *testing.T) {
+	for _, test := range []struct {
+		name, raw     string
+		colors, sizes []string
+		color, size   string
+	}{
+		{"combined color", "黑色+白色,L", []string{"黑色+白色", "黑色"}, []string{"L", "XL"}, "黑色+白色", "L"},
+		{"spaces in color", "浅  灰色,XL", []string{"浅 灰色"}, []string{"XL"}, "浅 灰色", "XL"},
+		{"full width comma", "黑色，XL", []string{"黑色"}, []string{"XL"}, "黑色", "XL"},
+		{"reverse full width", "XL，黑色", []string{"黑色"}, []string{"XL"}, "黑色", "XL"},
+		{"space separator", "黑色 XL", []string{"黑色"}, []string{"XL"}, "黑色", "XL"},
+		{"size only", "均碼", nil, []string{"均碼"}, "", "均碼"},
+		{"color only", "黑色+白色", []string{"黑色+白色"}, nil, "黑色+白色", ""},
+		{"weight description exact", "黑色，XL 建議55.5-60.0公斤穿", []string{"黑色"}, []string{"XL 建議55.5-60.0公斤穿"}, "黑色", "XL 建議55.5-60.0公斤穿"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			got := sybimport.ParseWithCandidates(test.raw, candidateSpecs(test.colors, test.sizes))
+			if got.Status != models.SYBParseStatusSuccess || got.Color != test.color || got.Size != test.size {
+				t.Fatalf("unexpected parse: %+v", got)
+			}
+		})
+	}
+}
+
+func TestCandidateParsePreservesAmbiguityAndNormalResults(t *testing.T) {
+	for _, test := range []struct{ raw, specs string }{
+		{"", candidateSpecs([]string{"黑色"}, []string{"XL"})},
+		{"黑色 XL", "broken"},
+		{"黑色 XL", "[]"},
+		{"XL", candidateSpecs([]string{"黑色"}, []string{"XL"})},
+		{"黑色+白色 XL", candidateSpecs([]string{"黑色", "白色"}, []string{"XL"})},
+		{"黑色 XL 多余描述", candidateSpecs([]string{"黑色"}, []string{"XL"})},
+		{"黑色 XL 建議55.5-60.0公斤穿", candidateSpecs([]string{"黑色"}, []string{"XL"})},
+		{"黑色，XL", candidateSpecs([]string{"黑色", "XL"}, []string{"XL", "黑色"})},
+		{"浅 灰色 XL", candidateSpecs([]string{"浅 灰色", "浅  灰色"}, []string{"XL"})},
+		{"白色,L", candidateSpecs([]string{"黑色"}, []string{"XL"})},
+		{"黑色 XL", `[{"name":"a","role":"color","values":[{"name":"黑色"}]},{"name":"b","role":"color","values":[{"name":"白色"}]},{"name":"s","role":"size","values":[{"name":"XL"}]}]`},
+		{"黑色 XL", `[{"name":"a","role":"other","values":[{"name":"黑色 XL"}]}]`},
+	} {
+		if got, want := sybimport.ParseWithCandidates(test.raw, test.specs), sybimport.Parse(test.raw); got != want {
+			t.Fatalf("raw %q changed: %+v vs %+v", test.raw, got, want)
+		}
+	}
+}
+
+func TestImportAndReparseReuseExistingCandidatesWithoutChangingMappings(t *testing.T) {
+	db := openTestDB(t)
+	ctx := context.Background()
+	detail := sybimport.DetailInput{ID: 25101, ProductID: 25101, ProductQty: 1, ProductPrice: 1, ProductSpec: "黑色+白色，XL", Raw: json.RawMessage(`{"productSpec":"黑色+白色，XL"}`)}
+	order := sybimport.OrderInput{Code: "test-251", ShopName: "test"}
+	first, err := sybimport.ApplyDetail(ctx, db, order, detail)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if first.SYBProduct.ParseStatus != models.SYBParseStatusUncertain {
+		t.Fatal("must not self-confirm without candidates")
+	}
+	specs := candidateSpecs([]string{"黑色+白色"}, []string{"XL"})
+	if err := db.Model(&models.ShopeeProduct{}).Where("id = ?", *first.SYBProduct.ShopeeProductID).Update("specs_json", specs).Error; err != nil {
+		t.Fatal(err)
+	}
+	outcome, err := sybimport.Reparse(ctx, db, first.SYBProduct.ID, false)
+	if err != nil || outcome.NewStatus != models.SYBParseStatusSuccess {
+		t.Fatalf("reparse: %+v %v", outcome, err)
+	}
+	second, err := sybimport.ApplyDetail(ctx, db, order, detail)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if second.SYBProduct.TargetColor != "黑色+白色" || second.SYBProduct.TargetSize != "XL" || second.SYBProduct.ParseStatus != models.SYBParseStatusSuccess {
+		t.Fatalf("import differs: %+v", second.SYBProduct)
+	}
+	if second.SYBProduct.RawJSON != first.SYBProduct.RawJSON {
+		t.Fatal("raw source changed")
+	}
+	if second.ShopeeProduct.SpecsJSON != specs {
+		t.Fatal("candidate confirmation must not rewrite archive dimensions or mappings")
+	}
+	if _, err := sybimport.ManualCorrect(ctx, db, first.SYBProduct.ID, "人工颜色", "人工尺码"); err != nil {
+		t.Fatal(err)
+	}
+	outcome, err = sybimport.Reparse(ctx, db, first.SYBProduct.ID, false)
+	if err != nil || outcome.Outcome != sybimport.ReparseOutcomeSkippedManual {
+		t.Fatalf("manual overwritten: %+v %v", outcome, err)
+	}
+	third, err := sybimport.ApplyDetail(ctx, db, order, detail)
+	if err != nil || third.SYBProduct.TargetColor != "人工颜色" {
+		t.Fatalf("reimport overwrote manual: %v", err)
+	}
+}

server/app/goauto/sybimport/reparse.go

@@ -77,6 +77,14 @@ func Reparse(ctx context.Context, db *gorm.DB, sybProductID uint64, force bool)
 			return fmt.Errorf("syb product %d: stored raw json is not decodable: %w", record.ID, err)
 		}
 		parsed := Parse(raw.ProductSpec)
+		if parsed.Status == models.SYBParseStatusUncertain && record.ShopeeProductID != nil {
+			var product models.ShopeeProduct
+			if err := tx.First(&product, *record.ShopeeProductID).Error; err == nil {
+				parsed = ParseWithCandidates(raw.ProductSpec, product.SpecsJSON)
+			} else if !errors.Is(err, gorm.ErrRecordNotFound) {
+				return err
+			}
+		}
 		outcome.NewStatus = parsed.Status
 
 		if parsed.Color == record.TargetColor && parsed.Size == record.TargetSize && parsed.Status == record.ParseStatus {

server/app/goauto/sybimport/sync.go

@@ -41,8 +41,7 @@ const (
 	// maxSyncDays bounds one request's window. It is a guard against a typo in
 	// the date range turning into tens of thousands of remote reads before
 	// MaxMatches trips.
-	maxSyncDays              = 31
-	maxTodaySnapshotAttempts = 3
+	maxSyncDays = 31
 )
 
 // SyncReport summarises one sync run.
@@ -82,8 +81,6 @@ type SyncProgress struct {
 	DaysProcessed int
 }
 
-var syncNow = time.Now
-
 type ProgressFunc func(SyncProgress) error
 
 type snapshotDriftError struct {
@@ -94,14 +91,6 @@ type snapshotDriftError struct {
 
 func (err *snapshotDriftError) Error() string { return err.message }
 
-func shanghaiToday() string {
-	location, err := time.LoadLocation("Asia/Shanghai")
-	if err != nil {
-		location = time.FixedZone("Asia/Shanghai", 8*60*60)
-	}
-	return syncNow().In(location).Format("2006-01-02")
-}
-
 // Sync pulls every shipment order in [dateFrom, dateTo] and folds each detail
 // line into the SYB/Shopee archive through ApplyDetail.
 //
@@ -109,16 +98,10 @@ func shanghaiToday() string {
 // a separate concern (see Connect); a session that dies mid-run surfaces as
 // sybclient.ErrSessionInvalid and is treated like any other mid-run failure.
 //
-// `[必须]` Failure stops the run immediately. Rows already written are NOT
-// rolled back — ApplyDetail is idempotent on (order_code, detail_id), so a
-// re-run overwrites them rather than duplicating. What must not happen is
-// reporting a partial run as a complete one, which would let the missing
-// orders go unnoticed forever.
-//
-// `[必须]` Every day is verified for completeness before anything is written:
-// the per-day total is re-read after paging and must not have drifted. SYB's
-// list endpoint returns the *page* size in `total` (§4.3, confirmed against
-// live data), so the paging loop is driven by listTotal, never by list.total.
+// Each validated page is committed independently. Date-local read failures
+// preserve committed pages and allow later dates to run. Database, cancellation
+// and progress persistence failures stop the run. Completeness is verified at
+// the end of each date; partial results must never be reported as full success.
 func Sync(ctx context.Context, db *gorm.DB, client *sybclient.Client, cfg SyncConfig, dateFrom, dateTo string) (SyncReport, error) {
 	return SyncWithProgress(ctx, db, client, cfg, dateFrom, dateTo, nil)
 }
@@ -190,106 +173,38 @@ func SyncWithShopSnapshot(ctx context.Context, db *gorm.DB, client *sybclient.Cl
 		plans = append(plans, dayPlan{date: date, total: total})
 	}
 
-	for dayIndex, plan := range plans {
-		if plan.total == 0 {
-			if err := emit(dayIndex + 1); err != nil {
-				return report, err
-			}
-			continue
-		}
-		// `[必须]` Completeness first, filtering second. loadDailyList proves the
-		// day's snapshot is whole; filtering before that would let drift among
-		// other shops' orders hide a hole in the ones we do want
-		// (docs/12-syb-erp-interface.md §8).
-		rows, listErr := loadDailyListWithRecovery(ctx, client, plan.date, pageSize, plan.total, maxMatches)
-		if listErr != nil && len(rows) == 0 {
-			return report, listErr
-		}
-		report.OrderCount += len(rows)
-
-		byID := make(map[int64]sybclient.StockRow, len(rows))
-		ids := make([]int64, 0, len(rows))
-		for _, row := range rows {
-			name := stringField(row.Raw, "shopName")
-			label := name
-			if sybshop.IsBlank(label) {
-				label = "(无店铺名)"
-			}
-			display, ok := allowed[sybshop.Normalize(name)]
-			if ok {
-				label = display
-			}
-			if !ok {
-				entry := report.ShopBreakdown[label]
-				entry.Skipped++
-				report.ShopBreakdown[label] = entry
-				report.ShopSkipped++
-				continue
-			}
-			entry := report.ShopBreakdown[label]
-			entry.Accepted++
-			report.ShopBreakdown[label] = entry
-			report.AcceptedCount++
-			byID[row.ID] = row
-			ids = append(ids, row.ID)
-		}
-		if len(ids) == 0 {
-			if err := emit(dayIndex + 1); err != nil {
-				return report, err
-			}
-			continue
-		}
-
-		for start := 0; start < len(ids); start += detailBatch {
-			end := start + detailBatch
-			if end > len(ids) {
-				end = len(ids)
-			}
-			batch := ids[start:end]
-			details, err := client.DetailListByStock(ctx, batch)
-			if err != nil {
-				return report, fmt.Errorf("拉取 %s 货运单明细失败（本次同步停止；"+
-					"已写入的数据保留，重跑会按 (order_code, detail_id) 覆盖）: %w", plan.date, err)
-			}
-			if err := validateDetailBatch(batch, details); err != nil {
-				return report, fmt.Errorf("%s 货运单明细不完整：%w；本次同步停止", plan.date, err)
-			}
-			for _, detail := range details {
-				// `[必须]` Re-check the shop on the detail response. The list said
-				// this order belongs to an enabled shop; if the detail disagrees,
-				// the two views are inconsistent and importing it would write a
-				// row for a shop nobody enabled.
-				name := stringField(detail.Raw, "shopName")
-				if sybshop.IsBlank(name) {
-					moveAcceptedToSkipped(&report, stringField(byID[detail.ID].Raw, "shopName"), "(无店铺名)", allowed)
-					report.AcceptedCount--
-					report.ShopSkipped++
-					continue
-				}
-				if _, ok := allowed[sybshop.Normalize(name)]; !ok {
-					moveAcceptedToSkipped(&report, stringField(byID[detail.ID].Raw, "shopName"), name, allowed)
-					report.AcceptedCount--
-					report.ShopSkipped++
-					continue
-				}
-				if err := applyStockDetail(ctx, db, byID[detail.ID], detail, &report); err != nil {
-					return report, err
-				}
-			}
-			if err := emit(dayIndex); err != nil {
-				return report, err
-			}
-		}
-		if listErr != nil {
-			return report, listErr
-		}
-		if err := emit(dayIndex + 1); err != nil {
+	daysCompleted := 0
+	var failures []error
+	for _, plan := range plans {
+		if err := ctx.Err(); err != nil {
 			return report, err
 		}
+		_, dayErr := loadDailyList(ctx, client, plan.date, pageSize, plan.total, func(rows []sybclient.StockRow, page int) error {
+			report.OrderCount += len(rows)
+			err := importSyncPage(ctx, db, client, rows, allowed, &report)
+			if err != nil {
+				return fmt.Errorf("%s 第 %d 页明细/入库阶段失败: %w", plan.date, page, err)
+			}
+			if err := emit(daysCompleted); err != nil {
+				return &syncFatalError{err}
+			}
+			return nil
+		})
+		if dayErr != nil {
+			failures = append(failures, dayErr)
+			var fatal *syncFatalError
+			if ctx.Err() != nil || errors.As(dayErr, &fatal) || errors.Is(dayErr, sybclient.ErrSessionInvalid) {
+				return report, errors.Join(failures...)
+			}
+			continue
+		}
+		daysCompleted++
+		if err := emit(daysCompleted); err != nil {
+			return report, errors.Join(append(failures, err)...)
+		}
 	}
-
 	report.FinishedAt = time.Now().UTC()
-	return report, nil
+	return report, errors.Join(failures...)
 }
 
 func shopSnapshotNames(allowed map[string]string) []string {
@@ -336,39 +251,7 @@ func moveAcceptedToSkipped(report *SyncReport, listName, detailName string, allo
 // `[必须]` The loop bound comes from expectedTotal (listTotal), because
 // list.total is the current page's row count, not the filtered total (§4.3).
 // Driving the loop with the response's own total would stop after page one.
-func loadDailyListWithRecovery(ctx context.Context, client *sybclient.Client, date string, pageSize, expectedTotal, maxMatches int) ([]sybclient.StockRow, error) {
-	if date != shanghaiToday() {
-		return loadDailyList(ctx, client, date, pageSize, expectedTotal)
-	}
-	var last *snapshotDriftError
-	for attempt := 1; attempt <= maxTodaySnapshotAttempts; attempt++ {
-		if attempt > 1 {
-			total, err := client.ListTotal(ctx, date, date, pageSize)
-			if err != nil {
-				return nil, fmt.Errorf("重新查询今天 %s 货运单总数失败: %w", date, err)
-			}
-			if total > maxMatches {
-				return nil, fmt.Errorf("今天 %s 的货运单总数 %d 超过单次同步上限 %d", date, total, maxMatches)
-			}
-			expectedTotal = total
-		}
-		rows, err := loadDailyList(ctx, client, date, pageSize, expectedTotal)
-		if err == nil {
-			return rows, nil
-		}
-		var drift *snapshotDriftError
-		if !errors.As(err, &drift) {
-			return nil, fmt.Errorf("今天第 %d/%d 次拉取失败: %w", attempt, maxTodaySnapshotAttempts, err)
-		}
-		last = drift
-	}
-	if last != nil && last.valid && len(last.rows) > 0 {
-		return last.rows, fmt.Errorf("今天持续变化，已保存本次取得的完整明细，但未形成稳定快照；下次同步继续覆盖: %w", last)
-	}
-	return nil, fmt.Errorf("今天持续变化，连续 %d 次未形成稳定快照，本次同步停止: %w", maxTodaySnapshotAttempts, last)
-}
-
-func loadDailyList(ctx context.Context, client *sybclient.Client, date string, pageSize, expectedTotal int) ([]sybclient.StockRow, error) {
+func loadDailyList(ctx context.Context, client *sybclient.Client, date string, pageSize, expectedTotal int, consume ...func([]sybclient.StockRow, int) error) ([]sybclient.StockRow, error) {
 	rows := make([]sybclient.StockRow, 0, expectedTotal)
 	type position struct{ page, row int }
 	seen := make(map[int64]position, expectedTotal)
@@ -413,6 +296,11 @@ func loadDailyList(ctx context.Context, client *sybclient.Client, date string, p
 		if len(page) != expectedPageCount {
 			return nil, &snapshotDriftError{message: fmt.Sprintf("%s 货运单列表第 %d 页不完整且相对初始总数发生变化：预期 %d 行，实际 %d 行", date, pageIndex, expectedPageCount, len(page)), rows: rows, valid: len(page) > expectedPageCount}
 		}
+		if len(consume) > 0 {
+			if err := consume[0](page, pageIndex); err != nil {
+				return nil, err
+			}
+		}
 	}
 
 	// Re-read the total: if it moved while we paged, some order was inserted or

server/app/goauto/sybimport/sync_page.go

@@ -0,0 +1,83 @@
+package sybimport
+
+import (
+	"context"
+	"go-admin/app/goauto/sybclient"
+	"go-admin/app/goauto/sybshop"
+	"gorm.io/gorm"
+)
+
+// Database/progress errors stop the entire run, not merely the current date.
+type syncFatalError struct{ error }
+
+func (e *syncFatalError) Unwrap() error { return e.error }
+
+// Read all remote details before opening a page transaction. Publish counters
+// only after commit, so a rollback never reports records as saved.
+func importSyncPage(ctx context.Context, db *gorm.DB, client *sybclient.Client, rows []sybclient.StockRow, allowed map[string]string, report *SyncReport) error {
+	next := *report
+	next.ShopBreakdown = make(map[string]ShopBreakdown, len(report.ShopBreakdown))
+	for k, v := range report.ShopBreakdown {
+		next.ShopBreakdown[k] = v
+	}
+	byID := make(map[int64]sybclient.StockRow)
+	var ids []int64
+	for _, row := range rows {
+		name := stringField(row.Raw, "shopName")
+		label := name
+		if sybshop.IsBlank(label) {
+			label = "(无店铺名)"
+		}
+		display, ok := allowed[sybshop.Normalize(name)]
+		if ok {
+			label = display
+		}
+		entry := next.ShopBreakdown[label]
+		if ok {
+			entry.Accepted++
+			next.AcceptedCount++
+			ids = append(ids, row.ID)
+			byID[row.ID] = row
+		} else {
+			entry.Skipped++
+			next.ShopSkipped++
+		}
+		next.ShopBreakdown[label] = entry
+	}
+	var details []sybclient.StockDetail
+	for start := 0; start < len(ids); start += detailBatch {
+		end := start + detailBatch
+		if end > len(ids) {
+			end = len(ids)
+		}
+		batch, err := client.DetailListByStock(ctx, ids[start:end])
+		if err != nil {
+			return err
+		}
+		if err := validateDetailBatch(ids[start:end], batch); err != nil {
+			return err
+		}
+		details = append(details, batch...)
+	}
+	err := db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+		for _, detail := range details {
+			name := stringField(detail.Raw, "shopName")
+			_, ok := allowed[sybshop.Normalize(name)]
+			if sybshop.IsBlank(name) || !ok {
+				moveAcceptedToSkipped(&next, stringField(byID[detail.ID].Raw, "shopName"), name, allowed)
+				next.AcceptedCount--
+				next.ShopSkipped++
+				continue
+			}
+			if err := applyStockDetail(ctx, tx, byID[detail.ID], detail, &next); err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		return &syncFatalError{err}
+	}
+	*report = next
+	return nil
+}

server/app/goauto/sybimport/sync_page_test.go

@@ -0,0 +1,117 @@
+package sybimport
+
+import (
+	"context"
+	"errors"
+	"go-admin/app/goauto/models"
+	"strings"
+	"testing"
+)
+
+func TestPageFailurePreservesEarlierPagesContinuesDatesAndRerunsIdempotently(t *testing.T) {
+	db := newSyncTestDB(t)
+	f := &fakeSYB{perDay: map[string]int{"2026-08-01": 3, "2026-08-02": 1}, shortPageAtIndex: 2}
+	var last SyncProgress
+	report, err := SyncWithProgress(context.Background(), db, newSyncClient(t, f), SyncConfig{PageSize: 2, MaxMatches: 100}, "2026-08-01", "2026-08-02", func(p SyncProgress) error { last = p; return nil })
+	if err == nil || !strings.Contains(err.Error(), "第 2 页") || report.Created != 2 || report.Updated != 1 || last.DaysProcessed != 1 {
+		t.Fatalf("report=%+v progress=%+v err=%v", report, last, err)
+	}
+	var count int64
+	db.Model(&models.SYBProduct{}).Count(&count)
+	if count != 2 {
+		t.Fatal(count)
+	}
+	f.shortPageAtIndex = 0
+	report, err = Sync(context.Background(), db, newSyncClient(t, f), SyncConfig{PageSize: 2, MaxMatches: 100}, "2026-08-01", "2026-08-02")
+	if err != nil || report.Created != 1 || report.Updated != 3 {
+		t.Fatalf("rerun=%+v err=%v", report, err)
+	}
+	db.Model(&models.SYBProduct{}).Count(&count)
+	if count != 3 {
+		t.Fatal(count)
+	}
+}
+
+func TestPageTransactionRollbackDoesNotPublishCountersAndStopsDates(t *testing.T) {
+	db := newSyncTestDB(t)
+	if err := db.Exec("CREATE TRIGGER reject_second BEFORE INSERT ON syb_product WHEN NEW.detail_id = 10011 BEGIN SELECT RAISE(ABORT, 'test database failure'); END").Error; err != nil {
+		t.Fatal(err)
+	}
+	f := &fakeSYB{perDay: map[string]int{"2026-08-01": 3, "2026-08-02": 1}}
+	report, err := Sync(context.Background(), db, newSyncClient(t, f), SyncConfig{PageSize: 2, MaxMatches: 100}, "2026-08-01", "2026-08-02")
+	var fatal *syncFatalError
+	if !errors.As(err, &fatal) || report.Created != 0 || report.DetailCount != 0 || len(f.listCalls) != 1 {
+		t.Fatalf("report=%+v calls=%v err=%v", report, f.listCalls, err)
+	}
+	var count int64
+	db.Model(&models.SYBProduct{}).Count(&count)
+	if count != 0 {
+		t.Fatal(count)
+	}
+}
+
+func TestPageProgressFailureStopsAfterCommittedPage(t *testing.T) {
+	db := newSyncTestDB(t)
+	f := &fakeSYB{perDay: map[string]int{"2026-08-01": 3, "2026-08-02": 1}}
+	calls := 0
+	report, err := SyncWithProgress(context.Background(), db, newSyncClient(t, f), SyncConfig{PageSize: 2, MaxMatches: 100}, "2026-08-01", "2026-08-02", func(SyncProgress) error {
+		calls++
+		if calls == 2 {
+			return errors.New("progress unavailable")
+		}
+		return nil
+	})
+	if err == nil || report.Created != 2 || len(f.listCalls) != 1 {
+		t.Fatalf("report=%+v err=%v", report, err)
+	}
+}
+
+func TestPageMissingDetailPreservesPriorPageAndContinuesNextDate(t *testing.T) {
+	db := newSyncTestDB(t)
+	f := &fakeSYB{perDay: map[string]int{"2026-08-01": 3, "2026-08-02": 1}, detailDropID: 1002}
+	report, err := Sync(context.Background(), db, newSyncClient(t, f), SyncConfig{PageSize: 2, MaxMatches: 100}, "2026-08-01", "2026-08-02")
+	if err == nil || report.Created != 2 || report.Updated != 1 || report.OrderCount != 4 || len(f.listCalls) != 3 {
+		t.Fatalf("report=%+v err=%v", report, err)
+	}
+}
+
+func TestPageCancellationPreservesCommitAndStopsNextPage(t *testing.T) {
+	db := newSyncTestDB(t)
+	f := &fakeSYB{perDay: map[string]int{"2026-08-01": 3, "2026-08-02": 1}}
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	report, err := SyncWithProgress(ctx, db, newSyncClient(t, f), SyncConfig{PageSize: 2, MaxMatches: 100}, "2026-08-01", "2026-08-02", func(p SyncProgress) error {
+		if p.Report.Created > 0 {
+			cancel()
+		}
+		return nil
+	})
+	if !errors.Is(err, context.Canceled) || report.Created != 2 || len(f.listCalls) != 1 {
+		t.Fatalf("report=%+v err=%v", report, err)
+	}
+}
+
+func TestPartialFinishPreservesProgressReleasesSlotAndIsFilterable(t *testing.T) {
+	db := newSyncTestDB(t)
+	ctx := context.Background()
+	s := NewSyncRunService(db)
+	run, err := s.Create(ctx, CreateSyncRunInput{DateFrom: "2026-08-01", DateTo: "2026-08-02"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	report := SyncReport{Created: 2, DetailCount: 2, ShopBreakdown: map[string]ShopBreakdown{}}
+	if err := s.UpdateProgress(ctx, run.ID, SyncProgress{Report: report, DaysTotal: 2, DaysProcessed: 1}); err != nil {
+		t.Fatal(err)
+	}
+	if err := s.Finish(ctx, run.ID, SyncRunPartial, report, errors.New("第 2 页失败")); err != nil {
+		t.Fatal(err)
+	}
+	row, err := s.Detail(ctx, run.ID)
+	if err != nil || row.Status != SyncRunPartial || row.ActiveSlot != nil || row.ProgressPercent != 50 || row.Created != 2 {
+		t.Fatalf("row=%+v err=%v", row, err)
+	}
+	result, err := s.List(ctx, SyncRunListRequest{Page: 1, PageSize: 20, Status: SyncRunPartial})
+	if err != nil || result.Total != 1 {
+		t.Fatalf("result=%+v err=%v", result, err)
+	}
+}

server/app/goauto/sybimport/sync_run.go

@@ -18,6 +18,7 @@ import (
 const (
 	SyncRunRunning     = "running"
 	SyncRunSucceeded   = "succeeded"
+	SyncRunPartial     = "partial_success"
 	SyncRunFailed      = "failed"
 	SyncRunInterrupted = "interrupted"
 )
@@ -75,7 +76,7 @@ func (s *SyncRunService) UpdateProgress(ctx context.Context, id uint64, progress
 }
 
 func (s *SyncRunService) Finish(ctx context.Context, id uint64, status string, report SyncReport, runErr error) error {
-	if status != SyncRunSucceeded && status != SyncRunFailed {
+	if status != SyncRunSucceeded && status != SyncRunPartial && status != SyncRunFailed {
 		return fmt.Errorf("invalid terminal sync status %q", status)
 	}
 	payload, err := marshalSyncRunPayload(report.ShopBreakdown, report.ShopFilterSnapshot)

server/app/goauto/sybimport/sync_run_handler.go

@@ -20,7 +20,7 @@ func (handler Handler) ListSyncRuns(c *gin.Context) {
 		return
 	}
 	status := strings.TrimSpace(c.Query("status"))
-	if status != "" && status != SyncRunRunning && status != SyncRunSucceeded && status != SyncRunFailed && status != SyncRunInterrupted {
+	if status != "" && status != SyncRunRunning && status != SyncRunSucceeded && status != SyncRunPartial && status != SyncRunFailed && status != SyncRunInterrupted {
 		writeError(c, invalidRequest("status 无效"))
 		return
 	}

server/app/goauto/sybimport/sync_run_handler_test.go

@@ -36,4 +36,12 @@ func TestSyncRunListAndDetailHandlers(t *testing.T) {
 	if detail.Code != http.StatusOK || !strings.Contains(detail.Body.String(), `"operatorName":"管理员"`) {
 		t.Fatalf("详情响应不正确: %d %s", detail.Code, detail.Body.String())
 	}
+	if err := NewSyncRunService(db).Finish(context.Background(), run.ID, SyncRunPartial, SyncReport{Created: 1}, nil); err != nil {
+		t.Fatal(err)
+	}
+	partial := httptest.NewRecorder()
+	engine.ServeHTTP(partial, httptest.NewRequest(http.MethodGet, "/sync-runs?status=partial_success", nil))
+	if partial.Code != http.StatusOK || !strings.Contains(partial.Body.String(), `"total":1`) {
+		t.Fatalf("partial filter: %d %s", partial.Code, partial.Body.String())
+	}
 }

server/app/goauto/sybimport/sync_test.go

@@ -9,7 +9,6 @@ import (
 	"net/http/httptest"
 	"strings"
 	"testing"
-	"time"
 
 	"go-admin/app/goauto/migrations"
 	"go-admin/app/goauto/models"
@@ -276,39 +275,6 @@ func TestSyncStopsWhenTotalDriftsDuringPaging(t *testing.T) {
 	}
 }
 
-func TestTodaySnapshotDriftRetriesFromFirstPage(t *testing.T) {
-	originalNow := syncNow
-	syncNow = func() time.Time { return time.Date(2026, 8, 29, 12, 0, 0, 0, time.FixedZone("Asia/Shanghai", 8*60*60)) }
-	t.Cleanup(func() { syncNow = originalNow })
-	f := &fakeSYB{perDay: map[string]int{"2026-08-29": 10}, totalOverride: map[int]int{1: 11, 2: 10, 3: 10}}
-	rows, err := loadDailyListWithRecovery(context.Background(), newSyncClient(t, f), "2026-08-29", 10, 10, 1000)
-	if err != nil || len(rows) != 10 || f.listTotalCalls != 3 {
-		t.Fatalf("rows=%d totalCalls=%d err=%v", len(rows), f.listTotalCalls, err)
-	}
-}
-
-func TestTodayThirdDriftReturnsValidLastListForDegradedSave(t *testing.T) {
-	originalNow := syncNow
-	syncNow = func() time.Time { return time.Date(2026, 8, 29, 12, 0, 0, 0, time.FixedZone("Asia/Shanghai", 8*60*60)) }
-	t.Cleanup(func() { syncNow = originalNow })
-	f := &fakeSYB{perDay: map[string]int{"2026-08-29": 10}, totalOverride: map[int]int{1: 11, 2: 10, 3: 11, 4: 10, 5: 11}}
-	rows, err := loadDailyListWithRecovery(context.Background(), newSyncClient(t, f), "2026-08-29", 10, 10, 1000)
-	if err == nil || len(rows) != 10 || !strings.Contains(err.Error(), "已保存本次取得的完整明细") {
-		t.Fatalf("rows=%d err=%v", len(rows), err)
-	}
-}
-
-func TestHistoricalSnapshotDriftDoesNotRetry(t *testing.T) {
-	originalNow := syncNow
-	syncNow = func() time.Time { return time.Date(2026, 8, 29, 12, 0, 0, 0, time.FixedZone("Asia/Shanghai", 8*60*60)) }
-	t.Cleanup(func() { syncNow = originalNow })
-	f := &fakeSYB{perDay: map[string]int{"2026-08-28": 10}, totalOverride: map[int]int{1: 11}}
-	rows, err := loadDailyListWithRecovery(context.Background(), newSyncClient(t, f), "2026-08-28", 10, 10, 1000)
-	if err == nil || rows != nil || f.listTotalCalls != 1 {
-		t.Fatalf("rows=%v totalCalls=%d err=%v", rows, f.listTotalCalls, err)
-	}
-}
-
 // 某页行数少于预期同样是不完整快照。
 func TestSyncStopsOnShortPage(t *testing.T) {
 	db := newSyncTestDB(t)

web/src/views/goauto/syb-sync-runs/index.vue

@@ -36,8 +36,9 @@
       <el-drawer v-model="detail.open" title="同步记录详情" size="760px">
         <div v-loading="detail.loading" class="drawer-body">
           <template v-if="detail.item">
-            <el-alert v-if="detail.item.status === 'failed' || detail.item.status === 'interrupted'" :title="detail.item.errorMessage || statusMeta(detail.item.status).label" :type="detail.item.status === 'failed' ? 'error' : 'warning'" show-icon :closable="false" class="notice" />
+            <el-alert v-if="detail.item.status === 'failed' || detail.item.status === 'interrupted' || detail.item.status === 'partial_success'" :title="detail.item.errorMessage || statusMeta(detail.item.status).label" :type="detail.item.status === 'failed' ? 'error' : 'warning'" show-icon :closable="false" class="notice" />
             <el-alert v-else-if="detail.item.status === 'running'" title="任务正在后台运行，关闭本页不会中断导入。" type="info" show-icon :closable="false" class="notice" />
+            <el-alert v-if="detail.item.status === 'partial_success'" title="已保存的数据会保留。请重新同步该日期范围补齐缺失数据；重跑不会重复新增相同明细。" type="warning" show-icon :closable="false" class="notice" />
             <el-descriptions :column="2" border>
               <el-descriptions-item label="记录编号">{{ detail.item.id }}</el-descriptions-item>
               <el-descriptions-item label="状态"><el-tag :type="statusMeta(detail.item.status).type">{{ statusMeta(detail.item.status).label }}</el-tag></el-descriptions-item>
@@ -81,7 +82,7 @@ export default {
       detail: { open: false, loading: false, item: null },
       statusOptions: [
         { label: '执行中', value: 'running' }, { label: '成功', value: 'succeeded' },
-        { label: '失败', value: 'failed' }, { label: '已中断', value: 'interrupted' }
+        { label: '部分成功', value: 'partial_success' }, { label: '失败', value: 'failed' }, { label: '已中断', value: 'interrupted' }
       ]
     }
   },
@@ -92,7 +93,7 @@ export default {
   created() { this.load().then(() => { const id = Number(this.$route.query.runId); if (id > 0) this.openDetail(id) }) },
   beforeUnmount() { this.stopPolling() },
   methods: {
-    statusMeta(status) { return { running: { label: '执行中', type: 'primary' }, succeeded: { label: '成功', type: 'success' }, failed: { label: '失败', type: 'danger' }, interrupted: { label: '已中断', type: 'warning' }}[status] || { label: status || '-', type: 'info' } },
+    statusMeta(status) { return { running: { label: '执行中', type: 'primary' }, succeeded: { label: '成功', type: 'success' }, partial_success: { label: '部分成功', type: 'warning' }, failed: { label: '失败', type: 'danger' }, interrupted: { label: '已中断', type: 'warning' }}[status] || { label: status || '-', type: 'info' } },
     formatTime(value) { if (!value) return '—'; return new Date(value).toLocaleString('zh-CN', { hour12: false }) },
     async load() {
       this.loading = true; this.loadError = ''

web/tests/e2e/syb-sync-run.spec.ts

@@ -6,6 +6,34 @@ async function authenticate(context: any) {
 
 const syncMenu = [{ path: '/syb-sync-runs', component: 'Layout', visible: '0', menuName: 'SybSync', title: 'SYB 同步', children: [{ path: 'index', component: '/goauto/syb-sync-runs/index', visible: '0', menuName: 'GoAutoSybSyncRuns', title: 'SYB 同步记录' }] }];
 
+test('部分成功可筛选并查看已保存数量和补齐提示', async ({ page, context }) => {
+  await authenticate(context);
+  const item = { id: 239, status: 'partial_success', dateFrom: '2026-08-01', dateTo: '2026-08-02', daysProcessed: 1, daysTotal: 2, progressPercent: 50, created: 2, updated: 1, orderCount: 3, detailCount: 3, acceptedCount: 3, shopSkipped: 0, errorMessage: '2026-08-01 第 2 页读取失败', shopBreakdown: [] };
+  let selected = '';
+  await page.route('**/api/**', route => {
+    const url = new URL(route.request().url());
+    if (url.pathname.startsWith('/src/api/')) return route.continue();
+    if (url.pathname.endsWith('/getinfo')) return route.fulfill({ json: { code: 200, data: { roles: ['purchaser'], name: '测试用户', avatar: '', introduction: '', permissions: [] } } });
+    if (url.pathname.endsWith('/sync-runs/239')) return route.fulfill({ json: { code: 200, data: { item } } });
+    if (url.pathname.endsWith('/sync-runs')) { selected = url.searchParams.get('status') || ''; return route.fulfill({ json: { code: 200, data: { items: [item], total: 1 } } }); }
+    return route.fulfill({ json: { code: 200, data: url.pathname.endsWith('/menurole') ? syncMenu : [] } });
+  });
+  await page.goto('/#/syb-sync-runs/index');
+  await expect(page.locator('.el-table').getByText('部分成功')).toBeVisible();
+  await page.locator('.search-form .el-select').click();
+  await page.getByRole('option', { name: '部分成功' }).click();
+  await page.getByRole('button', { name: '查询', exact: true }).click();
+  await expect.poll(() => selected).toBe('partial_success');
+  await page.getByRole('button', { name: '详情', exact: true }).click();
+  await expect(page.getByText(item.errorMessage)).toBeVisible();
+  await expect(page.getByText('已保存的数据会保留。', { exact: false })).toBeVisible();
+  await expect(page.locator('.el-drawer').getByText('2 / 1', { exact: true })).toBeVisible();
+  await expect.poll(async () => {
+    const box = await page.locator('.el-drawer').boundingBox();
+    return box ? Math.round(box.x + box.width) : 0;
+  }).toBe(page.viewportSize()!.width);
+});
+
 test('同步记录展示失败原因和按店铺统计', async ({ page, context }) => {
   await authenticate(context);
   await page.route('**/api/**', async route => {