fix(android): settle before spec gesture retry (#268)

android/app/build.gradle.kts

@@ -11,8 +11,8 @@ android {
         applicationId = "cn.ilapage.goauto.agent"
         minSdk = 23
         targetSdk = 34
-        versionCode = 54
-        versionName = "0.9.41"
+        versionCode = 72
+        versionName = "0.9.59"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
 

android/app/src/main/java/cn/ilapage/goauto/agent/automation/GoAutoAccessibilityService.kt

@@ -330,6 +330,42 @@ class GoAutoAccessibilityService : AccessibilityService(), UiDriver, PddCollecto
         }
     }
 
+    override fun clickAddressEntryFresh(target: SnapshotNode): FreshClickOutcome {
+        val root = rootInActiveWindow ?: return FreshClickOutcome(FreshActionResult.NOT_FOUND, FreshClickReason.ROOT_UNAVAILABLE)
+        val indexes = target.path.split('/').mapNotNull(String::toIntOrNull)
+        if (indexes.isEmpty() || indexes.first() != 0 || indexes.size != target.path.split('/').size) {
+            return FreshClickOutcome(FreshActionResult.NOT_FOUND, FreshClickReason.TARGET_NOT_FOUND)
+        }
+        var node = root
+        for (index in indexes.drop(1)) {
+            node = node.getChild(index)
+                ?: return FreshClickOutcome(FreshActionResult.NOT_FOUND, FreshClickReason.TARGET_NOT_FOUND)
+        }
+        val bounds = Rect().also(node::getBoundsInScreen)
+        if (!node.isVisibleToUser || !node.isEnabled ||
+            node.preferredOrDescendantLabel() != target.label ||
+            node.className?.toString() != target.className ||
+            kotlin.math.abs(bounds.centerX() - target.bounds.centerX) > 32 ||
+            kotlin.math.abs(bounds.centerY() - target.bounds.centerY) > 32
+        ) {
+            return FreshClickOutcome(FreshActionResult.NOT_FOUND, FreshClickReason.TARGET_NOT_FOUND)
+        }
+        var ancestorDepth = 0
+        while (!node.isClickable) {
+            node = node.parent ?: return FreshClickOutcome(
+                FreshActionResult.FAILED,
+                FreshClickReason.NO_CLICKABLE_ANCESTOR,
+                clickableAncestorDepth = ancestorDepth,
+            )
+            ancestorDepth++
+        }
+        return if (node.performAction(AccessibilityNodeInfo.ACTION_CLICK)) {
+            FreshClickOutcome(FreshActionResult.SUCCESS, FreshClickReason.SUCCESS, 1, ancestorDepth)
+        } else {
+            FreshClickOutcome(FreshActionResult.FAILED, FreshClickReason.ACTION_CLICK_FALSE, 1, ancestorDepth)
+        }
+    }
+
     override fun tapPurchaseFresh(target: SnapshotNode): FreshActionResult {
         val root = rootInActiveWindow ?: return FreshActionResult.NOT_FOUND
         val candidates = mutableListOf<AccessibilityNodeInfo>()
@@ -414,17 +450,27 @@ class GoAutoAccessibilityService : AccessibilityService(), UiDriver, PddCollecto
 
     override fun swipePurchaseIn(target: SnapshotNode, direction: SwipeDirection, durationMs: Long): Boolean {
         val root = rootInActiveWindow ?: return false
-        val matches = mutableListOf<AccessibilityNodeInfo>()
-        walk(root) { node ->
-            val bounds = Rect().also(node::getBoundsInScreen)
-            if (node.isVisibleToUser && node.isEnabled && node.isScrollable &&
-                node.className?.toString() == target.className &&
-                kotlin.math.abs(bounds.centerX() - target.bounds.centerX) <= 32 &&
-                kotlin.math.abs(bounds.centerY() - target.bounds.centerY) <= 32
-            ) matches += node
+        val candidates = mutableListOf<PurchaseScrollCandidate>()
+        val liveNodes = mutableMapOf<String, AccessibilityNodeInfo>()
+        fun visit(node: AccessibilityNodeInfo, path: String) {
+            if (node.isVisibleToUser && node.isEnabled && node.isScrollable) {
+                val bounds = Rect().also(node::getBoundsInScreen)
+                candidates += PurchaseScrollCandidate(
+                    path, node.className?.toString(),
+                    NodeBounds(bounds.left, bounds.top, bounds.right, bounds.bottom),
+                )
+                liveNodes[path] = node
+            }
+            for (index in 0 until node.childCount) {
+                node.getChild(index)?.let { visit(it, "$path/$index") }
+            }
         }
-        if (matches.size != 1) return false
-        return swipeNode(matches.single(), direction, durationMs, preferScrollAction = true)
+        visit(root, "0")
+        val resolved = PurchaseScrollLocator.locate(
+            PurchaseScrollCandidate(target.path, target.className, target.bounds), candidates,
+        ) ?: return false
+        val current = liveNodes[resolved.path] ?: return false
+        return swipeNode(current, direction, durationMs, preferScrollAction = true)
     }
 
     override fun backPurchase(): Boolean = performGlobalAction(GLOBAL_ACTION_BACK)
@@ -438,9 +484,17 @@ class GoAutoAccessibilityService : AccessibilityService(), UiDriver, PddCollecto
         }.getOrDefault(false)
     }
 
+    private var lastSpecRowSwipeFailure = "none"
+
+    override fun specRowSwipeFailureReason(): String = lastSpecRowSwipeFailure
+
     override fun swipeSpec(direction: SwipeDirection, anchor: SnapshotNode?): Boolean {
+        lastSpecRowSwipeFailure = "none"
         if (anchor == null) return swipe(SemanticTarget.SPEC_PANEL, direction)
-        val root = rootInActiveWindow ?: return false
+        val root = rootInActiveWindow ?: run {
+            lastSpecRowSwipeFailure = "windowMissing"
+            return false
+        }
         val matches = mutableListOf<AccessibilityNodeInfo>()
         walk(root) { node ->
             val bounds = Rect().also(node::getBoundsInScreen)
@@ -458,6 +512,7 @@ class GoAutoAccessibilityService : AccessibilityService(), UiDriver, PddCollecto
         val horizontal = direction == SwipeDirection.LEFT || direction == SwipeDirection.RIGHT
         if (matches.size != 1) {
             if (!SpecSwipeSafety.allowGlobalFallback(direction)) {
+                lastSpecRowSwipeFailure = if (matches.isEmpty()) "anchorMissing" else "anchorAmbiguous"
                 Log.i("GoAutoCollector", "swipe direction=$direction result=blocked reason=anchor-not-unique matches=${matches.size}")
                 return false
             }
@@ -481,19 +536,27 @@ class GoAutoAccessibilityService : AccessibilityService(), UiDriver, PddCollecto
         if (anchoredTarget != null) {
             val bounds = Rect().also(anchoredTarget::getBoundsInScreen)
             Log.i("GoAutoCollector", "swipe direction=$direction anchored=true bounds=$bounds class=${anchoredTarget.className}")
-            return swipeNode(
+            val success = swipeNode(
                 anchoredTarget,
                 direction,
                 preferScrollAction = SpecSwipeSafety.preferAccessibilityScrollAction(direction),
             )
+            if (!success) lastSpecRowSwipeFailure = "gestureFailed"
+            return success
         }
         if (!SpecSwipeSafety.allowGlobalFallback(direction)) {
+            lastSpecRowSwipeFailure = "horizontalContainerMissing"
             Log.i("GoAutoCollector", "swipe direction=$direction result=blocked reason=no-anchored-horizontal-container")
             return false
         }
         return swipe(SemanticTarget.SPEC_PANEL, direction)
     }
 
+    override fun swipeSpecRow(target: SnapshotNode, direction: SwipeDirection): Boolean {
+        if (direction != SwipeDirection.LEFT && direction != SwipeDirection.RIGHT) return false
+        return swipeSpec(direction, target)
+    }
+
     override fun pullDownSpecPanel(anchor: SnapshotNode): Boolean {
         if (!anchor.scrollable) return false
         val root = rootInActiveWindow ?: return false

android/app/src/main/java/cn/ilapage/goauto/agent/automation/PddLaunchFallback.kt

@@ -0,0 +1,8 @@
+package cn.ilapage.goauto.agent.automation
+
+internal object PddLaunchFallback {
+    fun open(preferDirect: Boolean, direct: () -> Boolean, browser: () -> Boolean): Boolean {
+        if (preferDirect && runCatching(direct).getOrDefault(false)) return true
+        return runCatching(browser).getOrDefault(false)
+    }
+}

android/app/src/main/java/cn/ilapage/goauto/agent/automation/PddNavigation.kt

@@ -31,11 +31,21 @@ object PddPageClassifier {
 }
 
 class PddLinkLauncher(private val context: Context) {
-    fun open(url: String): Boolean {
+    fun open(url: String, preferDirect: Boolean = false): Boolean {
         val uri = runCatching { Uri.parse(url) }.getOrNull() ?: return false
         if (uri.scheme !in setOf("http", "https") || !isPddHost(uri.host) || uri.getQueryParameter("goods_id").isNullOrBlank()) {
             return false
         }
+        return PddLaunchFallback.open(preferDirect, direct = {
+            val direct = Intent(Intent.ACTION_VIEW, uri)
+                .setPackage("com.xunmeng.pinduoduo")
+                .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
+            context.startActivity(direct)
+            true
+        }, browser = { openBrowser(uri) })
+    }
+
+    private fun openBrowser(uri: Uri): Boolean {
         val base = Intent(Intent.ACTION_VIEW, uri).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
         val browser = BROWSER_PACKAGES.firstOrNull { packageName ->
             runCatching { context.packageManager.getPackageInfo(packageName, 0) }.isSuccess

android/app/src/main/java/cn/ilapage/goauto/agent/automation/PddProductDetailCollector.kt

@@ -99,6 +99,8 @@ object PddSoldOutRecoveryDefaults {
     const val SETTLE_MILLIS = 2_000L
 }
 
+data class PurchasePanelContext(val container: SnapshotNode, val exactColor: String)
+
 data class ParsedPddScreen(
     val summary: ProductSummary,
     val dimensions: List<VisibleDimension>,
@@ -128,6 +130,10 @@ data class ParsedPddScreen(
     val bottomPurchaseEntryCount: Int,
     val problem: PageProblem?,
     val sourceNodes: List<SnapshotNode>,
+    val isPddPackage: Boolean,
+    val hasCloseControl: Boolean = false,
+    val hasPaymentArea: Boolean = false,
+    val purchaseContextMatched: Boolean = false,
 ) {
     fun isTransientSoldOut(
         exactText: String,
@@ -162,6 +168,7 @@ data class ParsedPddScreen(
 }
 
 object PddScreenParser {
+    private const val PDD_PACKAGE = "com.xunmeng.pinduoduo"
     private data class SafeSpecEntry(val anchor: SnapshotNode, val clickTarget: SnapshotNode)
     private val pricePattern = Regex("[¥￥]\\s*([0-9]+(?:\\.[0-9]{1,2})?)")
     private val salesPattern = Regex("已拼\\s*[0-9]+(?:\\.[0-9]+)?\\s*(?:万|亿)?\\s*\\+?\\s*(?:件|人)?")
@@ -179,7 +186,7 @@ object PddScreenParser {
     // purchase/order/payment controls must never become collection click targets.
     private val nonConfigurableClickDenylist = listOf("提交订单", "确认订单", "支付", "付款")
 
-    fun parse(snapshot: UiSnapshot, config: PddCollectorConfig, goodsId: String, evidence: PageEvidence?): ParsedPddScreen {
+    fun parse(snapshot: UiSnapshot, config: PddCollectorConfig, goodsId: String, evidence: PageEvidence?, purchaseContext: PurchasePanelContext? = null): ParsedPddScreen {
         val visibleNodes = snapshot.nodes.filter { it.visible }
         val visible = visibleNodes.mapNotNull { node ->
             val descendants = descendants(node, visibleNodes)
@@ -304,9 +311,24 @@ object PddScreenParser {
         // Opening evidence is intentionally independent from whether the current
         // viewport still exposes a clickable spec value. PDD may hide the only
         // selected value or restore a previously scrolled confirmation panel.
+        val continuedPurchasePanel = snapshot.packageName == PDD_PACKAGE && problem == null &&
+            purchaseContext != null && headedPanelScrollable != null &&
+            headedPanelScrollable.path == purchaseContext.container.path &&
+            headedPanelScrollable.className == purchaseContext.container.className &&
+            kotlin.math.abs(headedPanelScrollable.bounds.left - purchaseContext.container.bounds.left) <= 32 &&
+            kotlin.math.abs(headedPanelScrollable.bounds.right - purchaseContext.container.bounds.right) <= 32 &&
+            minOf(headedPanelScrollable.bounds.bottom, purchaseContext.container.bounds.bottom) >
+                maxOf(headedPanelScrollable.bounds.top, purchaseContext.container.bounds.top)
+        val structuredSelectionPanel = headedPanelScrollable != null &&
+            (headings.size >= 2 || (continuedPurchasePanel && headings.isNotEmpty())) &&
+            dimensions.any { it.values.isNotEmpty() } && hasClose &&
+            hasQuantityControls && hasPaymentArea && hasOrderSubmitAction
+        // Some selected-spec panels omit both the "已选" prefix and a confirm
+        // button. Keep the same structural evidence required for checkout.
         val specPanelType = when {
             quickConfirmationEvidence -> SpecPanelType.QUICK_CONFIRMATION
             orderConfirmationEvidence -> SpecPanelType.ORDER_CONFIRMATION
+            structuredSelectionPanel -> SpecPanelType.NORMAL_SCROLLABLE
             panelScrollable != null && (hasSelectionSummary || hasSubmitHint || (hasPanelTitle && hasPanelAction)) -> SpecPanelType.NORMAL_SCROLLABLE
             hasSelectionSummary && hasPanelTitle && hasPanelAction -> SpecPanelType.NON_SCROLLABLE_CONFIRMATION
             // Some PDD builds expose the complete selector as non-scrollable
@@ -320,6 +342,28 @@ object PddScreenParser {
             else -> SpecPanelType.UNKNOWN
         }
         val panelOpen = specPanelType != SpecPanelType.UNKNOWN
+        val unprefixedSummary = if (structuredSelectionPanel) {
+            val quantity = quantityInputs.single()
+            val knownColors = (dimensions.filter { it.key == "color" }.flatMap { it.values }.map { it.text } +
+                listOfNotNull(purchaseContext?.exactColor?.takeIf { continuedPurchasePanel && it.isNotBlank() })).distinct()
+            val byPath = visibleNodes.associateBy { it.path }
+            var region = quantity.parentPath?.let(byPath::get)
+            var summary: String? = null
+            while (region != null && region.bounds.bottom <= headedPanelScrollable!!.bounds.top) {
+                val candidates = visible.filter { node ->
+                    node.path.startsWith("${region!!.path}/") && !node.clickable &&
+                        node.className?.endsWith("TextView") == true &&
+                        node.bounds.bottom <= quantity.bounds.top && node.label.length <= 160 &&
+                        knownColors.any { SpecValueNormalizer.summaryHasExactToken(node.label, it) }
+                }.map { it.label }.distinct()
+                if (candidates.isNotEmpty()) {
+                    summary = candidates.singleOrNull()
+                    break
+                }
+                region = region.parentPath?.let(byPath::get)
+            }
+            summary
+        } else null
         val firstHeadingTop = headings.firstOrNull()?.bounds?.top ?: Int.MAX_VALUE
         val price = visible.asSequence()
             .filter { it.bounds.top < firstHeadingTop }
@@ -371,7 +415,7 @@ object PddScreenParser {
             selectedSummary = labels.firstOrNull {
                 val compact = it.replace(" ", "")
                 textAliases.selection.selectedPrefixes.any(compact::startsWith)
-            },
+            } ?: unprefixedSummary,
             priceCent = price,
             specPanelOpen = panelOpen,
             specPanelType = specPanelType,
@@ -390,6 +434,9 @@ object PddScreenParser {
             panelHeadingCount = headings.size,
             panelOptionCount = dimensions.sumOf { it.values.size },
             hasSelectionSummary = hasSelectionSummary,
+            hasCloseControl = hasClose,
+            hasPaymentArea = hasPaymentArea,
+            purchaseContextMatched = continuedPurchasePanel,
             hasQuantityControls = hasQuantityControls,
             hasOrderSubmitAction = hasOrderSubmitAction,
             explicitSpecEntryCount = explicitSpecEntries.size,
@@ -397,6 +444,7 @@ object PddScreenParser {
             bottomPurchaseEntryCount = bottomSpecEntries.size,
             problem = problem,
             sourceNodes = visibleNodes,
+            isPddPackage = snapshot.packageName == PDD_PACKAGE,
         )
     }
 

android/app/src/main/java/cn/ilapage/goauto/agent/automation/PurchaseLiveAutomation.kt

@@ -36,6 +36,58 @@ class PurchaseLiveAutomation(
     private var submitAttempted = false
     var lastOrderReadFailure: PurchaseOrderReadFailure? = null
         private set
+
+    /**
+     * Advances an already verified spec selector to the order confirmation
+     * page. Only the selector's unique exact confirm button is clickable; an
+     * order-submit or payment control can never satisfy this transition.
+     */
+    fun advanceToOrderConfirmation(allowUnclassifiedPanelWithSelectionProof: Boolean = false) {
+        var snapshot = driver.capture()
+        pageProblem(snapshot)
+        if (orderConfirmationReady(snapshot)) return
+        if (snapshot.packageName != PDD_PACKAGE) {
+            fail("PURCHASE_SPEC_CONFIRMATION_NOT_READY", "当前不是拼多多规格页面，未创建订单")
+        }
+        val screen = PddScreenParser.parse(snapshot, PurchaseRehearsalExecutor.DEFAULT_COLLECTOR, "", null)
+        val unclassifiedSelectionPanelWithProof = allowUnclassifiedPanelWithSelectionProof &&
+            screen.specPanelType == SpecPanelType.UNKNOWN &&
+            screen.priceCent != null &&
+            snapshot.nodes.count {
+                it.visible && it.enabled && it.className?.endsWith("EditText") == true && it.label.toLongOrNull() != null
+            } == 1
+        if (
+            screen.specPanelType !in setOf(SpecPanelType.NORMAL_SCROLLABLE, SpecPanelType.NON_SCROLLABLE_CONFIRMATION) &&
+            !unclassifiedSelectionPanelWithProof
+        ) {
+            fail("PURCHASE_SPEC_CONFIRMATION_NOT_READY", "当前规格面板不能安全确认，未创建订单")
+        }
+        val aliases = PurchaseRehearsalExecutor.DEFAULT_COLLECTOR.textAliases.specPanel.confirmAliases
+            .map { it.replace(" ", "") }
+            .toSet()
+        val targets = snapshot.nodes.filter { node ->
+            node.visible && node.enabled && node.clickable && node.label.replace(" ", "") in aliases
+        }.distinctBy { it.path }
+        if (targets.isEmpty()) {
+            fail("PURCHASE_SPEC_CONFIRM_TARGET_MISSING", "没有找到唯一的规格确认按钮，未创建订单")
+        }
+        if (targets.size > 1) {
+            fail("PURCHASE_SPEC_CONFIRM_TARGET_AMBIGUOUS", "规格确认按钮不唯一，未创建订单")
+        }
+        when (driver.clickFresh(targets.single())) {
+            FreshActionResult.SUCCESS -> Unit
+            FreshActionResult.AMBIGUOUS -> fail("PURCHASE_SPEC_CONFIRM_TARGET_AMBIGUOUS", "规格确认按钮不唯一，未创建订单")
+            else -> fail("PURCHASE_SPEC_CONFIRM_CLICK_FAILED", "规格确认按钮点击失败，未创建订单")
+        }
+        repeat(SPEC_CONFIRMATION_MAX_SAMPLES) {
+            pause(SPEC_CONFIRMATION_SAMPLE_INTERVAL_MS)
+            snapshot = driver.capture()
+            pageProblem(snapshot)
+            if (orderConfirmationReady(snapshot)) return
+        }
+        fail("PURCHASE_SPEC_CONFIRMATION_UNCONFIRMED", "规格确认后没有进入订单确认页，未创建订单")
+    }
+
     fun updateShippingAddress(addressSuffix: String): ShippingAddressProof {
         if (!addressSuffix.matches(Regex("^_cg[1-9][0-9]*$"))) fail("PURCHASE_ADDRESS_UPDATE_FAILED", "采购任务的地址标记无效")
         var snapshot = driver.capture()
@@ -43,12 +95,31 @@ class PurchaseLiveAutomation(
         var unchangedCount = 0
         for (attempt in 0 until 5) {
             pageProblem(snapshot)
-            val entries = mergedDirect(snapshot.nodes.filter { it.visible && it.enabled && MASKED_PHONE.containsMatchIn(it.label) })
-            if (entries.size == 1) {
-                when (driver.tapPurchaseFresh(entries.single())) {
+            val resolution = resolveAddressEntries(snapshot)
+            if (resolution.addressCardCount > 1 || resolution.tapTargetCount > 1) {
+                fail("PURCHASE_ADDRESS_ENTRY_AMBIGUOUS", "收货地址入口不唯一，未创建订单 [${resolution.diagnostic()}]")
+            }
+            if (resolution.target != null) {
+                pause(ADDRESS_ENTRY_STABLE_INTERVAL_MS)
+                val stableSnapshot = driver.capture()
+                pageProblem(stableSnapshot)
+                val stableResolution = resolveAddressEntries(stableSnapshot)
+                if (stableResolution.addressCardCount > 1 || stableResolution.tapTargetCount > 1) {
+                    fail("PURCHASE_ADDRESS_ENTRY_AMBIGUOUS", "收货地址入口不唯一，未创建订单 [${stableResolution.diagnostic()}]")
+                }
+                if (stableResolution.target == null || stableResolution.fingerprint() != resolution.fingerprint()) {
+                    snapshot = stableSnapshot
+                    continue
+                }
+                val target = stableResolution.target
+                val result = when (target.activation) {
+                    AddressEntryActivation.CLICK -> driver.clickAddressEntryFresh(target.node).result
+                    AddressEntryActivation.TAP -> driver.tapPurchaseFresh(target.node)
+                }
+                when (result) {
                     FreshActionResult.SUCCESS -> Unit
-                    FreshActionResult.AMBIGUOUS -> fail("PURCHASE_ADDRESS_ENTRY_AMBIGUOUS", "收货地址入口不唯一，未创建订单")
-                    else -> fail("PURCHASE_ADDRESS_ENTRY_NOT_READY", "收货地址入口点击失败，未创建订单")
+                    FreshActionResult.AMBIGUOUS -> fail("PURCHASE_ADDRESS_ENTRY_AMBIGUOUS", "收货地址入口不唯一，未创建订单 [${stableResolution.diagnostic()}]")
+                    else -> fail("PURCHASE_ADDRESS_ENTRY_NOT_READY", "收货地址入口点击失败，未创建订单 [${stableResolution.diagnostic()}]")
                 }
                 pause(1_000)
                 snapshot = waitFor("PURCHASE_ADDRESS_PANEL_TIMEOUT", "收货地址页面打开超时，未创建订单") {
@@ -56,7 +127,9 @@ class PurchaseLiveAutomation(
                 }
                 return editAndVerifyAddress(snapshot, addressSuffix)
             }
-            if (entries.size > 1) fail("PURCHASE_ADDRESS_ENTRY_AMBIGUOUS", "收货地址入口不唯一，未创建订单")
+            if (resolution.phoneNodeCount > 0) {
+                fail("PURCHASE_ADDRESS_ENTRY_NOT_READY", "收货地址入口无法安全定位，未创建订单 [${resolution.diagnostic()}]")
+            }
             val panel = purchasePanelScrollTargets(snapshot)
             if (panel.size != 1) fail("PURCHASE_ADDRESS_ENTRY_AMBIGUOUS", "没有找到唯一的规格面板滚动区域，未创建订单")
             val signature = viewportSignature(snapshot, panel.single())
@@ -72,6 +145,161 @@ class PurchaseLiveAutomation(
         fail("PURCHASE_ADDRESS_PANEL_TIMEOUT", "规格面板下拉后仍未找到收货地址，未创建订单")
     }
 
+    private enum class AddressEntryActivation { CLICK, TAP }
+
+    private data class AddressEntryTarget(
+        val node: SnapshotNode,
+        val activation: AddressEntryActivation,
+        val cardKey: String,
+    )
+
+    private data class AddressCardCandidate(
+        val phone: SnapshotNode,
+        val clickableCard: SnapshotNode?,
+        val semanticKey: String?,
+    )
+
+    private data class AddressEntryResolution(
+        val phoneNodeCount: Int,
+        val addressCardCount: Int,
+        val tapTargetCount: Int,
+        val target: AddressEntryTarget?,
+    ) {
+        fun diagnostic(): String =
+            "phoneNodes=$phoneNodeCount;addressCards=$addressCardCount;tapTargets=$tapTargetCount"
+
+        fun fingerprint(): String? = target?.let {
+            listOf(
+                it.activation.name,
+                it.cardKey,
+                it.node.label,
+                it.node.className.orEmpty(),
+                it.node.bounds.left,
+                it.node.bounds.top,
+                it.node.bounds.right,
+                it.node.bounds.bottom,
+            ).joinToString(":")
+        }
+    }
+
+    private fun resolveAddressEntries(snapshot: UiSnapshot): AddressEntryResolution {
+        val phones = snapshot.nodes.filter {
+            it.visible && it.enabled && maskedPhone(it.label) != null
+        }.distinctBy { it.path }
+        if (phones.isEmpty()) return AddressEntryResolution(0, 0, 0, null)
+
+        val byPath = snapshot.nodes.associateBy(SnapshotNode::path)
+        val candidates = phones.map { phone ->
+            val card = nearestClickableAncestor(phone, byPath)
+            AddressCardCandidate(phone, card, card?.let { addressCardSemanticKey(it, snapshot) })
+        }
+        val groups = mutableListOf<MutableList<AddressCardCandidate>>()
+        candidates.forEach { candidate ->
+            val matching = groups.filter { group -> group.any { sameLogicalAddress(it, candidate) } }
+            if (matching.isEmpty()) {
+                groups += mutableListOf(candidate)
+            } else {
+                val primary = matching.first()
+                primary += candidate
+                matching.drop(1).forEach { duplicate ->
+                    primary += duplicate
+                    groups.remove(duplicate)
+                }
+            }
+        }
+
+        val targets = groups.mapIndexed { index, group ->
+            val clickable = group.filter { it.clickableCard != null }
+                .minWithOrNull(compareBy<AddressCardCandidate>({ nodeArea(requireNotNull(it.clickableCard)) }, { it.phone.path }))
+            if (clickable != null) {
+                AddressEntryTarget(clickable.phone, AddressEntryActivation.CLICK, logicalAddressKey(group, index))
+            } else {
+                AddressEntryTarget(group.minBy { nodeArea(it.phone) }.phone, AddressEntryActivation.TAP, logicalAddressKey(group, index))
+            }
+        }
+
+        val actionable = targets.filter { it.node.bounds.width >= 2 && it.node.bounds.height >= 2 }
+        return AddressEntryResolution(
+            phoneNodeCount = phones.size,
+            addressCardCount = targets.size,
+            tapTargetCount = actionable.size,
+            target = actionable.singleOrNull(),
+        )
+    }
+
+    private fun nearestClickableAncestor(
+        source: SnapshotNode,
+        byPath: Map<String, SnapshotNode>,
+    ): SnapshotNode? {
+        var current: SnapshotNode? = source
+        while (current != null) {
+            if (current.clickable && current.visible && current.enabled) return current
+            current = current.parentPath?.let(byPath::get)
+        }
+        return null
+    }
+
+    private fun addressCardSemanticKey(card: SnapshotNode, snapshot: UiSnapshot): String? {
+        val labels = snapshot.nodes.asSequence()
+            .filter { it.visible && (it.path == card.path || it.path.startsWith("${card.path}/")) }
+            .map { normalizeAddressSemantic(it.label) }
+            .filter { it.isNotBlank() && maskedPhone(it) == null && it !in ADDRESS_CARD_GENERIC_LABELS }
+            .distinct()
+            .sorted()
+            .toList()
+        if (labels.none { it.length >= ADDRESS_SEMANTIC_MIN_LENGTH }) return null
+        return labels.joinToString("|")
+    }
+
+    private fun normalizeAddressSemantic(value: String): String = value
+        .replace(Regex("\\s+"), "")
+        .replace("，", ",")
+        .replace("：", ":")
+        .lowercase()
+
+    private fun sameLogicalAddress(first: AddressCardCandidate, second: AddressCardCandidate): Boolean {
+        if (maskedPhone(first.phone.label) != maskedPhone(second.phone.label)) return false
+        if (first.clickableCard?.path != null && first.clickableCard.path == second.clickableCard?.path) return true
+        if (sameAddressRegion(first.phone, second.phone)) return true
+        val firstCard = first.clickableCard
+        val secondCard = second.clickableCard
+        if (firstCard != null && secondCard != null && boundsRepresentSameRegion(firstCard.bounds, secondCard.bounds)) return true
+        return first.semanticKey != null && first.semanticKey == second.semanticKey
+    }
+
+    private fun boundsRepresentSameRegion(first: NodeBounds, second: NodeBounds): Boolean {
+        val overlapWidth = (minOf(first.right, second.right) - maxOf(first.left, second.left)).coerceAtLeast(0)
+        val overlapHeight = (minOf(first.bottom, second.bottom) - maxOf(first.top, second.top)).coerceAtLeast(0)
+        val overlap = overlapWidth.toLong() * overlapHeight
+        val smaller = minOf(first.width.toLong() * first.height, second.width.toLong() * second.height)
+        return smaller > 0 && overlap * 100 >= smaller * ADDRESS_CARD_OVERLAP_PERCENT
+    }
+
+    private fun logicalAddressKey(group: List<AddressCardCandidate>, index: Int): String {
+        val semantic = group.mapNotNull(AddressCardCandidate::semanticKey).distinct().singleOrNull()
+        return semantic?.let { "semantic:$it" } ?: "geometry:$index:${group.minOf { it.phone.bounds.top }}"
+    }
+
+    private fun sameAddressRegion(first: SnapshotNode, second: SnapshotNode): Boolean {
+        if (maskedPhone(first.label) != maskedPhone(second.label)) return false
+        val overlapWidth = (minOf(first.bounds.right, second.bounds.right) - maxOf(first.bounds.left, second.bounds.left)).coerceAtLeast(0)
+        val overlapHeight = (minOf(first.bounds.bottom, second.bounds.bottom) - maxOf(first.bounds.top, second.bounds.top)).coerceAtLeast(0)
+        val overlap = overlapWidth.toLong() * overlapHeight
+        val smaller = minOf(nodeArea(first), nodeArea(second))
+        val containsCenter = (
+            first.bounds.centerX in second.bounds.left..second.bounds.right &&
+                first.bounds.centerY in second.bounds.top..second.bounds.bottom
+            ) || (
+            second.bounds.centerX in first.bounds.left..first.bounds.right &&
+                second.bounds.centerY in first.bounds.top..first.bounds.bottom
+            )
+        return (smaller > 0 && overlap * 100 >= smaller * 50) || containsCenter
+    }
+
+    private fun maskedPhone(value: String): String? = MASKED_PHONE.find(value)?.value
+
+    private fun nodeArea(node: SnapshotNode): Long = node.bounds.width.toLong() * node.bounds.height
+
     fun finalConfirmation(input: PurchaseExecutionInput, address: ShippingAddressProof): FinalConfirmationEvidence {
         val snapshot = driver.capture()
         pageProblem(snapshot)
@@ -259,14 +487,62 @@ class PurchaseLiveAutomation(
         click(save.single(), "保存地址")
         val savedEvidence = waitForStableAddressEditorExit()
         if (!hasFinalSavedAddressEvidence(savedEvidence, expected, suffix)) {
-            if (!driver.backPurchase()) fail("PURCHASE_ADDRESS_UPDATE_FAILED", "地址保存后无法返回订单页面，未创建订单")
-            waitFor("PURCHASE_ADDRESS_SAVE_TIMEOUT", "地址保存后无法返回订单页面，未创建订单") {
-                hasFinalSavedAddressEvidence(it, expected, suffix)
+            if (isPurchaseConfirmationPanel(savedEvidence)) {
+                restoreFinalEvidenceInCurrentPanel(savedEvidence, expected, suffix)
+            } else {
+                if (!driver.backPurchase()) fail("PURCHASE_ADDRESS_UPDATE_FAILED", "地址保存后无法返回订单页面，未创建订单")
+                waitFor("PURCHASE_ADDRESS_SAVE_TIMEOUT", "地址保存后无法返回订单页面，未创建订单") {
+                    hasFinalSavedAddressEvidence(it, expected, suffix)
+                }
             }
         }
         return ShippingAddressProof(expected, suffix)
     }
 
+    private fun isPurchaseConfirmationPanel(snapshot: UiSnapshot): Boolean {
+        if (snapshot.packageName != PDD_PACKAGE || shippingAddressEditors(snapshot).isNotEmpty()) return false
+        val screen = PddScreenParser.parse(snapshot, PurchaseRehearsalExecutor.DEFAULT_COLLECTOR, "", null)
+        return screen.specPanelType in setOf(
+            SpecPanelType.NORMAL_SCROLLABLE,
+            SpecPanelType.NON_SCROLLABLE_CONFIRMATION,
+            SpecPanelType.ORDER_CONFIRMATION,
+        )
+    }
+
+    private fun restoreFinalEvidenceInCurrentPanel(
+        initial: UiSnapshot,
+        expected: String,
+        suffix: String,
+    ) {
+        var snapshot = initial
+        var previousSignature: String? = null
+        repeat(ADDRESS_CONFIRMATION_SCROLL_LIMIT) { attempt ->
+            if (hasFinalSavedAddressEvidence(snapshot, expected, suffix)) return
+            if (!isPurchaseConfirmationPanel(snapshot)) {
+                fail("PURCHASE_ADDRESS_SAVE_TIMEOUT", "地址保存后采购面板发生变化，未创建订单")
+            }
+            val panels = purchasePanelScrollTargets(snapshot)
+            if (panels.size != 1) {
+                fail("PURCHASE_ADDRESS_ENTRY_AMBIGUOUS", "地址保存后没有找到唯一的规格面板滚动区域，未创建订单")
+            }
+            val panel = panels.single()
+            val signature = viewportSignature(snapshot, panel)
+            if (signature == previousSignature) {
+                fail("PURCHASE_ADDRESS_SAVE_TIMEOUT", "地址保存后规格面板未找到完整订单确认信息，未创建订单")
+            }
+            previousSignature = signature
+            if (!driver.swipePurchaseIn(panel, SwipeDirection.DOWN, 350)) {
+                fail("PURCHASE_ADDRESS_SAVE_TIMEOUT", "地址保存后规格面板无法定位订单确认信息，未创建订单")
+            }
+            if (attempt < ADDRESS_CONFIRMATION_SCROLL_LIMIT - 1) pause(ADDRESS_CONFIRMATION_SCROLL_INTERVAL_MS)
+            snapshot = driver.capture()
+            pageProblem(snapshot)
+        }
+        if (!hasFinalSavedAddressEvidence(snapshot, expected, suffix)) {
+            fail("PURCHASE_ADDRESS_SAVE_TIMEOUT", "地址保存后规格面板未找到完整订单确认信息，未创建订单")
+        }
+    }
+
     private fun hasSavedAddressEvidence(snapshot: UiSnapshot, expected: String, suffix: String): Boolean {
         if (snapshot.packageName != PDD_PACKAGE || shippingAddressEditors(snapshot).isNotEmpty()) return false
         val visible = snapshot.nodes.filter { it.visible }
@@ -329,7 +605,7 @@ class PurchaseLiveAutomation(
     private fun viewportSignature(snapshot: UiSnapshot, panel: SnapshotNode): String = snapshot.nodes
         .filter { node -> node.visible && inside(node.bounds, panel.bounds) }
         .joinToString("|") { node ->
-            listOf(node.className.orEmpty(), node.bounds.left, node.bounds.top, node.bounds.right, node.bounds.bottom, node.clickable, node.scrollable).joinToString(":")
+            listOf(node.path, node.className.orEmpty(), node.bounds.left, node.bounds.top, node.bounds.right, node.bounds.bottom, node.clickable, node.scrollable).joinToString(":")
         }
 
     private fun inside(child: NodeBounds, parent: NodeBounds): Boolean =
@@ -407,6 +683,13 @@ class PurchaseLiveAutomation(
         snapshot.nodes.filter { node -> node.visible && node.enabled && FINAL_SUBMIT_MARKERS.any { node.label == it || node.label.startsWith(it) } },
     )
 
+    private fun orderConfirmationReady(snapshot: UiSnapshot): Boolean {
+        if (snapshot.packageName != PDD_PACKAGE) return false
+        if (snapshot.nodes.any { it.visible && it.enabled && MASKED_PHONE.containsMatchIn(it.label) }) return true
+        return PddScreenParser.parse(snapshot, PurchaseRehearsalExecutor.DEFAULT_COLLECTOR, "", null).specPanelType ==
+            SpecPanelType.ORDER_CONFIRMATION
+    }
+
     /** A post-submit navigation target is allowed only when it is one exact, non-payment PDD order-detail entry. */
     private fun orderDetailEntryTargets(snapshot: UiSnapshot): List<SnapshotNode> = uniqueClickable(
         snapshot,
@@ -483,5 +766,13 @@ class PurchaseLiveAutomation(
         const val ORDER_RESULT_PAYMENT_POST_BACK_MAX_SAMPLES = 3
         const val ORDER_RESULT_SCROLL_SAMPLE_INTERVAL = 15
         const val ORDER_RESULT_SAMPLE_INTERVAL_MS = 200L
+        const val SPEC_CONFIRMATION_MAX_SAMPLES = 20
+        const val SPEC_CONFIRMATION_SAMPLE_INTERVAL_MS = 100L
+        const val ADDRESS_ENTRY_STABLE_INTERVAL_MS = 200L
+        const val ADDRESS_CARD_OVERLAP_PERCENT = 70
+        const val ADDRESS_SEMANTIC_MIN_LENGTH = 4
+        val ADDRESS_CARD_GENERIC_LABELS = setOf("收货地址", "修改", "默认地址", "默认")
+        const val ADDRESS_CONFIRMATION_SCROLL_LIMIT = 5
+        const val ADDRESS_CONFIRMATION_SCROLL_INTERVAL_MS = 500L
     }
 }

android/app/src/main/java/cn/ilapage/goauto/agent/automation/PurchaseRehearsalExecutor.kt

@@ -10,6 +10,13 @@ interface PurchaseUiDriver {
         result = clickFresh(target),
         reason = FreshClickReason.UNKNOWN,
     )
+    /**
+     * Reacquires one address-entry node by its accessibility path and validates
+     * its immutable snapshot traits before clicking its nearest clickable
+     * ancestor. This is intentionally limited to the reversible transition
+     * from order confirmation into address management.
+     */
+    fun clickAddressEntryFresh(target: SnapshotNode): FreshClickOutcome = clickFreshDetailed(target)
     fun tapPurchaseFresh(target: SnapshotNode): FreshActionResult
     /**
      * Reacquires and center-taps a target that the purchase parser has already
@@ -17,6 +24,12 @@ interface PurchaseUiDriver {
      * must still verify the semantic postcondition from a fresh snapshot.
      */
     fun tapSpecFresh(target: SnapshotNode): FreshActionResult = FreshActionResult.FAILED
+    /**
+     * Reacquires a parsed spec option and swipes only its nearest horizontal
+     * scrollable ancestor. There is deliberately no global fallback.
+     */
+    fun swipeSpecRow(target: SnapshotNode, direction: SwipeDirection): Boolean = false
+    fun specRowSwipeFailureReason(): String = "gestureFailed"
     fun inputFresh(target: SnapshotNode, value: String): FreshActionResult
     fun swipePurchase(direction: SwipeDirection, durationMs: Long): Boolean
     fun swipePurchaseIn(target: SnapshotNode, direction: SwipeDirection, durationMs: Long): Boolean
@@ -75,7 +88,10 @@ class PurchaseRehearsalExecutor(
     private val panelDiagnostic: (String) -> Unit = {},
     private val beforeOrderSubmit: (FinalConfirmationEvidence) -> Unit = { throw PurchaseLiveException("PURCHASE_MODE_NOT_ALLOWED", "当前执行器没有正式采购授权") },
 ) {
+    private var purchasePanelContext: PurchasePanelContext? = null
+
     fun execute(input: PurchaseExecutionInput, rule: PurchaseRule, supportedCapabilities: Set<String>): PurchaseExecutionOutcome {
+        purchasePanelContext = null
         validateBeforeDeviceAction(input, rule, supportedCapabilities)?.let { return it }
         var observedPrice: Long? = null
         var addressProof: ShippingAddressProof? = null
@@ -83,6 +99,15 @@ class PurchaseRehearsalExecutor(
         val specSelectionProofs = mutableMapOf<String, ExactSpecSelectionProof>()
         val live = PurchaseLiveAutomation(driver, pause)
         for (action in rule.actions) {
+            // The immediate phase-two handoff can reuse the PDD page retained by
+            // spec_probe. A later manual retry may start from Agent (or another
+            // unrelated screen), so only skip navigation when a fresh snapshot
+            // still carries safe PDD product/spec evidence.
+            if (
+                input.phase == "purchase" &&
+                action.type == PurchaseActionType.OPEN_PRODUCT &&
+                canReuseCurrentProduct(input)
+            ) continue
             stepChanged(action.type.wireName)
             val failure = when (action.type) {
                 PurchaseActionType.OPEN_PRODUCT -> openProduct(input, action)
@@ -101,6 +126,7 @@ class PurchaseRehearsalExecutor(
                     null
                 }
                 PurchaseActionType.UPDATE_SHIPPING_ADDRESS -> try {
+                    live.advanceToOrderConfirmation(hasAllRecordedSelectionProofs(input, specSelectionProofs))
                     addressProof = live.updateShippingAddress(input.addressSuffix)
                     null
                 } catch (error: PurchaseLiveException) {
@@ -152,6 +178,11 @@ class PurchaseRehearsalExecutor(
         else failure("PURCHASE_RULE_INVALID", "正式采购规则缺少核单动作")
     }
 
+    private fun canReuseCurrentProduct(input: PurchaseExecutionInput): Boolean =
+        currentScreen(input).let { screen ->
+            screen.problem == null && screen.hasPurchaseProductEvidence()
+        }
+
     private fun validateBeforeDeviceAction(
         input: PurchaseExecutionInput,
         rule: PurchaseRule,
@@ -203,15 +234,35 @@ class PurchaseRehearsalExecutor(
     }
 
     private fun openProduct(input: PurchaseExecutionInput, action: PurchaseAction): PurchaseExecutionOutcome? {
+        purchasePanelContext = null
         if (!openLink(input.url)) return failure("PDD_LINK_INVALID", "任务中的 PDD 链接无法打开")
         val aliases = action.textAliases ?: listOf("打开拼多多APP", "打开拼多多 App", "打开")
         var clickAttempted = false
         var nextClickPoll = 0
         var lastClickReason = FreshClickReason.UNKNOWN
+        var stableEvidenceReads = 0
+        var pddForegroundObserved = false
         repeat(OPEN_PRODUCT_POLL_LIMIT) { poll ->
             val snapshot = driver.capture()
             pageProblem(snapshot)?.let { return it }
-            if (snapshot.packageName == PDD_PACKAGE) return null
+            if (snapshot.packageName == PDD_PACKAGE) {
+                pddForegroundObserved = true
+                val screen = PddScreenParser.parse(snapshot, DEFAULT_COLLECTOR, input.goodsId, null)
+                stableEvidenceReads = if (screen.hasPurchaseProductEvidence()) stableEvidenceReads + 1 else 0
+                if (stableEvidenceReads >= PRODUCT_PAGE_STABLE_READS) {
+                    // A product-page accessibility tree can appear before PDD has
+                    // finished wiring click listeners and bottom-sheet transitions.
+                    // Give the page one short settle window, then require the
+                    // evidence again before moving to the spec entry.
+                    pause(PRODUCT_PAGE_SETTLE_MILLIS)
+                    val settled = PddScreenParser.parse(driver.capture(), DEFAULT_COLLECTOR, input.goodsId, null)
+                    if (settled.hasPurchaseProductEvidence()) return null
+                    stableEvidenceReads = 0
+                }
+                pause(OPEN_PRODUCT_POLL_MILLIS)
+                return@repeat
+            }
+            stableEvidenceReads = 0
             val candidates = snapshot.nodes.filter { it.visible && it.enabled && it.label in aliases }
             if (candidates.size > 1) return failure("RULE_AMBIGUOUS", "打开拼多多按钮不唯一")
             if (candidates.size == 1 && poll >= nextClickPoll) {
@@ -229,6 +280,9 @@ class PurchaseRehearsalExecutor(
             }
             pause(OPEN_PRODUCT_POLL_MILLIS)
         }
+        if (pddForegroundObserved) {
+            return failure("PDD_DETAIL_ENTRY_FAILED", "打开拼多多后未识别到稳定商品页面")
+        }
         if (clickAttempted) {
             val message = when (lastClickReason) {
                 FreshClickReason.ROOT_UNAVAILABLE, FreshClickReason.TARGET_NOT_FOUND -> "打开拼多多入口发生变化"
@@ -242,14 +296,23 @@ class PurchaseRehearsalExecutor(
     }
 
     private fun verifyProduct(input: PurchaseExecutionInput): PurchaseExecutionOutcome? {
-        repeat(50) {
+        var stableEvidenceReads = 0
+        repeat(PRODUCT_PAGE_POLL_LIMIT) {
             val snapshot = driver.capture()
             pageProblem(snapshot)?.let { return it }
             val screen = PddScreenParser.parse(snapshot, DEFAULT_COLLECTOR, input.goodsId, null)
             if (screen.hasPurchaseProductEvidence()) {
-                return recoverSoldOut(input, screen)
+                stableEvidenceReads++
+                if (stableEvidenceReads >= PRODUCT_PAGE_STABLE_READS) {
+                    pause(PRODUCT_PAGE_SETTLE_MILLIS)
+                    val settled = PddScreenParser.parse(driver.capture(), DEFAULT_COLLECTOR, input.goodsId, null)
+                    if (settled.hasPurchaseProductEvidence()) return recoverSoldOut(input, settled)
+                    stableEvidenceReads = 0
+                }
+            } else {
+                stableEvidenceReads = 0
             }
-            pause(100)
+            pause(OPEN_PRODUCT_POLL_MILLIS)
         }
         return failure("PDD_DETAIL_ENTRY_FAILED", "没有进入拼多多商品页面")
     }
@@ -290,6 +353,9 @@ class PurchaseRehearsalExecutor(
         var screen = currentScreen(input)
         var entryReadyWaitPolls = 0
         var target: SnapshotNode? = null
+        var stableTargetPath: String? = null
+        var stableTargetBounds: NodeBounds? = null
+        var stableTargetReads = 0
         while (target == null) {
             if (screen.reviewPageOpen) return leaveUnexpectedReviewPage(input)
             screen.problem?.let { return failure(it.code, it.message) }
@@ -308,8 +374,38 @@ class PurchaseRehearsalExecutor(
                 panelDiagnostic(specEntryEvidence(screen, candidates.size, entryReadyWaitPolls))
                 return failure(SPEC_ENTRY_TARGET_AMBIGUOUS, "规格入口候选不唯一 [${specEntryEvidence(screen, candidates.size, entryReadyWaitPolls)}]")
             }
-            target = candidates.singleOrNull()?.second
-            if (target != null) continue
+            val candidate = candidates.singleOrNull()?.second
+            if (candidate != null) {
+                val unchanged = candidate.path == stableTargetPath && candidate.bounds == stableTargetBounds
+                stableTargetReads = if (unchanged) stableTargetReads + 1 else 1
+                stableTargetPath = candidate.path
+                stableTargetBounds = candidate.bounds
+                if (stableTargetReads >= SPEC_ENTRY_STABLE_READS) {
+                    // Reacquire once more immediately before clicking so a node
+                    // rebuilt during the settle window is never reused.
+                    val latest = currentScreen(input)
+                    val latestCandidates = listOfNotNull(
+                        latest.specEntry?.let { anchor -> anchor to (latest.specEntryClickTarget ?: anchor) },
+                        latest.quickConfirmationEntry?.let { it to it },
+                    ).distinctBy { it.second.path }
+                        .let { candidatesToFilter ->
+                            action.textAliases?.let { aliases ->
+                                candidatesToFilter.filter { (anchor, _) -> specEntryMatchesAliases(latest, anchor, aliases) }
+                            } ?: candidatesToFilter
+                        }
+                    if (latestCandidates.size > 1) {
+                        return failure(SPEC_ENTRY_TARGET_AMBIGUOUS, "规格入口点击目标不唯一 [${specEntryEvidence(latest, latestCandidates.size, entryReadyWaitPolls)}]")
+                    }
+                    target = latestCandidates.singleOrNull()?.second
+                    if (target != null) screen = latest
+                    if (target != null) continue
+                    stableTargetReads = 0
+                }
+            } else {
+                stableTargetReads = 0
+                stableTargetPath = null
+                stableTargetBounds = null
+            }
             if (entryReadyWaitPolls >= SPEC_ENTRY_READY_WAIT_POLLS) {
                 panelDiagnostic(specEntryEvidence(screen, 0, entryReadyWaitPolls))
                 return failure(SPEC_ENTRY_NOT_FOUND, "没有找到安全的商品规格入口 [${specEntryEvidence(screen, 0, entryReadyWaitPolls)}]")
@@ -334,11 +430,58 @@ class PurchaseRehearsalExecutor(
         var wait = waitForSpecPanel(input, beforeSignature)
         wait.failure?.let { return it }
         if (wait.opened) return null
+        var gestureBaseline = wait.screen
         if (wait.changed) {
-            return failure(
-                SPEC_PANEL_EVIDENCE_NOT_MATCHED,
-                "规格入口点击后页面已变化，但规格面板强证据不足 [${panelEvidence(wait.screen)}]",
-            )
+            // A page transition can be caused by PDD rerendering the entry before
+            // the bottom sheet becomes observable. Re-locate the fresh entry and
+            // allow exactly one controlled retry while still on the same product.
+            if (!wait.screen.isPddPackage || !wait.screen.pageEvidenceMatched) {
+                return failure(SPEC_PANEL_EVIDENCE_NOT_MATCHED, "规格入口点击后页面已变化，但规格面板强证据不足 [${panelEvidence(wait.screen)}]")
+            }
+            val retryScreen = currentScreen(input)
+            if (!retryScreen.isPddPackage || !retryScreen.pageEvidenceMatched || retryScreen.specPanelOpen) {
+                return failure(SPEC_PANEL_EVIDENCE_NOT_MATCHED, "规格入口点击后页面已变化，但规格面板强证据不足 [${panelEvidence(retryScreen)}]")
+            }
+            val retryCandidates = listOfNotNull(
+                retryScreen.specEntry?.let { anchor -> anchor to (retryScreen.specEntryClickTarget ?: anchor) },
+                retryScreen.quickConfirmationEntry?.let { it to it },
+            ).distinctBy { it.second.path }
+                .let { candidatesToFilter ->
+                    action.textAliases?.let { aliases ->
+                        candidatesToFilter.filter { (anchor, _) -> specEntryMatchesAliases(retryScreen, anchor, aliases) }
+                    } ?: candidatesToFilter
+                }
+            if (retryCandidates.size != 1) {
+                return failure(SPEC_PANEL_EVIDENCE_NOT_MATCHED, "规格入口点击后页面已变化，但规格面板强证据不足 [${panelEvidence(retryScreen)}]")
+            }
+            target = retryCandidates.single().second
+            screen = retryScreen
+            gestureBaseline = retryScreen
+        }
+
+        // Give PDD's bottom-sheet re-render a short settle window after an
+        // accessibility click that produced no observable transition, then
+        // reacquire the target before the single controlled gesture retry.
+        if (!wait.changed) {
+            pause(SPEC_ENTRY_GESTURE_RETRY_SETTLE_MILLIS)
+            val refreshed = currentScreen(input)
+            if (!refreshed.isPddPackage || !refreshed.pageEvidenceMatched || refreshed.specPanelOpen) {
+                return failure(SPEC_PANEL_EVIDENCE_NOT_MATCHED, "规格入口点击后页面已变化，但规格面板强证据不足 [${panelEvidence(refreshed)}]")
+            }
+            val refreshedCandidates = listOfNotNull(
+                refreshed.specEntry?.let { anchor -> anchor to (refreshed.specEntryClickTarget ?: anchor) },
+                refreshed.quickConfirmationEntry?.let { it to it },
+            ).distinctBy { it.second.path }
+                .let { candidatesToFilter ->
+                    action.textAliases?.let { aliases ->
+                        candidatesToFilter.filter { (anchor, _) -> specEntryMatchesAliases(refreshed, anchor, aliases) }
+                    } ?: candidatesToFilter
+                }
+            if (refreshedCandidates.size != 1) {
+                return failure(SPEC_ENTRY_CLICK_FAILED, "gesture_failed_after_action_click_no_effect")
+            }
+            target = refreshedCandidates.single().second
+            gestureBaseline = refreshed
         }
 
         when (driver.tapSpecFresh(requireNotNull(target))) {
@@ -347,9 +490,12 @@ class PurchaseRehearsalExecutor(
                 "规格入口手势目标不唯一 [${specEntryEvidence(screen, 1, entryReadyWaitPolls)}]",
             )
             FreshActionResult.SUCCESS -> Unit
-            else -> return failure(SPEC_ENTRY_CLICK_FAILED, click.reason.specEntrySubreason())
+            else -> return failure(
+                SPEC_ENTRY_CLICK_FAILED,
+                click.reason.specEntrySubreasonAfterGestureFailure(),
+            )
         }
-        wait = waitForSpecPanel(input, specActionSignature(wait.screen))
+        wait = waitForSpecPanel(input, specActionSignature(gestureBaseline))
         wait.failure?.let { return it }
         if (wait.opened) return null
         if (wait.changed) {
@@ -423,6 +569,7 @@ class PurchaseRehearsalExecutor(
     private fun specEntryEvidence(screen: ParsedPddScreen, candidateCount: Int, entryReadyWaitPolls: Int = 0): String =
         "specEntryCandidates=$candidateCount;explicit=${screen.explicitSpecEntryCount};" +
             "nested=${screen.nestedSpecEntryCount};bottomPurchase=${screen.bottomPurchaseEntryCount};" +
+            "source=${screen.specEntrySource ?: "none"};" +
             "panelAlreadyOpen=${screen.specPanelOpen};reviewPage=${screen.reviewPageOpen};" +
             "pageEvidence=${screen.pageEvidenceMatched};entryReadyWaitPolls=$entryReadyWaitPolls;" +
             "entryReadyWaitMillis=${entryReadyWaitPolls * SPEC_ENTRY_READY_POLL_MILLIS}"
@@ -454,6 +601,12 @@ class PurchaseRehearsalExecutor(
         else -> "unknown"
     }
 
+    private fun FreshClickReason.specEntrySubreasonAfterGestureFailure(): String = when (this) {
+        FreshClickReason.SUCCESS -> "gesture_failed_after_action_click_no_effect"
+        FreshClickReason.UNKNOWN -> "gesture_failed_after_unclassified_action_result"
+        else -> specEntrySubreason()
+    }
+
     private fun selectSpecs(
         input: PurchaseExecutionInput,
         rule: PurchaseRule,
@@ -557,10 +710,16 @@ class PurchaseRehearsalExecutor(
 
     private fun isExactSpecSelected(screen: ParsedPddScreen, dimension: String, target: String): Boolean {
         val candidates = screen.dimensions.filter { it.key == dimension }.flatMap { it.values }
+        if (candidates.any { it.text != target && (it.node.selected || it.node.checked) }) return false
         if (candidates.any { it.text == target && (it.node.selected || it.node.checked) }) return true
+        if (screen.specPanelOpen && fullSummaryTargetMatches(screen.selectedSummary, target)) return true
         return summarySelectionMatches(screen.selectedSummary, dimension, target, candidates)
     }
 
+    private fun fullSummaryTargetMatches(summary: String?, target: String): Boolean =
+        summary != null && Regex("(^|[\\s,，、/|;；:：])" + Regex.escape(target) + "($|[\\s,，、/|;；:：])")
+            .containsMatchIn(summary)
+
     private fun summarySelectionMatches(
         summary: String?,
         dimension: String,
@@ -575,7 +734,11 @@ class PurchaseRehearsalExecutor(
         return matchingCandidates.size == 1 && matchingCandidates.single() == target
     }
 
-    private data class ExactSpecSelectionProof(val dimension: String, val target: String)
+    private data class ExactSpecSelectionProof(
+        val dimension: String,
+        val target: String,
+        val panelType: SpecPanelType,
+    )
 
     private fun exactSpecSelectionProof(
         screen: ParsedPddScreen,
@@ -587,8 +750,9 @@ class PurchaseRehearsalExecutor(
         val tokenCandidates = screen.dimensions.filter { it.key == dimension }.flatMap { it.values }.filter { candidate ->
             if (dimension == "size") SpecValueNormalizer.primarySizeToken(candidate.text) == token else candidate.text == token
         }
-        return ExactSpecSelectionProof(dimension, target).takeIf {
-            tokenCandidates.size == 1 && tokenCandidates.single().text == target
+        return ExactSpecSelectionProof(dimension, target, screen.specPanelType).takeIf {
+            (tokenCandidates.size == 1 && tokenCandidates.single().text == target) ||
+                (tokenCandidates.isEmpty() && screen.specPanelOpen && fullSummaryTargetMatches(screen.selectedSummary, target))
         }
     }
 
@@ -597,7 +761,11 @@ class PurchaseRehearsalExecutor(
         val reason: String,
         val summaryTokenMatched: Boolean,
         val candidateCount: Int,
-        val proofPresent: Boolean,
+        val proofRecorded: Boolean,
+        val proofUsable: Boolean,
+        val targetMatchCount: Int = 0,
+        val relocationAttempted: Boolean = false,
+        val relocationSwipes: Int = 0,
     )
 
     private fun verifyExactSpecSelection(
@@ -608,15 +776,25 @@ class PurchaseRehearsalExecutor(
     ): FinalSpecVerification {
         val candidates = screen.dimensions.filter { it.key == dimension }.flatMap { it.values }
         val matchingNodes = candidates.filter { it.text == target }
-        val proofPresent = proof?.dimension == dimension && proof.target == target
+        val proofRecorded = proof?.dimension == dimension && proof.target == target
+        val proofUsable = proofRecorded && (
+            proof?.panelType == screen.specPanelType ||
+                (screen.specPanelType == SpecPanelType.UNKNOWN && screen.isPddPackage && screen.rootAvailable)
+            )
         if (matchingNodes.size == 1 && (matchingNodes.single().node.selected || matchingNodes.single().node.checked)) {
-            return FinalSpecVerification(true, "selected_node", false, candidates.size, proofPresent)
+            return FinalSpecVerification(true, "selected_node", false, candidates.size, proofRecorded, proofUsable, matchingNodes.size)
+        }
+        if (candidates.any { it.text != target && (it.node.selected || it.node.checked) }) {
+            return FinalSpecVerification(false, "visible_selected_conflict", false, candidates.size, proofRecorded, proofUsable, matchingNodes.size)
         }
 
         val token = if (dimension == "size") SpecValueNormalizer.primarySizeToken(target) else target.trim()
         val summaryTokenMatched = !token.isNullOrBlank() && SpecValueNormalizer.summaryHasExactToken(screen.selectedSummary, token)
         if (!summaryTokenMatched) {
-            return FinalSpecVerification(false, "summary_token_missing", false, candidates.size, proofPresent)
+            if (screen.selectedSummary == null && proofUsable) {
+                return FinalSpecVerification(true, "attempt_selection_state", false, candidates.size, true, true, matchingNodes.size)
+            }
+            return FinalSpecVerification(false, "summary_token_missing", false, candidates.size, proofRecorded, proofUsable, matchingNodes.size)
         }
         // PDD can rerender or scroll the previously selected dimension out of
         // the current viewport while the selected summary remains visible. A
@@ -627,18 +805,83 @@ class PurchaseRehearsalExecutor(
             if (dimension == "size") SpecValueNormalizer.primarySizeToken(candidate.text) == token else candidate.text == token
         }
         if (visibleTokenMatches.size == 1 && visibleTokenMatches.single().text == target) {
-            return FinalSpecVerification(true, "visible_candidate", true, candidates.size, proofPresent)
+            return FinalSpecVerification(true, "visible_candidate", true, candidates.size, proofRecorded, proofUsable, matchingNodes.size)
         }
         if (visibleTokenMatches.isNotEmpty()) {
-            return FinalSpecVerification(false, "visible_candidate_conflict", true, candidates.size, proofPresent)
+            return FinalSpecVerification(false, "visible_candidate_conflict", true, candidates.size, proofRecorded, proofUsable, matchingNodes.size)
         }
-        return if (proofPresent) {
-            FinalSpecVerification(true, "attempt_selection_proof", true, candidates.size, true)
+        return if (proofUsable) {
+            FinalSpecVerification(true, "attempt_selection_proof", true, candidates.size, true, true, matchingNodes.size)
         } else {
-            FinalSpecVerification(false, "selection_proof_missing", true, candidates.size, false)
+            FinalSpecVerification(false, "selection_proof_missing", true, candidates.size, proofRecorded, false, matchingNodes.size)
         }
     }
 
+    private fun verifyExactSpecSelectionWithRelocation(
+        input: PurchaseExecutionInput,
+        dimension: String,
+        target: String,
+        proof: ExactSpecSelectionProof?,
+    ): FinalSpecVerification {
+        var screen = currentScreen(input)
+        screen.problem?.let {
+            return FinalSpecVerification(false, it.code, false, 0, proof != null, false)
+        }
+        var verification = verifyExactSpecSelection(screen, dimension, target, proof)
+        if (verification.confirmed || verification.targetMatchCount > 0 || verification.reason == "visible_selected_conflict") return verification
+        if (!screen.specPanelOpen) return verification.copy(reason = "relocation_panel_closed", relocationAttempted = true)
+
+        var signature = screen.dimensions.joinToString("|") { item ->
+            "${item.key}:${item.values.joinToString(",") { value -> "${value.text}:${value.available}" }}"
+        }
+        var swipes = 0
+        for ((direction, limit) in listOf(SwipeDirection.DOWN to 3, SwipeDirection.UP to 6)) {
+            for (attempt in 0 until limit) {
+                val container = screen.specPanelContainer
+                    ?: return verification.copy(
+                        reason = "relocation_container_missing",
+                        relocationAttempted = true,
+                        relocationSwipes = swipes,
+                    )
+                if (!driver.swipePurchaseIn(container, direction, 350)) {
+                    return verification.copy(
+                        reason = "relocation_swipe_failed",
+                        relocationAttempted = true,
+                        relocationSwipes = swipes,
+                    )
+                }
+                swipes++
+                pause(300)
+                screen = currentScreen(input)
+                screen.problem?.let {
+                    return verification.copy(
+                        reason = it.code,
+                        relocationAttempted = true,
+                        relocationSwipes = swipes,
+                    )
+                }
+                if (!screen.specPanelOpen) {
+                    return verification.copy(
+                        reason = "relocation_panel_closed",
+                        relocationAttempted = true,
+                        relocationSwipes = swipes,
+                    )
+                }
+                verification = verifyExactSpecSelection(screen, dimension, target, proof).copy(
+                    relocationAttempted = true,
+                    relocationSwipes = swipes,
+                )
+                if (verification.confirmed || verification.targetMatchCount > 0 || verification.reason == "visible_selected_conflict") return verification
+                val refreshedSignature = screen.dimensions.joinToString("|") { item ->
+                    "${item.key}:${item.values.joinToString(",") { value -> "${value.text}:${value.available}" }}"
+                }
+                if (refreshedSignature == signature) break
+                signature = refreshedSignature
+            }
+        }
+        return verification.copy(relocationAttempted = true, relocationSwipes = swipes)
+    }
+
     private data class SpecLookup(val node: SnapshotNode? = null, val failure: PurchaseExecutionOutcome? = null)
 
     /**
@@ -648,13 +891,27 @@ class PurchaseRehearsalExecutor(
      * Every gesture is followed by a fresh parse, and unchanged evidence ends
      * that direction early.
      */
+    private fun panelRecognitionFailure(screen: ParsedPddScreen, dimension: String): PurchaseExecutionOutcome =
+        failure("RULE_NOT_MATCHED",
+            "未能识别当前商品规格面板 [dimension=$dimension;panel=${screen.specPanelType};headings=${screen.panelHeadingCount};options=${screen.panelOptionCount};summary=${screen.hasSelectionSummary};quantity=${screen.hasQuantityControls};orderAction=${screen.hasOrderSubmitAction};close=${screen.hasCloseControl};payment=${screen.hasPaymentArea};contextMatched=${screen.purchaseContextMatched}]")
+
+    private fun stableSelectionScreen(input: PurchaseExecutionInput): ParsedPddScreen {
+        var screen = currentScreen(input)
+        repeat(2) {
+            if (screen.specPanelOpen || screen.problem != null) return screen
+            pause(SPEC_SELECTION_POLL_MILLIS)
+            screen = currentScreen(input)
+        }
+        return screen
+    }
+
     private fun locateExactSpec(input: PurchaseExecutionInput, dimension: String, target: String): SpecLookup {
         data class Inspection(val lookup: SpecLookup?, val signature: String, val container: SnapshotNode?)
         fun inspect(): Inspection {
-            val screen = currentScreen(input)
+            val screen = stableSelectionScreen(input)
             screen.problem?.let { return Inspection(SpecLookup(failure = failure(it.code, it.message)), "", null) }
             if (!screen.specPanelOpen) {
-                return Inspection(SpecLookup(failure = failure("RULE_NOT_MATCHED", "商品规格面板已经关闭")), "", null)
+                return Inspection(SpecLookup(failure = panelRecognitionFailure(screen, dimension)), "", null)
             }
             val dimensionValues = screen.dimensions.filter { it.key == dimension }.flatMap { it.values }
             val exact = dimensionValues.filter { it.text == target }
@@ -685,9 +942,171 @@ class PurchaseRehearsalExecutor(
                 currentSignature = inspected.signature
             }
         }
+        if (dimension == "color" || dimension == "size") {
+            locateExactDimensionHorizontally(input, dimension, target)?.let { return it }
+        }
         return SpecLookup(failure = failure(SPEC_TARGET_NOT_VISIBLE, "有界搜索后未找到精确规格"))
     }
 
+    /**
+     * Compatibility fallback for horizontally paged PDD color or size rows. The
+     * established visible/vertical lookup above remains the primary path, so
+     * already successful purchases never enter this branch.
+     */
+    private fun locateExactDimensionHorizontally(
+        input: PurchaseExecutionInput,
+        dimension: String,
+        target: String,
+    ): SpecLookup? {
+        val swipeLimit = DEFAULT_COLLECTOR.limits.getValue("specHorizontalSwipes")
+        val stableReadLimit = DEFAULT_COLLECTOR.limits.getValue("stableEdgeReads")
+        data class ColorInspection(
+            val lookup: SpecLookup?,
+            val screen: ParsedPddScreen,
+            val rows: List<List<VisibleSpecValue>>,
+            val signature: String,
+        )
+
+        fun inspect(): ColorInspection {
+            val screen = stableSelectionScreen(input)
+            screen.problem?.let {
+                return ColorInspection(SpecLookup(failure = failure(it.code, it.message)), screen, emptyList(), "")
+            }
+            if (!screen.specPanelOpen) {
+                return ColorInspection(
+                    SpecLookup(failure = panelRecognitionFailure(screen, dimension)),
+                    screen,
+                    emptyList(),
+                    "",
+                )
+            }
+            val values = screen.dimensions.filter { it.key == dimension }.flatMap { it.values }
+            val exact = values.filter { it.text == target }
+            val lookup = when {
+                exact.size > 1 -> SpecLookup(failure = failure(SPEC_TARGET_AMBIGUOUS, "精确规格匹配到多个控件"))
+                exact.size == 1 && exact.single().available -> SpecLookup(node = exact.single().node)
+                exact.size == 1 -> SpecLookup(failure = failure(SPEC_SAFE_TARGET_MISSING, "精确规格当前不可安全点击"))
+                else -> null
+            }
+            val rows = specValueRows(values)
+            val signature = screen.dimensions.flatMap { it.values }.joinToString("|") { value ->
+                val bounds = value.node.bounds
+                "${value.text}:${bounds.left},${bounds.top},${bounds.right},${bounds.bottom}:${value.available}"
+            }
+            return ColorInspection(lookup, screen, rows, signature)
+        }
+
+        var inspected = inspect()
+        inspected.lookup?.let { return it }
+        var verticalSwipes = 0
+        var horizontalSwipes = 0
+        var lastHorizontalFailure = "none"
+        var termination = "budgetExhausted"
+        val horizontalBudget = mutableMapOf(SwipeDirection.RIGHT to swipeLimit, SwipeDirection.LEFT to swipeLimit)
+
+        fun searchVisibleRows(): SpecLookup? {
+            for (direction in listOf(SwipeDirection.RIGHT, SwipeDirection.LEFT)) {
+                var stableReads = 0
+                var previousSignature = inspected.signature
+                while (horizontalBudget.getValue(direction) > 0) {
+                    // Always reacquire a supported row; never fall back to a stale node.
+                    val anchor = horizontalSpecRow(inspected.screen, inspected.rows)?.firstOrNull()?.node ?: break
+                    horizontalBudget[direction] = horizontalBudget.getValue(direction) - 1
+                    if (!driver.swipeSpecRow(anchor, direction)) {
+                        lastHorizontalFailure = driver.specRowSwipeFailureReason()
+                        // A failed gesture is not evidence that the target is absent.
+                        inspected = inspect()
+                        inspected.lookup?.let { return it }
+                        break
+                    }
+                    horizontalSwipes++
+                    pause(300)
+                    inspected = inspect()
+                    inspected.lookup?.let { return it }
+                    stableReads = if (previousSignature == inspected.signature) stableReads + 1 else 0
+                    previousSignature = inspected.signature
+                    if (stableReads >= stableReadLimit) break
+                }
+            }
+            return null
+        }
+
+        // The original fast path remains first. Recover both ends of a vertical
+        // grid, inspecting each viewport for the exact target and supported rows.
+        val verticalLimit = DEFAULT_COLLECTOR.limits.getValue("specVerticalSwipes")
+        for (direction in listOf(SwipeDirection.DOWN, SwipeDirection.UP)) {
+            var stableReads = 0
+            var previousSignature = inspected.signature
+            for (attempt in 0..verticalLimit) {
+                searchVisibleRows()?.let { return it }
+                if (attempt == verticalLimit) {
+                    termination = "budgetExhausted"
+                    break
+                }
+                val container = inspected.screen.specPanelContainer
+                if (container == null) {
+                    termination = "verticalContainerMissing"
+                    break
+                }
+                if (!driver.swipePurchaseIn(container, direction, 350)) {
+                    termination = "verticalSwipeFailed"
+                    break
+                }
+                verticalSwipes++
+                pause(300)
+                inspected = inspect()
+                inspected.lookup?.let { return it }
+                stableReads = if (previousSignature == inspected.signature) stableReads + 1 else 0
+                previousSignature = inspected.signature
+                if (stableReads >= stableReadLimit) {
+                    searchVisibleRows()?.let { return it }
+                    termination = "stableViewport"
+                    break
+                }
+            }
+        }
+        return SpecLookup(failure = failure(
+            SPEC_TARGET_NOT_VISIBLE,
+            "有界搜索后未找到精确规格 [dimension=$dimension;horizontalSwipes=$horizontalSwipes;verticalRecoverySwipes=$verticalSwipes;visibleCandidates=${inspected.rows.flatten().size};reason=$termination;horizontalFailure=$lastHorizontalFailure]",
+        ))
+    }
+
+    private fun horizontalSpecRow(
+        screen: ParsedPddScreen,
+        rows: List<List<VisibleSpecValue>>,
+    ): List<VisibleSpecValue>? = rows.firstOrNull { row ->
+        row.isNotEmpty() && row.all { value -> hasDedicatedHorizontalAncestor(screen, value.node) }
+    }
+
+    private fun hasDedicatedHorizontalAncestor(screen: ParsedPddScreen, source: SnapshotNode): Boolean {
+        val byPath = screen.sourceNodes.associateBy(SnapshotNode::path)
+        var current: SnapshotNode? = source
+        while (current != null) {
+            if (current.path == screen.specPanelContainer?.path) return false
+            if (current.scrollable && current.bounds.width > current.bounds.height) return true
+            current = current.parentPath?.let(byPath::get)
+        }
+        return false
+    }
+
+    private fun specValueRows(values: List<VisibleSpecValue>): List<List<VisibleSpecValue>> {
+        val sorted = values.sortedWith(compareBy({ it.node.bounds.centerY }, { it.node.bounds.left }))
+        val rows = mutableListOf<MutableList<VisibleSpecValue>>()
+        val centers = mutableListOf<Int>()
+        sorted.forEach { value ->
+            val tolerance = (value.node.bounds.height / 2).coerceIn(24, 80)
+            val index = centers.indexOfFirst { kotlin.math.abs(value.node.bounds.centerY - it) <= tolerance }
+            if (index < 0) {
+                rows += mutableListOf(value)
+                centers += value.node.bounds.centerY
+            } else {
+                rows[index] += value
+                centers[index] = rows[index].map { it.node.bounds.centerY }.average().toInt()
+            }
+        }
+        return rows.onEach { row -> row.sortBy { it.node.bounds.left } }
+    }
+
     private fun setQuantity(quantity: Long): PurchaseExecutionOutcome? {
         val snapshot = driver.capture()
         pageProblem(snapshot)?.let { return it }
@@ -726,23 +1145,26 @@ class PurchaseRehearsalExecutor(
         observedPrice: Long?,
         selectionProofs: Map<String, ExactSpecSelectionProof>,
     ): PurchaseExecutionOutcome? {
-        val screen = currentScreen(input)
-        screen.problem?.let { return failure(it.code, it.message) }
         val selected = listOf("color" to input.mappedColor, "size" to input.mappedSize).filter { it.second.isNotBlank() }.map { (dimension, rawTarget) ->
             dimension to (normalizedTarget(dimension, rawTarget)
                 ?: return failure(SPEC_SAFE_TARGET_MISSING, "下发规格无法安全规范化"))
         }
         selected.forEach { (dimension, target) ->
-            val verification = verifyExactSpecSelection(screen, dimension, target, selectionProofs[dimension])
+            val verification = verifyExactSpecSelectionWithRelocation(input, dimension, target, selectionProofs[dimension])
             if (!verification.confirmed) {
+                val screen = currentScreen(input)
                 val panel = screen.specPanelType.name.lowercase()
                 val diagnostic = "dimension=$dimension,reason=${verification.reason},panel=$panel," +
                     "summary=${screen.selectedSummary != null},tokenMatched=${verification.summaryTokenMatched}," +
-                    "candidates=${verification.candidateCount},proof=${verification.proofPresent}"
+                    "candidates=${verification.candidateCount},targetMatches=${verification.targetMatchCount}," +
+                    "proofRecorded=${verification.proofRecorded},proofUsable=${verification.proofUsable}," +
+                    "relocated=${verification.relocationAttempted},relocationSwipes=${verification.relocationSwipes}"
                 return failure(SPEC_SELECTION_UNCONFIRMED, "最终规格复核未能确认精确选中状态 [$diagnostic]")
             }
         }
         if (readQuantity() != input.quantity) return failure("PURCHASE_QUANTITY_MISMATCH", "最终数量复核失败")
+        val screen = currentScreen(input)
+        screen.problem?.let { return failure(it.code, it.message) }
         val price = screen.priceCent ?: observedPrice ?: return failure("RULE_NOT_MATCHED", "最终价格复核失败")
         if (price !in input.minUnitPriceCent..input.maxUnitPriceCent) {
             return failure("PURCHASE_PRICE_OUT_OF_RANGE", "当前商品单价超出允许范围", price)
@@ -750,6 +1172,18 @@ class PurchaseRehearsalExecutor(
         return null
     }
 
+    private fun hasAllRecordedSelectionProofs(
+        input: PurchaseExecutionInput,
+        proofs: Map<String, ExactSpecSelectionProof>,
+    ): Boolean {
+        val required = listOf("color" to input.mappedColor, "size" to input.mappedSize)
+            .filter { it.second.isNotBlank() }
+            .map { (dimension, rawTarget) -> dimension to normalizedTarget(dimension, rawTarget) }
+        return required.isNotEmpty() && required.all { (dimension, target) ->
+            target != null && proofs[dimension]?.let { it.dimension == dimension && it.target == target } == true
+        }
+    }
+
     private fun applyPostAction(input: PurchaseExecutionInput, action: PurchaseAction): PurchaseExecutionOutcome? {
         if (action.waitAfterMs > 0) pause(action.waitAfterMs)
         action.swipeAfter?.let { swipe ->
@@ -784,8 +1218,16 @@ class PurchaseRehearsalExecutor(
         return normalized.takeIf(SpecValueNormalizer::isSafeSize)
     }
 
-    private fun currentScreen(input: PurchaseExecutionInput): ParsedPddScreen =
-        PddScreenParser.parse(driver.capture(), DEFAULT_COLLECTOR, input.goodsId, null)
+    private fun currentScreen(input: PurchaseExecutionInput): ParsedPddScreen {
+        val snapshot = driver.capture()
+        val screen = PddScreenParser.parse(snapshot, DEFAULT_COLLECTOR, input.goodsId, null, purchasePanelContext)
+        purchasePanelContext = if (screen.isPddPackage && screen.problem == null && screen.specPanelOpen) {
+            screen.specPanelContainer?.let {
+                PurchasePanelContext(it, normalizedTarget("color", input.mappedColor).orEmpty())
+            }
+        } else null
+        return screen
+    }
 
     private fun pageProblem(snapshot: UiSnapshot): PurchaseExecutionOutcome? =
         PddPageClassifier.classify(snapshot.packageName, snapshot.activityName, snapshot.nodes.filter { it.visible }.map { it.label })
@@ -809,12 +1251,17 @@ class PurchaseRehearsalExecutor(
 
     companion object {
         private const val PDD_PACKAGE = "com.xunmeng.pinduoduo"
-        private const val OPEN_PRODUCT_POLL_LIMIT = 50
+        private const val OPEN_PRODUCT_POLL_LIMIT = 150
+        private const val PRODUCT_PAGE_POLL_LIMIT = 150
+        private const val PRODUCT_PAGE_STABLE_READS = 2
+        private const val PRODUCT_PAGE_SETTLE_MILLIS = 1_000L
         private const val OPEN_PRODUCT_RETRY_POLLS = 10
         private const val OPEN_PRODUCT_POLL_MILLIS = 100L
         private const val SPEC_ENTRY_READY_WAIT_POLLS = 20
+        private const val SPEC_ENTRY_STABLE_READS = 2
+        private const val SPEC_ENTRY_GESTURE_RETRY_SETTLE_MILLIS = 500L
         private const val SPEC_ENTRY_READY_POLL_MILLIS = 100L
-        private const val SPEC_POST_CLICK_VERIFY_POLLS = 30
+        private const val SPEC_POST_CLICK_VERIFY_POLLS = 50
         private const val SPEC_SELECTION_SUCCESS_VERIFY_POLLS = 20
         private const val SPEC_SELECTION_FAILED_VERIFY_POLLS = 5
         private const val SPEC_SELECTION_POLL_MILLIS = 100L

android/app/src/main/java/cn/ilapage/goauto/agent/automation/PurchaseScrollLocator.kt

@@ -0,0 +1,24 @@
+package cn.ilapage.goauto.agent.automation
+
+internal data class PurchaseScrollCandidate(
+    val path: String,
+    val className: String?,
+    val bounds: NodeBounds,
+)
+
+internal object PurchaseScrollLocator {
+    fun locate(target: PurchaseScrollCandidate, candidates: List<PurchaseScrollCandidate>): PurchaseScrollCandidate? {
+        val compatible = candidates.filter {
+            it.className == target.className && boundsMatch(it.bounds, target.bounds)
+        }
+        val samePath = compatible.filter { it.path == target.path }
+        if (samePath.isNotEmpty()) return samePath.singleOrNull()
+        return compatible.singleOrNull()
+    }
+
+    private fun boundsMatch(a: NodeBounds, b: NodeBounds): Boolean =
+        kotlin.math.abs(a.left - b.left) <= 32 &&
+            kotlin.math.abs(a.top - b.top) <= 32 &&
+            kotlin.math.abs(a.right - b.right) <= 32 &&
+            kotlin.math.abs(a.bottom - b.bottom) <= 32
+}

android/app/src/main/java/cn/ilapage/goauto/agent/network/AgentApiClient.kt

@@ -73,6 +73,7 @@ data class CurrentPageIdentity(
 data class PurchaseAgentTask(
     val taskId: Long,
     val taskAttemptId: String,
+    val attemptNumber: Int,
     val phase: String,
     val executionMode: String,
     val status: String,
@@ -589,6 +590,7 @@ class AgentApiClient(private val serverUrl: String) {
     private fun purchaseTask(data: JSONObject) = PurchaseAgentTask(
         taskId = data.getLong("taskId"),
         taskAttemptId = data.optString("taskAttemptId"),
+        attemptNumber = data.optInt("attemptNumber", 1),
         phase = data.optString("phase"),
         executionMode = data.getString("executionMode"),
         status = data.getString("status"),

android/app/src/main/java/cn/ilapage/goauto/agent/persistence/AgentDiagnosticSchema.kt

@@ -1,7 +1,7 @@
 package cn.ilapage.goauto.agent.persistence
 
 internal object AgentDiagnosticSchema {
-    const val VERSION = 2
+    const val VERSION = 3
 
     val colorDiagnosticColumns = linkedMapOf(
         "color_row_count" to "INTEGER",
@@ -14,6 +14,15 @@ internal object AgentDiagnosticSchema {
         "horizontal_swipe_count" to "INTEGER",
     )
 
+    val purchaseFailureColumns = linkedMapOf(
+        "attempt_id" to "TEXT",
+        "device_id" to "INTEGER",
+        "error_code" to "TEXT",
+        "failure_message" to "TEXT",
+        "page_evidence" to "TEXT",
+        "last_step" to "TEXT",
+    )
+
     val createTableSql =
         """CREATE TABLE agent_diagnostic (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -42,14 +51,33 @@ internal object AgentDiagnosticSchema {
             initial_selected_size_count INTEGER,
             selected_summary_present INTEGER,
             horizontal_swipe_count INTEGER,
+            attempt_id TEXT,
+            device_id INTEGER,
+            error_code TEXT,
+            failure_message TEXT,
+            page_evidence TEXT,
+            last_step TEXT,
             agent_version TEXT NOT NULL,
             created_at INTEGER NOT NULL
         )""".trimIndent()
 
-    fun v2MigrationStatements(oldVersion: Int, newVersion: Int, existingColumns: Set<String>): List<String> {
-        if (oldVersion >= 2 || newVersion < 2) return emptyList()
-        return colorDiagnosticColumns.mapNotNull { (name, definition) ->
-            if (name in existingColumns) null else "ALTER TABLE agent_diagnostic ADD COLUMN $name $definition"
+    fun migrationStatements(oldVersion: Int, newVersion: Int, existingColumns: Set<String>): List<String> {
+        if (oldVersion >= newVersion) return emptyList()
+        val statements = mutableListOf<String>()
+        if (oldVersion < 2 && newVersion >= 2) {
+            colorDiagnosticColumns.forEach { (name, definition) ->
+                if (name !in existingColumns) statements += "ALTER TABLE agent_diagnostic ADD COLUMN $name $definition"
+            }
         }
+        if (oldVersion < 3 && newVersion >= 3) {
+            purchaseFailureColumns.forEach { (name, definition) ->
+                if (name !in existingColumns) statements += "ALTER TABLE agent_diagnostic ADD COLUMN $name $definition"
+            }
+        }
+        return statements
     }
+
+    // Kept for existing migration tests and callers; new code should use migrationStatements.
+    fun v2MigrationStatements(oldVersion: Int, newVersion: Int, existingColumns: Set<String>): List<String> =
+        migrationStatements(oldVersion, newVersion, existingColumns)
 }

android/app/src/main/java/cn/ilapage/goauto/agent/persistence/AgentDiagnosticStore.kt

@@ -4,6 +4,8 @@ import android.content.ContentValues
 import android.content.Context
 import android.database.sqlite.SQLiteDatabase
 import android.database.sqlite.SQLiteOpenHelper
+import org.json.JSONArray
+import org.json.JSONObject
 import cn.ilapage.goauto.agent.BuildConfig
 
 enum class AgentDiagnosticStage {
@@ -71,6 +73,7 @@ enum class AgentDiagnosticReason {
     LINK_AMBIGUOUS,
     LINK_NOT_FOUND,
     UNKNOWN,
+    PURCHASE_FAILURE,
 }
 
 data class AgentDiagnosticEvent(
@@ -99,6 +102,12 @@ data class AgentDiagnosticEvent(
     val initialSelectedSizeCount: Int? = null,
     val selectedSummaryPresent: Boolean? = null,
     val horizontalSwipeCount: Int? = null,
+    val attemptId: String? = null,
+    val deviceId: Long? = null,
+    val errorCode: String? = null,
+    val failureMessage: String? = null,
+    val pageEvidence: String? = null,
+    val lastStep: String? = null,
     val createdAt: Long = System.currentTimeMillis(),
 )
 
@@ -118,7 +127,7 @@ internal object AgentDiagnosticRetentionPolicy {
     fun cutoff(createdAt: Long): Long = createdAt - RETENTION_MILLIS
 }
 
-class AgentDiagnosticStore(context: Context) : SQLiteOpenHelper(context, DATABASE_NAME, null, DATABASE_VERSION) {
+class AgentDiagnosticStore(private val context: Context) : SQLiteOpenHelper(context, DATABASE_NAME, null, DATABASE_VERSION) {
     override fun onCreate(db: SQLiteDatabase) {
         db.execSQL(AgentDiagnosticSchema.createTableSql)
         db.execSQL("CREATE INDEX idx_agent_diagnostic_task ON agent_diagnostic(task_id, id)")
@@ -126,7 +135,7 @@ class AgentDiagnosticStore(context: Context) : SQLiteOpenHelper(context, DATABAS
 
     override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
         val existing = columnNames(db)
-        AgentDiagnosticSchema.v2MigrationStatements(oldVersion, newVersion, existing).forEach(db::execSQL)
+        AgentDiagnosticSchema.migrationStatements(oldVersion, newVersion, existing).forEach(db::execSQL)
     }
 
     private fun columnNames(db: SQLiteDatabase): Set<String> =
@@ -171,6 +180,12 @@ class AgentDiagnosticStore(context: Context) : SQLiteOpenHelper(context, DATABAS
                 putNullableInt("initial_selected_size_count", event.initialSelectedSizeCount)
                 putNullableBoolean("selected_summary_present", event.selectedSummaryPresent)
                 putNullableInt("horizontal_swipe_count", event.horizontalSwipeCount)
+                event.attemptId?.let { put("attempt_id", it.take(MAX_TEXT_CHARS)) }
+                putNullableLong("device_id", event.deviceId)
+                event.errorCode?.let { put("error_code", it.take(MAX_ERROR_CODE_CHARS)) }
+                event.failureMessage?.let { put("failure_message", sanitizeText(it)) }
+                event.pageEvidence?.let { put("page_evidence", sanitizeText(it)) }
+                event.lastStep?.let { put("last_step", it.take(MAX_TEXT_CHARS)) }
                 put("agent_version", BuildConfig.VERSION_NAME)
                 put("created_at", event.createdAt)
             }
@@ -186,6 +201,53 @@ class AgentDiagnosticStore(context: Context) : SQLiteOpenHelper(context, DATABAS
         }
     }
 
+    /** Returns only the allow-listed, structured fields; raw accessibility data is never exported. */
+    @Synchronized
+    fun exportTaskJson(taskId: Long): String {
+        require(taskId > 0)
+        val events = JSONArray()
+        readableDatabase.query(
+            "agent_diagnostic",
+            arrayOf(
+                "task_id", "stage", "reason", "attempt", "elapsed_ms", "attempt_id", "device_id",
+                "error_code", "failure_message", "page_evidence", "last_step", "agent_version", "created_at",
+            ),
+            "task_id = ?",
+            arrayOf(taskId.toString()),
+            null,
+            null,
+            "id ASC",
+        ).use { cursor ->
+            while (cursor.moveToNext()) {
+                events.put(JSONObject().apply {
+                    put("taskId", cursor.getLong(0))
+                    put("stage", cursor.getString(1))
+                    put("reason", cursor.getString(2))
+                    put("attempt", cursor.getInt(3))
+                    put("elapsedMs", cursor.getLong(4))
+                    putNullable("attemptId", cursor, 5)
+                    if (!cursor.isNull(6)) put("deviceId", cursor.getLong(6))
+                    putNullable("errorCode", cursor, 7)
+                    putNullable("message", cursor, 8)
+                    putNullable("pageEvidence", cursor, 9)
+                    putNullable("lastStep", cursor, 10)
+                    put("agentVersion", cursor.getString(11))
+                    put("createdAt", cursor.getLong(12))
+                })
+            }
+        }
+        return JSONObject().put("taskId", taskId).put("events", events).toString()
+    }
+
+    /** Writes a task export into app-specific external storage so it can be pulled over USB. */
+    @Synchronized
+    fun exportTaskJsonFile(taskId: Long, fileName: String = "task-$taskId.json"): java.io.File {
+        val safeName = fileName.replace(Regex("[^A-Za-z0-9._-]"), "_").take(96)
+        val directory = context.getExternalFilesDir("diagnostics") ?: error("诊断导出目录不可用")
+        if (!directory.exists() && !directory.mkdirs()) error("诊断导出目录创建失败")
+        return java.io.File(directory, safeName).apply { writeText(exportTaskJson(taskId), Charsets.UTF_8) }
+    }
+
     private fun ContentValues.putNullableBoolean(key: String, value: Boolean?) {
         value?.let { put(key, if (it) 1 else 0) }
     }
@@ -194,11 +256,25 @@ class AgentDiagnosticStore(context: Context) : SQLiteOpenHelper(context, DATABAS
         value?.let { put(key, it.coerceAtLeast(0)) }
     }
 
+    private fun ContentValues.putNullableLong(key: String, value: Long?) {
+        value?.let { put(key, it) }
+    }
+
+    private fun JSONObject.putNullable(key: String, cursor: android.database.Cursor, index: Int) {
+        if (!cursor.isNull(index)) put(key, cursor.getString(index))
+    }
+
+    private fun sanitizeText(value: String): String = value
+        .replace(Regex("(?i)(addressSuffix|收货地址|详细地址)\\s*[:=：][^;，,\\]]+"), "[REDACTED]")
+        .take(MAX_TEXT_CHARS)
+
     companion object {
         private const val DATABASE_NAME = "goauto_diagnostics.db"
         private const val DATABASE_VERSION = AgentDiagnosticSchema.VERSION
         private const val MAX_CLASS_NAME_CHARS = 160
         private const val MAX_ROW_VALUE_COUNTS_CHARS = 160
+        private const val MAX_TEXT_CHARS = 512
+        private const val MAX_ERROR_CODE_CHARS = 96
         private val ROW_VALUE_COUNTS_PATTERN = Regex("[0-9]+(?:,[0-9]+)*")
         private val ALLOWED_ZONES = setOf("top-left", "top-center", "top-right", "middle", "bottom")
     }

android/app/src/main/java/cn/ilapage/goauto/agent/service/AgentForegroundService.kt

@@ -256,13 +256,20 @@ class AgentForegroundService : Service() {
         flushPurchaseOutbox(api, token)
         val collectionCooldown = activeCollectionCooldown()
         val purchaseTask = api.nextPurchaseTask(token)
-        when (TaskDispatchPolicy.decide(purchaseTask != null, collectionCooldown != null)) {
+        when (TaskDispatchPolicy.decide(purchaseTask?.status, collectionCooldown != null)) {
             TaskDispatchDecision.RUN_PURCHASE -> {
                 cancelIdleReturn("收到新的采购任务")
                 releaseCollectionCooldownWakeLock()
                 schedulePurchaseTask(api, requireNotNull(purchaseTask), token)
                 return MANUAL_PURCHASE_TASK
             }
+            TaskDispatchDecision.WAIT_FOR_PURCHASE_MATCH -> {
+                val waitingTask = requireNotNull(purchaseTask)
+                cancelIdleReturn("等待采购规格匹配")
+                stateStore.update("ONLINE", "采购任务 #${waitingTask.taskId} 正在匹配规格", tokenStored = true)
+                updateNotification("采购任务 #${waitingTask.taskId} 等待规格匹配")
+                return MANUAL_PURCHASE_MATCH_PENDING
+            }
             TaskDispatchDecision.WAIT_FOR_COLLECTION_COOLDOWN -> {
                 val ticket = requireNotNull(collectionCooldown)
                 showCollectionCooldown(ticket)
@@ -438,7 +445,10 @@ class AgentForegroundService : Service() {
         GoAutoAccessibilityService.instance?.dismissPurchaseResultBubble()
         acquireTaskWakeLock()
         var resultSafelyStored = false
+        var diagnosticRecorded = false
+        var activeTask = initial
         val lastStep = AtomicReference("started")
+        val lastPanelEvidence = AtomicReference<String?>(null)
         try {
             val claimed = if (initial.status == "pending") {
                 api.claimPurchaseTask(initial.taskId, UUID.randomUUID().toString(), token)
@@ -446,6 +456,7 @@ class AgentForegroundService : Service() {
             val task = if (claimed.status == "pending") {
                 api.startPurchaseTask(claimed.taskId, UUID.randomUUID().toString(), token)
             } else claimed
+            activeTask = task
             check(task.status == "running" && task.taskAttemptId.isNotBlank()) { "采购任务没有有效 attempt" }
             val snapshotHashValid = task.ruleSnapshotHash.matches(Regex("^[0-9a-f]{64}$"))
             val snapshotHash = task.ruleSnapshotHash.takeIf { snapshotHashValid } ?: "0".repeat(64)
@@ -473,13 +484,16 @@ class AgentForegroundService : Service() {
                     } else {
                         PurchaseRehearsalExecutor(
                             driver = accessibility,
-                            openLink = { PddLinkLauncher(this).open(it) },
+                            openLink = { PddLinkLauncher(this).open(it, preferDirect = true) },
                             probeSpecs = { collectPurchaseProbe(accessibility, task, parsedRule) },
                             stepChanged = { step ->
                                 lastStep.set(step)
                                 purchaseStore.updateStep(task.taskId, task.taskAttemptId, step)
                             },
-                            panelDiagnostic = { evidence -> Log.i("GoAutoPurchasePanel", "task=${task.taskId};$evidence") },
+                            panelDiagnostic = { evidence ->
+                                lastPanelEvidence.set(evidence)
+                                Log.i("GoAutoPurchasePanel", "task=${task.taskId};$evidence")
+                            },
                             beforeOrderSubmit = { evidence ->
                                 val boundaryRequestId = UUID.randomUUID().toString()
                                 val finalEvidence = JSONObject()
@@ -519,6 +533,10 @@ class AgentForegroundService : Service() {
             val payload = purchaseResultPayload(requestId, task.taskAttemptId, outcome)
             purchaseStore.completeAndEnqueue(task.taskId, task.taskAttemptId, requestId, payload)
             resultSafelyStored = true
+            if (outcome.resultType == "failed") {
+                recordPurchaseDiagnostic(task, outcome, lastStep.get(), lastPanelEvidence.get())
+                diagnosticRecorded = true
+            }
             PurchaseResultBubblePolicy.create(
                 taskId = task.taskId,
                 resultType = outcome.resultType,
@@ -533,8 +551,24 @@ class AgentForegroundService : Service() {
             stateStore.update(if (outcome.resultType == "failed") "TASK_ERROR" else "ONLINE", message, tokenStored = true)
             updateNotification(if (outcome.resultType == "failed") "$taskLabel #${task.taskId} 失败" else "$taskLabel #${task.taskId} 已提交")
         } catch (error: AgentApiException) {
+            if (!diagnosticRecorded) {
+                recordPurchaseDiagnostic(
+                    activeTask,
+                    PurchaseExecutionOutcome("failed", error.code, error.message ?: "采购接口调用失败"),
+                    lastStep.get(),
+                    lastPanelEvidence.get(),
+                )
+            }
             stateStore.update("TASK_ERROR", "${error.code}：${error.message}", tokenStored = true)
         } catch (error: Exception) {
+            if (!diagnosticRecorded) {
+                recordPurchaseDiagnostic(
+                    activeTask,
+                    PurchaseExecutionOutcome("failed", "AGENT_PURCHASE_EXCEPTION", error.message ?: "采购执行异常"),
+                    lastStep.get(),
+                    lastPanelEvidence.get(),
+                )
+            }
             stateStore.update("TASK_ERROR", error.message ?: "采购演练执行异常", tokenStored = true)
         } finally {
             if (!resultSafelyStored) cancelIdleReturn("采购结果未安全保存")
@@ -542,6 +576,45 @@ class AgentForegroundService : Service() {
         }
     }
 
+    private fun recordPurchaseDiagnostic(
+        task: PurchaseAgentTask,
+        outcome: PurchaseExecutionOutcome,
+        lastStep: String,
+        panelEvidence: String?,
+    ) {
+        if (task.taskId <= 0L) return
+        val deviceId = runCatching { identityStore.credentials()?.deviceId }.getOrNull()
+        val event = AgentDiagnosticEvent(
+            taskId = task.taskId,
+            stage = purchaseDiagnosticStage(lastStep),
+            reason = AgentDiagnosticReason.PURCHASE_FAILURE,
+            attempt = task.attemptNumber,
+            attemptId = task.taskAttemptId.takeIf { it.isNotBlank() },
+            deviceId = deviceId,
+            errorCode = outcome.errorCode,
+            failureMessage = outcome.message,
+            pageEvidence = panelEvidence,
+            lastStep = lastStep,
+        )
+        diagnosticExecutor.execute {
+            runCatching {
+                diagnosticStore.record(event)
+                val export = diagnosticStore.exportTaskJsonFile(task.taskId)
+                Log.i("GoAutoDiagnostic", "purchase diagnostic exported task=${task.taskId};file=${export.absolutePath}")
+            }.onFailure { error ->
+                Log.w("GoAutoDiagnostic", "purchase diagnostic export failed: ${error.javaClass.simpleName}")
+            }
+        }
+    }
+
+    private fun purchaseDiagnosticStage(step: String): AgentDiagnosticStage = when (step) {
+        "openProduct" -> AgentDiagnosticStage.DETAIL_ENTRY
+        "openSpecPanel" -> AgentDiagnosticStage.SPEC_PANEL_ENTRY
+        "selectSpec" -> AgentDiagnosticStage.SIZE_DISCOVERY
+        "verifyUnitPrice", "verifyOrderSummary" -> AgentDiagnosticStage.PAGE_STABILITY
+        else -> AgentDiagnosticStage.DETAIL_ENTRY
+    }
+
     private fun collectPurchaseProbe(accessibility: GoAutoAccessibilityService, task: PurchaseAgentTask, purchaseRule: PurchaseRule): String? {
         val snapshot = accessibility.capture()
         val activity = snapshot.activityName ?: return null
@@ -1074,6 +1147,7 @@ class AgentForegroundService : Service() {
         const val MANUAL_EMPTY = "empty"
         const val MANUAL_COLLECTION_TASK = "collection_task"
         const val MANUAL_PURCHASE_TASK = "purchase_task"
+        const val MANUAL_PURCHASE_MATCH_PENDING = "purchase_match_pending"
         const val MANUAL_BUSY = "busy"
         const val MANUAL_CONFIG_REQUIRED = "config_required"
         const val MANUAL_AUTH_ERROR = "auth_error"

android/app/src/main/java/cn/ilapage/goauto/agent/service/AgentStateStore.kt

@@ -99,13 +99,15 @@ internal object CollectionCooldownPolicy {
 
 internal enum class TaskDispatchDecision {
     RUN_PURCHASE,
+    WAIT_FOR_PURCHASE_MATCH,
     WAIT_FOR_COLLECTION_COOLDOWN,
     CHECK_COLLECTION,
 }
 
 internal object TaskDispatchPolicy {
-    fun decide(purchaseAvailable: Boolean, collectionCooldownActive: Boolean): TaskDispatchDecision = when {
-        purchaseAvailable -> TaskDispatchDecision.RUN_PURCHASE
+    fun decide(purchaseStatus: String?, collectionCooldownActive: Boolean): TaskDispatchDecision = when {
+        purchaseStatus == "spec_probe_pending" -> TaskDispatchDecision.WAIT_FOR_PURCHASE_MATCH
+        purchaseStatus != null -> TaskDispatchDecision.RUN_PURCHASE
         collectionCooldownActive -> TaskDispatchDecision.WAIT_FOR_COLLECTION_COOLDOWN
         else -> TaskDispatchDecision.CHECK_COLLECTION
     }

android/app/src/main/java/cn/ilapage/goauto/agent/ui/TaskHistoryFragment.kt

@@ -83,10 +83,12 @@ internal object CollectionResetPolicy {
 internal object PurchaseRetryPolicy {
     fun showsAction(status: String, retryable: Boolean): Boolean = status == "failed" && retryable
 
+    fun usesInPlaceReset(continuing: Boolean): Boolean = !continuing
+
     fun confirmationMessage(continuing: Boolean = false): String = if (continuing) {
         "替代商品已完成匹配。系统会保留原任务并创建一笔新采购任务；可能创建拼多多待付款订单，但不会支付。"
     } else {
-        "系统会保留原任务，并根据当前商品档案和最新采购规则创建一笔新采购任务；可能创建拼多多待付款订单，但不会支付。"
+        "系统会复用原采购任务并开始新一次执行，使用当前有效采购规则，商品和规格等任务快照保持不变；可能创建拼多多待付款订单，但不会支付。"
     }
 }
 
@@ -746,7 +748,7 @@ class TaskHistoryFragment : Fragment() {
                 contentDescription = "重试采购任务 CG-${task.taskId}"
                 setOnClickListener { confirmPurchaseRetry(task) }
             }, collectionCardParams())
-            resultColumn.addView(context.centeredMessage("重试边界", "保留当前失败任务并创建新任务；新任务读取当前商品档案和采购规则，不会执行支付。"))
+            resultColumn.addView(context.centeredMessage("重试边界", "复用当前任务并新增一次执行；使用当前有效采购规则，商品和规格快照不变，不会执行支付。"))
         } else if (!replacementInProgress && task.status == "failed") {
             val reason = task.retryDisabledReason?.takeIf(String::isNotBlank) ?: "请在管理端核对任务状态。"
             resultColumn.addView(context.centeredMessage("不可重试", reason))
@@ -864,18 +866,25 @@ class TaskHistoryFragment : Fragment() {
         val generation = ++requestGeneration
         showLoading(if (continuing) "正在提交继续采购请求…" else "正在提交重试请求…")
         Thread {
-            runCatching {
+            runCatching<Unit> {
                 val client = AgentApiClient(serverUrl)
                 val requestId = UUID.randomUUID().toString()
-                client.retryPurchaseTask(taskId, requestId, credentials.token)
-            }
-                .onSuccess { result ->
+                if (PurchaseRetryPolicy.usesInPlaceReset(continuing)) {
+                    val result = client.resetPurchaseTask(taskId, requestId, credentials.token)
+                    resultColumn.post {
+                        if (!isAdded || generation != requestGeneration) return@post
+                        AgentForegroundService.start(requireContext())
+                        showPurchaseResetSuccess(result.taskNo, result.taskId, result.attemptNumber)
+                    }
+                } else {
+                    val result = client.retryPurchaseTask(taskId, requestId, credentials.token)
                     resultColumn.post {
                         if (!isAdded || generation != requestGeneration) return@post
                         AgentForegroundService.start(requireContext())
                         showPurchaseRetrySuccess(result.sourceTaskNo, result.taskNo, result.taskId)
                     }
                 }
+            }
                 .onFailure { error ->
                     resultColumn.post {
                         if (isAdded && generation == requestGeneration) {
@@ -886,6 +895,24 @@ class TaskHistoryFragment : Fragment() {
         }.start()
     }
 
+    private fun showPurchaseResetSuccess(taskNo: String, taskId: Long, attemptNumber: Int) {
+        resultColumn.removeAllViews()
+        resultColumn.addView(requireContext().centeredMessage(
+            "$taskNo 已进入第 $attemptNumber 次执行",
+            "原采购任务已复用，并将由当前设备按正常队列执行；系统不会支付。",
+        ))
+        resultColumn.addView(MaterialButton(requireContext()).apply {
+            text = "查看当前任务"
+            minimumHeight = requireContext().dp(48)
+            setOnClickListener { loadPurchaseDetail(taskId) }
+        }, collectionCardParams())
+        resultColumn.addView(MaterialButton(requireContext(), null, com.google.android.material.R.attr.materialButtonOutlinedStyle).apply {
+            text = "返回采购记录"
+            minimumHeight = requireContext().dp(48)
+            setOnClickListener { page = 1; load() }
+        }, collectionCardParams())
+    }
+
     private fun showPurchaseRetrySuccess(sourceTaskNo: String, taskNo: String, taskId: Long) {
         resultColumn.removeAllViews()
         resultColumn.addView(requireContext().centeredMessage(

android/app/src/test/java/cn/ilapage/goauto/agent/CollectionCooldownPolicyTest.kt

@@ -86,15 +86,19 @@ class CollectionCooldownPolicyTest {
     fun `purchase keeps priority while collection waits for cooldown`() {
         assertEquals(
             TaskDispatchDecision.RUN_PURCHASE,
-            TaskDispatchPolicy.decide(purchaseAvailable = true, collectionCooldownActive = true),
+            TaskDispatchPolicy.decide(purchaseStatus = "pending", collectionCooldownActive = true),
+        )
+        assertEquals(
+            TaskDispatchDecision.WAIT_FOR_PURCHASE_MATCH,
+            TaskDispatchPolicy.decide(purchaseStatus = "spec_probe_pending", collectionCooldownActive = true),
         )
         assertEquals(
             TaskDispatchDecision.WAIT_FOR_COLLECTION_COOLDOWN,
-            TaskDispatchPolicy.decide(purchaseAvailable = false, collectionCooldownActive = true),
+            TaskDispatchPolicy.decide(purchaseStatus = null, collectionCooldownActive = true),
         )
         assertEquals(
             TaskDispatchDecision.CHECK_COLLECTION,
-            TaskDispatchPolicy.decide(purchaseAvailable = false, collectionCooldownActive = false),
+            TaskDispatchPolicy.decide(purchaseStatus = null, collectionCooldownActive = false),
         )
     }
 }

android/app/src/test/java/cn/ilapage/goauto/agent/PddLaunchFallbackTest.kt

@@ -0,0 +1,25 @@
+package cn.ilapage.goauto.agent
+
+import cn.ilapage.goauto.agent.automation.PddLaunchFallback
+import org.junit.Assert.*
+import org.junit.Test
+
+class PddLaunchFallbackTest {
+    @Test fun directSuccessDoesNotStartBrowser() {
+        assertTrue(PddLaunchFallback.open(true, { true }, { error("browser must not start") }))
+    }
+    @Test fun missingHandlerFallsBackOnce() {
+        var browserCalls = 0
+        assertTrue(PddLaunchFallback.open(true, { throw IllegalStateException("no handler") }, { browserCalls++; true }))
+        assertEquals(1, browserCalls)
+    }
+    @Test fun rejectedDirectLaunchFallsBack() {
+        assertTrue(PddLaunchFallback.open(true, { false }, { true }))
+        assertFalse(PddLaunchFallback.open(true, { false }, { false }))
+    }
+    @Test fun collectionKeepsBrowserEntry() {
+        var directCalls = 0
+        assertTrue(PddLaunchFallback.open(false, { directCalls++; true }, { true }))
+        assertEquals(0, directCalls)
+    }
+}

android/app/src/test/java/cn/ilapage/goauto/agent/PddProductDetailCollectorTest.kt

@@ -11,6 +11,7 @@ import cn.ilapage.goauto.agent.automation.PddCollectorConfig
 import cn.ilapage.goauto.agent.automation.PddCollectorDriver
 import cn.ilapage.goauto.agent.automation.PddProductDetailCollector
 import cn.ilapage.goauto.agent.automation.PddScreenParser
+import cn.ilapage.goauto.agent.automation.PurchasePanelContext
 import cn.ilapage.goauto.agent.automation.SnapshotNode
 import cn.ilapage.goauto.agent.automation.SpecPanelType
 import cn.ilapage.goauto.agent.automation.SwipeDirection
@@ -26,6 +27,62 @@ import org.junit.Assert.assertTrue
 import org.junit.Test
 
 class PddProductDetailCollectorTest {
+    private fun prefixlessPanel(): UiSnapshot = UiSnapshot(PDD_PACKAGE, ACTIVITY, listOf(
+        node("root", "", 0, 0, 1080, 2376),
+        node("close", "关闭", 970, 270, 1050, 350, clickable = true),
+        node("info", "", 0, 770, 1080, 1157),
+        node("info/summary", "米白色（有里布） 2XL 建议131到150斤", 396, 878, 1053, 992, parentPath = "info"),
+        node("info/quantity", "1", 480, 1046, 561, 1121, className = "android.widget.EditText", parentPath = "info"),
+        node("minus", "减少数量", 396, 1046, 470, 1121, clickable = true),
+        node("plus", "增加数量", 570, 1046, 645, 1121, clickable = true),
+        node("scroll", "", 0, 1294, 1080, 2079, scrollable = true),
+        node("scroll/color-title", "颜色分类", 36, 1319, 216, 1380, parentPath = "scroll"),
+        node("scroll/color", "米白色（有里布）", 36, 1405, 352, 1808, clickable = true, selected = true, parentPath = "scroll"),
+        node("scroll/size-title", "尺码", 36, 1858, 126, 1911, parentPath = "scroll"),
+        node("scroll/size", "XL 建议111到130斤", 36, 1930, 440, 2015, clickable = true, parentPath = "scroll"),
+        node("payment", "微信支付", 112, 2100, 929, 2157),
+        node("submit", "提交订单", 375, 2225, 705, 2284, clickable = true),
+    ))
+
+    @Test fun `prefixless selected panel retains structural recognition and product summary`() {
+        val parsed = PddScreenParser.parse(prefixlessPanel(), config(), GOODS_ID, evidence())
+        assertEquals(SpecPanelType.NORMAL_SCROLLABLE, parsed.specPanelType)
+        assertEquals("米白色（有里布） 2XL 建议131到150斤", parsed.selectedSummary)
+    }
+
+    @Test fun `prefixless panel requires quantity and order evidence`() {
+        for (missing in listOf("plus", "submit", "payment")) {
+            val snapshot = prefixlessPanel()
+            val parsed = PddScreenParser.parse(snapshot.copy(nodes = snapshot.nodes.filterNot { it.path == missing }), config(), GOODS_ID, evidence())
+            assertFalse(parsed.specPanelOpen)
+            assertEquals(null, parsed.selectedSummary)
+        }
+    }
+
+    @Test fun `ambiguous product summaries are not used`() {
+        val snapshot = prefixlessPanel()
+        val extra = node("info/other", "米白色（有里布） XL 建议111到130斤", 396, 800, 1053, 870, parentPath = "info")
+        val parsed = PddScreenParser.parse(snapshot.copy(nodes = snapshot.nodes + extra), config(), GOODS_ID, evidence())
+        assertEquals(null, parsed.selectedSummary)
+    }
+
+    @Test fun `scrolling away color heading and options preserves known purchase panel and summary`() {
+        val initial = prefixlessPanel()
+        val opened = PddScreenParser.parse(initial, config(), GOODS_ID, evidence())
+        val context = PurchasePanelContext(requireNotNull(opened.specPanelContainer), "米白色（有里布）")
+        val scrolled = initial.copy(nodes = initial.nodes.filterNot { it.path.startsWith("scroll/color") })
+        val continued = PddScreenParser.parse(scrolled, config(), GOODS_ID, evidence(), context)
+        assertEquals(1, continued.panelHeadingCount)
+        assertTrue(continued.specPanelOpen)
+        assertEquals("米白色（有里布） 2XL 建议131到150斤", continued.selectedSummary)
+        assertTrue(continued.dimensions.none { it.key == "color" })
+        assertFalse(PddScreenParser.parse(scrolled, config(), GOODS_ID, evidence()).specPanelOpen)
+        assertFalse(PddScreenParser.parse(scrolled, config(), GOODS_ID, evidence(),
+            context.copy(container = context.container.copy(path = "other"))).specPanelOpen)
+        assertFalse(PddScreenParser.parse(scrolled.copy(nodes = scrolled.nodes.filterNot { it.path == "submit" }),
+            config(), GOODS_ID, evidence(), context).specPanelOpen)
+    }
+
     @Test
     fun `parser removes only trailing size price and keeps raw evidence`() {
         val snapshot = UiSnapshot(

android/app/src/test/java/cn/ilapage/goauto/agent/PurchaseLiveAutomationTest.kt

@@ -1,6 +1,8 @@
 package cn.ilapage.goauto.agent
 
 import cn.ilapage.goauto.agent.automation.FreshActionResult
+import cn.ilapage.goauto.agent.automation.FreshClickOutcome
+import cn.ilapage.goauto.agent.automation.FreshClickReason
 import cn.ilapage.goauto.agent.automation.NodeBounds
 import cn.ilapage.goauto.agent.automation.PurchaseExecutionInput
 import cn.ilapage.goauto.agent.automation.PurchaseLiveAutomation
@@ -16,6 +18,81 @@ import org.junit.Assert.assertTrue
 import org.junit.Test
 
 class PurchaseLiveAutomationTest {
+    @Test
+    fun `verified spec panel advances through one exact confirm target`() {
+        val driver = SpecConfirmationDriver()
+
+        PurchaseLiveAutomation(driver, pause = {}).advanceToOrderConfirmation()
+
+        assertEquals(listOf("确定"), driver.clicked)
+        assertEquals("order", driver.page)
+    }
+
+    @Test
+    fun `ambiguous missing and unchanged spec confirmation stop safely`() {
+        val ambiguous = SpecConfirmationDriver(confirmLabels = listOf("确定", "确认"))
+        val ambiguousError = runCatching { PurchaseLiveAutomation(ambiguous, pause = {}).advanceToOrderConfirmation() }
+            .exceptionOrNull() as PurchaseLiveException
+        assertEquals("PURCHASE_SPEC_CONFIRM_TARGET_AMBIGUOUS", ambiguousError.code)
+        assertTrue(ambiguous.clicked.isEmpty())
+
+        val missing = SpecConfirmationDriver(confirmLabels = emptyList(), specPanelScrollable = true)
+        val missingError = runCatching { PurchaseLiveAutomation(missing, pause = {}).advanceToOrderConfirmation() }
+            .exceptionOrNull() as PurchaseLiveException
+        assertEquals("PURCHASE_SPEC_CONFIRM_TARGET_MISSING", missingError.code)
+        assertTrue(missing.clicked.isEmpty())
+
+        val unchanged = SpecConfirmationDriver(advanceAfterClick = false)
+        val unchangedError = runCatching { PurchaseLiveAutomation(unchanged, pause = {}).advanceToOrderConfirmation() }
+            .exceptionOrNull() as PurchaseLiveException
+        assertEquals("PURCHASE_SPEC_CONFIRMATION_UNCONFIRMED", unchangedError.code)
+        assertEquals(listOf("确定"), unchanged.clicked)
+    }
+
+    @Test
+    fun `existing order confirmation does not click submit or payment controls`() {
+        val driver = SpecConfirmationDriver(startOnOrderPage = true)
+
+        PurchaseLiveAutomation(driver, pause = {}).advanceToOrderConfirmation()
+
+        assertTrue(driver.clicked.isEmpty())
+    }
+
+    @Test
+    fun `recorded exact selections allow one unique confirm on an unclassified pdd panel`() {
+        val driver = SpecConfirmationDriver(unclassifiedSpecPanel = true)
+
+        PurchaseLiveAutomation(driver, pause = {}).advanceToOrderConfirmation(
+            allowUnclassifiedPanelWithSelectionProof = true,
+        )
+
+        assertEquals(listOf("确定"), driver.clicked)
+        assertEquals("order", driver.page)
+    }
+
+    @Test
+    fun `unclassified pdd panel without recorded selections remains blocked`() {
+        val driver = SpecConfirmationDriver(unclassifiedSpecPanel = true)
+        val error = runCatching { PurchaseLiveAutomation(driver, pause = {}).advanceToOrderConfirmation() }
+            .exceptionOrNull() as PurchaseLiveException
+
+        assertEquals("PURCHASE_SPEC_CONFIRMATION_NOT_READY", error.code)
+        assertTrue(driver.clicked.isEmpty())
+    }
+
+    @Test
+    fun `recorded selections never authorize a generic unclassified pdd dialog`() {
+        val driver = SpecConfirmationDriver(unclassifiedSpecPanel = true, unclassifiedHasPurchaseEvidence = false)
+        val error = runCatching {
+            PurchaseLiveAutomation(driver, pause = {}).advanceToOrderConfirmation(
+                allowUnclassifiedPanelWithSelectionProof = true,
+            )
+        }.exceptionOrNull() as PurchaseLiveException
+
+        assertEquals("PURCHASE_SPEC_CONFIRMATION_NOT_READY", error.code)
+        assertTrue(driver.clicked.isEmpty())
+    }
+
     @Test
     fun `address is retagged verified and final order button can only be clicked once`() {
         val driver = LiveDriver()
@@ -64,6 +141,31 @@ class PurchaseLiveAutomationTest {
         assertEquals(0, driver.submitClicks)
     }
 
+    @Test
+    fun `saved address returning to spec panel is recovered without pressing back`() {
+        val driver = LiveDriver(saveReturnsToSpecPanel = true)
+        val automation = PurchaseLiveAutomation(driver, pause = {})
+
+        val address = automation.updateShippingAddress("_cg91")
+        val final = automation.finalConfirmation(input().copy(addressSuffix = "_cg91"), address)
+
+        assertEquals("_cg91", final.addressSuffix)
+        assertEquals(0, driver.backCount)
+        assertEquals(1, driver.scopedSwipes)
+        assertEquals(0, driver.submitClicks)
+    }
+
+    @Test
+    fun `saved address stuck on spec panel fails without backing out or submitting`() {
+        val driver = LiveDriver(saveReturnsToSpecPanel = true, savedSpecPanelRecoveryStuck = true)
+        val error = runCatching { PurchaseLiveAutomation(driver, pause = {}).updateShippingAddress("_cg92") }
+            .exceptionOrNull() as PurchaseLiveException
+
+        assertEquals("PURCHASE_ADDRESS_SAVE_TIMEOUT", error.code)
+        assertEquals(0, driver.backCount)
+        assertEquals(0, driver.submitClicks)
+    }
+
     @Test
     fun `edit field containing suffix cannot impersonate post save evidence`() {
         val driver = LiveDriver(saveStaysInEdit = true)
@@ -399,6 +501,52 @@ class PurchaseLiveAutomationTest {
         assertTrue(driver.clicked.isEmpty())
     }
 
+    @Test
+    fun `duplicate masked phone nodes in one clickable address card are activated once`() {
+        val driver = LiveDriver(duplicatePhoneNodesSameCard = true)
+
+        PurchaseLiveAutomation(driver, pause = {}).updateShippingAddress("_cg94")
+
+        assertEquals(1, driver.clicked.count { it == "138****5678" })
+        assertEquals(0, driver.addressTaps)
+    }
+
+    @Test
+    fun `duplicate semantic address cards in separate accessibility trees are activated once`() {
+        val driver = LiveDriver(duplicateSemanticAddressCards = true)
+
+        PurchaseLiveAutomation(driver, pause = {}).updateShippingAddress("_cg94")
+
+        assertEquals(1, driver.addressPathClicks)
+        assertEquals(1, driver.clicked.count { it == "138****5678" })
+        assertEquals(0, driver.addressTaps)
+    }
+
+    @Test
+    fun `two independent address cards remain ambiguous without any click`() {
+        val driver = LiveDriver(duplicateAddressCards = true)
+        val error = runCatching { PurchaseLiveAutomation(driver, pause = {}).updateShippingAddress("_cg95") }
+            .exceptionOrNull() as PurchaseLiveException
+
+        assertEquals("PURCHASE_ADDRESS_ENTRY_AMBIGUOUS", error.code)
+        assertTrue(error.message.orEmpty().contains("phoneNodes=2;addressCards=2;tapTargets=2"))
+        assertFalse(error.message.orEmpty().contains("138"))
+        assertTrue(driver.clicked.isEmpty())
+        assertEquals(0, driver.addressTaps)
+    }
+
+    @Test
+    fun `address entry path drift fails without fallback tap`() {
+        val driver = LiveDriver(duplicatePhoneNodesSameCard = true, addressEntryPathUnavailable = true)
+        val error = runCatching { PurchaseLiveAutomation(driver, pause = {}).updateShippingAddress("_cg94") }
+            .exceptionOrNull() as PurchaseLiveException
+
+        assertEquals("PURCHASE_ADDRESS_ENTRY_NOT_READY", error.code)
+        assertTrue(driver.clicked.isEmpty())
+        assertEquals(1, driver.addressPathClicks)
+        assertEquals(0, driver.addressTaps)
+    }
+
     private fun input() = PurchaseExecutionInput(
         taskId = 11,
         executionMode = "live",
@@ -413,6 +561,78 @@ class PurchaseLiveAutomationTest {
         addressSuffix = "_cg11",
     )
 
+    private class SpecConfirmationDriver(
+        private val confirmLabels: List<String> = listOf("确定"),
+        private val advanceAfterClick: Boolean = true,
+        private val specPanelScrollable: Boolean = false,
+        private val unclassifiedSpecPanel: Boolean = false,
+        private val unclassifiedHasPurchaseEvidence: Boolean = true,
+        startOnOrderPage: Boolean = false,
+    ) : PurchaseUiDriver {
+        var page = if (startOnOrderPage) "order" else "spec"
+        val clicked = mutableListOf<String>()
+
+        override fun capture(): UiSnapshot = if (page == "order") {
+            snapshot(listOf(
+                node("root", "", bounds = NodeBounds(0, 0, 1080, 2200)),
+                node("scroll", "", scrollable = true, bounds = NodeBounds(0, 400, 1080, 2100)),
+                node("summary", "已选 黑色 均码"),
+                node("quantity", "1", className = "android.widget.EditText"),
+                node("phone", "138****5678"),
+                node("submit", "提交订单", clickable = true),
+                node("payment", "微信支付"),
+            ))
+        } else {
+            snapshot(buildList {
+                add(node("root", "", bounds = NodeBounds(0, 0, 1080, 2200)))
+                if (unclassifiedSpecPanel) {
+                    if (unclassifiedHasPurchaseEvidence) {
+                        add(node("price", "¥20.00"))
+                        add(node("quantity", "1", className = "android.widget.EditText"))
+                    }
+                    confirmLabels.forEachIndexed { index, label -> add(node("confirm-$index", label, clickable = true)) }
+                    return@buildList
+                }
+                if (specPanelScrollable) {
+                    add(node("scroll", "", scrollable = true, bounds = NodeBounds(0, 400, 1080, 1500)))
+                }
+                add(node("title", "确认款式"))
+                add(node("summary", "已选 黑色 均码"))
+                val parent = "scroll".takeIf { specPanelScrollable }
+                val prefix = if (specPanelScrollable) "scroll/" else ""
+                add(node("${prefix}color-heading", "颜色分类", parentPath = parent))
+                add(node("${prefix}color", "黑色", clickable = true, parentPath = parent))
+                add(node("${prefix}size-heading", "尺码", parentPath = parent))
+                add(node("${prefix}size", "均码", clickable = true, parentPath = parent))
+                add(node("quantity", "1", className = "android.widget.EditText"))
+                confirmLabels.forEachIndexed { index, label -> add(node("confirm-$index", label, clickable = true)) }
+            })
+        }
+
+        override fun clickFresh(target: SnapshotNode): FreshActionResult {
+            clicked += target.label
+            if (advanceAfterClick && target.label in confirmLabels) page = "order"
+            return FreshActionResult.SUCCESS
+        }
+
+        override fun tapPurchaseFresh(target: SnapshotNode) = FreshActionResult.FAILED
+        override fun inputFresh(target: SnapshotNode, value: String) = FreshActionResult.FAILED
+        override fun swipePurchase(direction: SwipeDirection, durationMs: Long) = false
+        override fun swipePurchaseIn(target: SnapshotNode, direction: SwipeDirection, durationMs: Long) = false
+        override fun backPurchase() = false
+
+        private fun snapshot(nodes: List<SnapshotNode>) = UiSnapshot(PDD, ACTIVITY, nodes)
+        private fun node(
+            path: String,
+            text: String,
+            clickable: Boolean = false,
+            scrollable: Boolean = false,
+            className: String = "android.widget.TextView",
+            bounds: NodeBounds = NodeBounds(20, 100, 900, 180),
+            parentPath: String? = null,
+        ) = SnapshotNode(path, parentPath, text, null, null, className, bounds, clickable, scrollable, false, false, true, true)
+    }
+
     private class LiveDriver(
         private val addressClipped: Boolean = false,
         private val duplicatePanels: Boolean = false,
@@ -424,6 +644,12 @@ class PurchaseLiveAutomationTest {
         private val saveStaysInEdit: Boolean = false,
         private val savedTransitionWithoutLegacyContext: Boolean = false,
         private val savedTransitionHidesSuffix: Boolean = false,
+        private val saveReturnsToSpecPanel: Boolean = false,
+        private val savedSpecPanelRecoveryStuck: Boolean = false,
+        private val duplicatePhoneNodesSameCard: Boolean = false,
+        private val duplicateSemanticAddressCards: Boolean = false,
+        private val duplicateAddressCards: Boolean = false,
+        private val addressEntryPathUnavailable: Boolean = false,
         private val wechatLoginAfterSubmit: Boolean = false,
         private val wechatRestoreStuck: Boolean = false,
         private val orderEvidenceBelowFold: Boolean = false,
@@ -442,6 +668,7 @@ class PurchaseLiveAutomationTest {
         var scopedSwipes = 0
         var genericSwipes = 0
         var addressTaps = 0
+        var addressPathClicks = 0
         var lastInputTargetPath: String? = null
         var backCount = 0
         var postSubmitBackCount = 0
@@ -479,6 +706,21 @@ class PurchaseLiveAutomationTest {
                 node("transition-title", "选择收货信息"),
                 node("address-summary", if (savedTransitionHidesSuffix) "已保存的收货信息" else address.substring(address.lastIndexOf("_cg"))),
             ))
+            "post-save-spec" -> snapshot(listOf(
+                node("root", "", bounds = NodeBounds(0, 0, 1080, 2200)),
+                node("panel", "", scrollable = true, bounds = NodeBounds(0, 400, 1080, 2100)),
+                node("panel-title", "确认款式", bounds = NodeBounds(20, 396, 300, 430)),
+                node("panel/price", "¥20.00", parentPath = "panel", bounds = NodeBounds(20, 460, 300, 520)),
+                node("panel/selected", "已选 黑色 XL", parentPath = "panel", bounds = NodeBounds(20, 540, 700, 600)),
+                node("panel/color-heading", "颜色分类", parentPath = "panel", bounds = NodeBounds(20, 650, 300, 700)),
+                node("panel/color", "黑色", clickable = true, parentPath = "panel", bounds = NodeBounds(20, 720, 220, 790)),
+                node("panel/size-heading", "尺码", parentPath = "panel", bounds = NodeBounds(20, 850, 300, 900)),
+                node("panel/size", "XL", clickable = true, parentPath = "panel", bounds = NodeBounds(20, 920, 220, 990)),
+                node("panel/quantity", "2", className = "android.widget.EditText", parentPath = "panel", bounds = NodeBounds(400, 1050, 600, 1120)),
+                node("panel/confirm", "确定", clickable = true, parentPath = "panel", bounds = NodeBounds(20, 1200, 500, 1280)),
+                node("submit-parent", "", clickable = true, bounds = NodeBounds(20, 1900, 1000, 2100)),
+                node("submit", "提交订单", parentPath = "submit-parent", bounds = NodeBounds(520, 1940, 980, 2040)),
+            ))
             "order" -> snapshot(listOf(node("status", "待付款"), node("order", "订单号：PDD-202608210001"), node("time", "下单时间：2026-08-21 10:30:00"), node("pay", "立即支付", clickable = true)))
             "order-folded" -> snapshot(listOf(node("status", "待付款"), node("pay", "立即支付", clickable = true)))
             "order-folded-payment-activity" -> UiSnapshot(PDD, "com.xunmeng.pinduoduo.app_pay.core.PayActivity", listOf(
@@ -512,7 +754,30 @@ class PurchaseLiveAutomationTest {
                 )
                 if (duplicatePanels) nodes += node("panel2", "", scrollable = true, bounds = NodeBounds(0, 500, 1080, 2000))
                 if (addressVisible) {
-                    nodes += node("phone", "138****5678")
+                    when {
+                        duplicateSemanticAddressCards -> {
+                            nodes += node("address-layer-a", "", clickable = true, bounds = NodeBounds(0, 620, 1080, 840))
+                            nodes += node("address-layer-a/phone", "138****5678", parentPath = "address-layer-a", bounds = NodeBounds(20, 650, 400, 710))
+                            nodes += node("address-layer-a/detail", "广东省广州市天园街道骏景花园", parentPath = "address-layer-a", bounds = NodeBounds(20, 720, 900, 790))
+                            nodes += node("address-layer-b", "", clickable = true, bounds = NodeBounds(0, 900, 1080, 1120))
+                            nodes += node("address-layer-b/phone", "138****5678", parentPath = "address-layer-b", bounds = NodeBounds(20, 930, 400, 990))
+                            nodes += node("address-layer-b/detail", "广东省广州市天园街道骏景花园", parentPath = "address-layer-b", bounds = NodeBounds(20, 1000, 900, 1070))
+                        }
+                        duplicateAddressCards -> {
+                            nodes += node("address-card-a", "", clickable = true, bounds = NodeBounds(0, 620, 1080, 820))
+                            nodes += node("address-card-a/phone", "138****5678", parentPath = "address-card-a", bounds = NodeBounds(20, 650, 400, 710))
+                            nodes += node("address-card-a/detail", "广东省广州市天园街道一号", parentPath = "address-card-a", bounds = NodeBounds(20, 720, 900, 780))
+                            nodes += node("address-card-b", "", clickable = true, bounds = NodeBounds(0, 840, 1080, 1040))
+                            nodes += node("address-card-b/phone", "138****5678", parentPath = "address-card-b", bounds = NodeBounds(20, 870, 400, 930))
+                            nodes += node("address-card-b/detail", "广东省广州市天园街道二号", parentPath = "address-card-b", bounds = NodeBounds(20, 940, 900, 1000))
+                        }
+                        duplicatePhoneNodesSameCard -> {
+                            nodes += node("address-card", "", clickable = true, bounds = NodeBounds(0, 620, 1080, 900))
+                            nodes += node("address-card/phone-a", "138****5678", parentPath = "address-card", bounds = NodeBounds(20, 650, 400, 710))
+                            nodes += node("address-card/phone-b", "138****5678", parentPath = "address-card", bounds = NodeBounds(20, 720, 440, 790))
+                        }
+                        else -> nodes += node("phone", "138****5678")
+                    }
                     val suffixStart = address.lastIndexOf("_cg")
                     val addressBody = if (suffixStart >= 0) address.substring(0, suffixStart) else address
                     val addressSuffix = if (suffixStart >= 0) address.substring(suffixStart) else ""
@@ -537,7 +802,13 @@ class PurchaseLiveAutomationTest {
             when (target.label) {
                 "138****5678" -> page = "panel"
                 "修改" -> page = "edit"
-                "保存" -> if (!saveStaysInEdit) page = if (savedTransitionWithoutLegacyContext) "saved-transition" else "panel"
+                "保存" -> if (!saveStaysInEdit) {
+                    page = when {
+                        saveReturnsToSpecPanel -> "post-save-spec"
+                        savedTransitionWithoutLegacyContext -> "saved-transition"
+                        else -> "panel"
+                    }
+                }
                 "提交订单" -> {
                     submitClicks++
                     page = when {
@@ -555,6 +826,14 @@ class PurchaseLiveAutomationTest {
             return FreshActionResult.SUCCESS
         }
 
+        override fun clickAddressEntryFresh(target: SnapshotNode): FreshClickOutcome {
+            addressPathClicks++
+            if (addressEntryPathUnavailable) {
+                return FreshClickOutcome(FreshActionResult.NOT_FOUND, FreshClickReason.TARGET_NOT_FOUND)
+            }
+            return FreshClickOutcome(clickFresh(target), FreshClickReason.SUCCESS, 1, 1)
+        }
+
         override fun tapPurchaseFresh(target: SnapshotNode): FreshActionResult {
             addressTaps++
             clicked += target.label
@@ -575,6 +854,7 @@ class PurchaseLiveAutomationTest {
         override fun swipePurchaseIn(target: SnapshotNode, direction: SwipeDirection, durationMs: Long): Boolean {
             scopedSwipes++
             if (target.path == "panel" && direction == SwipeDirection.DOWN) addressVisible = true
+            if (page == "post-save-spec" && direction == SwipeDirection.DOWN && !savedSpecPanelRecoveryStuck) page = "confirmation"
             return true
         }
         override fun backPurchase(): Boolean {

android/app/src/test/java/cn/ilapage/goauto/agent/PurchaseRehearsalExecutorTest.kt

@@ -22,6 +22,36 @@ import org.junit.Assert.assertTrue
 import org.junit.Test
 
 class PurchaseRehearsalExecutorTest {
+    @Test
+    fun `color selection then single size heading completes without selecting color again`() {
+        val driver = FakePurchaseDriver(prefixlessSingleHeadingAfterColor = true)
+        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { null }, pause = {})
+            .execute(input(), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+        assertEquals(outcome.message, "rehearsal_completed", outcome.resultType)
+        assertEquals(1, driver.clicked.count { it == "黑色" })
+        assertEquals(1, driver.clicked.count { it == "XL" })
+    }
+    @Test
+    fun `full exact summary confirms size after option leaves viewport`() {
+        val target = "2XL 建议131到150斤"
+        val driver = FakePurchaseDriver(sizes = listOf(target), hideSizeAfterSelection = true)
+        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { null }, pause = {})
+            .execute(input().copy(mappedSize = target), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+        assertEquals(outcome.message, "rehearsal_completed", outcome.resultType)
+        assertEquals(1, driver.clicked.count { it == target })
+    }
+
+    @Test
+    fun `same size token with different full range cannot establish selection`() {
+        val target = "2XL 建议131到150斤"
+        val driver = FakePurchaseDriver(
+            sizes = listOf(target), hideSizeAfterSelection = true,
+            selectedSizeSummaryOverride = "2XL 建议151到170斤",
+        )
+        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { null }, pause = {})
+            .execute(input().copy(mappedSize = target), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+        assertEquals("failed", outcome.resultType)
+    }
     @Test
     fun `spec gesture policy excludes irreversible and out of bounds targets`() {
         fun target(label: String, bounds: NodeBounds = NodeBounds(20, 100, 300, 180)) = SnapshotNode(
@@ -81,12 +111,63 @@ class PurchaseRehearsalExecutorTest {
 
         assertEquals("rehearsal_completed", outcome.resultType)
         assertEquals(2_000L, outcome.actualUnitPriceCent)
-        assertEquals(1, openCount)
+        assertEquals(0, openCount)
         assertEquals(2, driver.swipeCount)
         assertEquals(2L, driver.quantity)
-        assertTrue(driver.clicked.containsAll(listOf("打开", "选择规格", "黑色", "XL")))
+        assertTrue(driver.clicked.containsAll(listOf("选择规格", "黑色", "XL")))
         assertFalse(driver.clicked.any { it.contains("订单") || it.contains("支付") })
-        assertTrue(pauses.contains(700))
+        assertFalse(pauses.contains(700))
+    }
+
+    @Test
+    fun `manual purchase retry from agent reopens the task product url`() {
+        val driver = FakePurchaseDriver(initiallyInAgent = true)
+        var openCount = 0
+        val outcome = PurchaseRehearsalExecutor(
+            driver,
+            openLink = {
+                openCount++
+                driver.leaveAgentAndOpenBrowser()
+                true
+            },
+            probeSpecs = { null },
+            pause = {},
+        ).execute(input(), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+
+        assertEquals("rehearsal_completed", outcome.resultType)
+        assertEquals(1, openCount)
+        assertEquals(1, driver.openClickCount)
+    }
+
+    @Test
+    fun `purchase phase reopens when pdd foreground has no product evidence`() {
+        val driver = FakePurchaseDriver(loadingPddCaptures = 1)
+        var openCount = 0
+        val outcome = PurchaseRehearsalExecutor(
+            driver,
+            openLink = { openCount++; driver.browser = true; true },
+            probeSpecs = { null },
+            pause = {},
+        ).execute(input(), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+
+        assertEquals("rehearsal_completed", outcome.resultType)
+        assertEquals(1, openCount)
+        assertEquals(1, driver.openClickCount)
+    }
+
+    @Test
+    fun `purchase phase does not reuse a pdd login page`() {
+        val driver = FakePurchaseDriver(pddProblemLabels = listOf("手机号登录", "登录后继续"))
+        var openCount = 0
+        val outcome = PurchaseRehearsalExecutor(
+            driver,
+            openLink = { openCount++; driver.browser = true; true },
+            probeSpecs = { null },
+            pause = {},
+        ).execute(input(), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+
+        assertEquals("PDD_LOGIN_REQUIRED", outcome.errorCode)
+        assertEquals(1, openCount)
     }
 
     @Test
@@ -151,6 +232,159 @@ class PurchaseRehearsalExecutorTest {
         assertTrue(driver.swipeInPaths.all { it == "scroll" })
     }
 
+    @Test
+    fun `exact color on later horizontal page is found by bounded fallback`() {
+        val driver = FakePurchaseDriver(
+            horizontalColorPages = listOf(listOf("黑色", "白色"), listOf("蓝色", "富贵粉")),
+        )
+        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { null }, pause = {})
+            .execute(input().copy(mappedColor = "富贵粉"), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+
+        assertEquals("rehearsal_completed", outcome.resultType)
+        assertEquals("富贵粉", driver.color)
+        assertTrue(driver.horizontalSpecDirections.contains(SwipeDirection.LEFT))
+        assertEquals(1, driver.clicked.count { it == "富贵粉" })
+    }
+
+    @Test
+    fun `visible exact color keeps established path without horizontal fallback`() {
+        val driver = FakePurchaseDriver(colors = listOf("黑色", "白色"))
+        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { null }, pause = {})
+            .execute(input(), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+
+        assertEquals("rehearsal_completed", outcome.resultType)
+        assertTrue(driver.horizontalSpecDirections.isEmpty())
+    }
+
+    @Test
+    fun `single column colors never trigger horizontal fallback`() {
+        val driver = FakePurchaseDriver(
+            horizontalColorPages = listOf(listOf("黑色"), listOf("富贵粉")),
+        )
+        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { null }, pause = {})
+            .execute(input().copy(mappedColor = "富贵粉"), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+
+        assertEquals("PURCHASE_SPEC_TARGET_NOT_VISIBLE", outcome.errorCode)
+        assertTrue(outcome.message.contains("horizontalSwipes=0"))
+        assertTrue(driver.horizontalSpecDirections.isEmpty())
+        assertFalse(driver.clicked.contains("黑色"))
+    }
+
+    @Test
+    fun `failed horizontal color swipe remains safely failed`() {
+        val driver = FakePurchaseDriver(
+            horizontalColorPages = listOf(listOf("黑色", "白色"), listOf("蓝色", "富贵粉")),
+            horizontalSpecSwipeSucceeds = false,
+        )
+        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { null }, pause = {})
+            .execute(input().copy(mappedColor = "富贵粉"), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+
+        assertEquals("PURCHASE_SPEC_TARGET_NOT_VISIBLE", outcome.errorCode)
+        assertTrue(outcome.message.contains("horizontalFailure=gestureFailed"))
+        assertTrue(driver.clicked.none { it == "富贵粉" })
+    }
+
+    @Test
+    fun `long exact size on later horizontal page is found after color selection`() {
+        val targetSize = "3XL 推荐140-155斤"
+        val driver = FakePurchaseDriver(
+            horizontalSizePages = listOf(
+                listOf("S 推荐80-95斤", "M 推荐95-110斤"),
+                listOf("2XL 推荐125-140斤", targetSize),
+            ),
+        )
+        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { null }, pause = {})
+            .execute(input().copy(mappedSize = targetSize), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+
+        assertEquals("rehearsal_completed", outcome.resultType)
+        assertEquals(targetSize, driver.size)
+        assertTrue(driver.horizontalSpecDimensions.contains("size"))
+        assertEquals(1, driver.clicked.count { it == targetSize })
+    }
+
+    @Test
+    fun `single visible long size uses its dedicated horizontal container`() {
+        val targetSize = "3XL 推荐140-155斤"
+        val driver = FakePurchaseDriver(
+            horizontalSizePages = listOf(listOf("S 推荐80-95斤"), listOf(targetSize)),
+        )
+        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { null }, pause = {})
+            .execute(input().copy(mappedSize = targetSize), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+
+        assertEquals("rehearsal_completed", outcome.resultType)
+        assertEquals(targetSize, driver.size)
+        assertTrue(driver.horizontalSpecDimensions.contains("size"))
+    }
+
+    @Test
+    fun `color and size horizontal fallbacks reacquire their own row anchors`() {
+        val targetSize = "3XL 推荐140-155斤"
+        val driver = FakePurchaseDriver(
+            horizontalColorPages = listOf(listOf("黑色", "白色"), listOf("蓝色", "富贵粉")),
+            horizontalSizePages = listOf(listOf("S 推荐80-95斤", "M 推荐95-110斤"), listOf("2XL 推荐125-140斤", targetSize)),
+        )
+        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { null }, pause = {})
+            .execute(
+                input().copy(mappedColor = "富贵粉", mappedSize = targetSize),
+                PurchaseRuleParser.parse(rule()),
+                PurchaseAgentCapabilities.supported,
+            )
+
+        assertEquals("rehearsal_completed", outcome.resultType)
+        assertTrue(driver.horizontalSpecDimensions.containsAll(listOf("color", "size")))
+        assertTrue(driver.horizontalSpecAnchorPaths.filterIndexed { index, _ -> driver.horizontalSpecDimensions[index] == "size" }
+            .all { it.contains("size-row") })
+    }
+
+    @Test
+    fun `two column size grid continues vertically without horizontal container`() {
+        val target = "3XL 推荐140-155斤"
+        val driver = FakePurchaseDriver(sizes = listOf(target), revealGridSizeAfterUpSwipes = 7)
+        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { null }, pause = {})
+            .execute(input().copy(mappedSize = target), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+        assertEquals("rehearsal_completed", outcome.resultType)
+        assertEquals(target, driver.size)
+        assertTrue(driver.horizontalSpecDirections.isEmpty())
+        assertEquals(1, driver.clicked.count { it == target })
+    }
+
+    @Test
+    fun `failed horizontal gesture still permits vertical exact size recovery`() {
+        val target = "3XL 推荐140-155斤"
+        val driver = FakePurchaseDriver(
+            sizes = listOf(target),
+            horizontalSizePages = listOf(listOf("S", "M")),
+            horizontalSpecSwipeSucceeds = false,
+            revealGridSizeAfterUpSwipes = 7,
+        )
+        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { null }, pause = {})
+            .execute(input().copy(mappedSize = target), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+        assertEquals(outcome.message, "rehearsal_completed", outcome.resultType)
+        assertEquals(target, driver.size)
+        assertTrue(driver.horizontalSpecDirections.isNotEmpty())
+    }
+
+    @Test
+    fun `missing size terminates at stable viewport with bounded gestures`() {
+        val driver = FakePurchaseDriver(sizes = listOf("S", "M"))
+        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { null }, pause = {})
+            .execute(input(), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+        assertEquals("PURCHASE_SPEC_TARGET_NOT_VISIBLE", outcome.errorCode)
+        assertTrue(outcome.message.contains("reason=stableViewport"))
+        assertTrue(driver.horizontalSpecDirections.isEmpty())
+        assertTrue(driver.swipeCount < 35)
+    }
+
+    @Test
+    fun `visible exact size does not enter horizontal fallback`() {
+        val driver = FakePurchaseDriver(sizes = listOf("L", "XL"))
+        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { null }, pause = {})
+            .execute(input(), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+
+        assertEquals("rehearsal_completed", outcome.resultType)
+        assertFalse(driver.horizontalSpecDimensions.contains("size"))
+    }
+
     @Test
     fun `failed size click result continues when exact size is actually selected`() {
         val driver = FakePurchaseDriver(
@@ -233,7 +467,7 @@ class PurchaseRehearsalExecutorTest {
     }
 
     @Test
-    fun `final verification rejects prior proof when selected summary is no longer visible`() {
+    fun `final verification keeps exact attempt selection when summary is no longer visible`() {
         val driver = FakePurchaseDriver(
             hideColorAfterQuantitySet = true,
             hideSelectedSummaryAfterQuantitySet = true,
@@ -241,11 +475,53 @@ class PurchaseRehearsalExecutorTest {
         val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { null }, pause = {})
             .execute(input(), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
 
+        assertEquals("rehearsal_completed", outcome.resultType)
+        assertEquals(1, driver.clicked.count { it == "黑色" })
+    }
+
+    @Test
+    fun `final verification keeps current attempt proof when selected panel becomes unclassified`() {
+        val driver = FakePurchaseDriver(panelBecomesUnknownAfterSizeProof = true)
+        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { null }, pause = {})
+            .execute(input().copy(quantity = 1), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+
+        assertEquals("rehearsal_completed", outcome.resultType)
+        assertEquals(1, driver.clicked.count { it == "黑色" })
+        assertEquals(1, driver.clicked.count { it == "XL" })
+    }
+
+    @Test
+    fun `final verification reuses exact attempt state without scrolling back`() {
+        val driver = FakePurchaseDriver(
+            hideColorAfterQuantitySet = true,
+            hideSelectedSummaryAfterQuantitySet = true,
+            restoreHiddenColorOnDownSwipe = true,
+        )
+        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { null }, pause = {})
+            .execute(input(), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+
+        assertEquals("rehearsal_completed", outcome.resultType)
+        assertFalse(driver.swipeInPaths.contains("scroll"))
+        assertEquals(1, driver.clicked.count { it == "黑色" })
+        assertEquals(1, driver.clicked.count { it == "XL" })
+    }
+
+    @Test
+    fun `final verification rejects explicit conflicting selected color`() {
+        val driver = FakePurchaseDriver(
+            colors = listOf("黑色", "白色"),
+            hideSelectedSummaryAfterQuantitySet = true,
+            selectedColorOverrideAfterQuantitySet = "白色",
+        )
+        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { null }, pause = {})
+            .execute(input(), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+
         assertEquals("failed", outcome.resultType)
         assertEquals("PURCHASE_SPEC_SELECTION_UNCONFIRMED", outcome.errorCode)
         assertTrue(outcome.message.contains("dimension=color"))
-        assertTrue(outcome.message.contains("reason=summary_token_missing"))
-        assertTrue(outcome.message.contains("proof=true"))
+        assertTrue(outcome.message.contains("reason=visible_selected_conflict"))
+        assertTrue(outcome.message.contains("targetMatches=1"))
+        assertEquals(1, driver.clicked.count { it == "黑色" })
     }
 
     @Test
@@ -279,7 +555,8 @@ class PurchaseRehearsalExecutorTest {
         assertEquals("PURCHASE_SPEC_SELECTION_UNCONFIRMED", outcome.errorCode)
         assertTrue(outcome.message.contains("dimension=size"))
         assertTrue(outcome.message.contains("reason=visible_candidate_conflict"))
-        assertTrue(outcome.message.contains("proof=true"))
+        assertTrue(outcome.message.contains("proofRecorded=true"))
+        assertTrue(outcome.message.contains("proofUsable=true"))
     }
 
     @Test
@@ -404,8 +681,8 @@ class PurchaseRehearsalExecutorTest {
     @Test
     fun `ambiguous browser target stops safely`() {
         val driver = FakePurchaseDriver(duplicateOpen = true)
-        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { null }, pause = {})
-            .execute(input(), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { "{}" }, pause = {})
+            .execute(input().copy(phase = "spec_probe"), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
         assertEquals("RULE_AMBIGUOUS", outcome.errorCode)
         assertTrue(driver.clicked.isEmpty())
     }
@@ -416,10 +693,10 @@ class PurchaseRehearsalExecutorTest {
             openClickResults = mutableListOf(FreshActionResult.FAILED),
             openPddOnFailedClick = true,
         )
-        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { null }, pause = {})
-            .execute(input(), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { "{}" }, pause = {})
+            .execute(input().copy(phase = "spec_probe"), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
 
-        assertEquals("rehearsal_completed", outcome.resultType)
+        assertEquals("spec_probe_completed", outcome.resultType)
         assertEquals(1, driver.openClickCount)
     }
 
@@ -429,10 +706,10 @@ class PurchaseRehearsalExecutorTest {
             openClickResults = mutableListOf(FreshActionResult.NOT_FOUND, FreshActionResult.SUCCESS),
         )
         val pauses = mutableListOf<Long>()
-        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { null }, pause = pauses::add)
-            .execute(input(), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { "{}" }, pause = pauses::add)
+            .execute(input().copy(phase = "spec_probe"), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
 
-        assertEquals("rehearsal_completed", outcome.resultType)
+        assertEquals("spec_probe_completed", outcome.resultType)
         assertEquals(2, driver.openClickCount)
         assertTrue(pauses.size <= 50)
     }
@@ -440,15 +717,50 @@ class PurchaseRehearsalExecutorTest {
     @Test
     fun `persistent open click failure is bounded and remains safely failed`() {
         val driver = FakePurchaseDriver(
-            openClickResults = MutableList(10) { FreshActionResult.FAILED },
+            openClickResults = MutableList(20) { FreshActionResult.FAILED },
         )
         val pauses = mutableListOf<Long>()
-        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { null }, pause = pauses::add)
-            .execute(input(), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { "{}" }, pause = pauses::add)
+            .execute(input().copy(phase = "spec_probe"), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
 
         assertEquals("RULE_ACTION_FAILED", outcome.errorCode)
-        assertTrue(driver.openClickCount in 1..5)
-        assertEquals(50, pauses.size)
+        assertTrue(driver.openClickCount in 1..15)
+        assertEquals(150, pauses.size)
+    }
+
+    @Test
+    fun `five second browser interstitial can still reach a stable product page`() {
+        val pauses = mutableListOf<Long>()
+        val driver = FakePurchaseDriver(browserOpenVisibleAfterCaptures = 50)
+        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { "{}" }, pause = pauses::add)
+            .execute(input().copy(phase = "spec_probe"), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+
+        assertEquals("spec_probe_completed", outcome.resultType)
+        assertEquals(1, driver.openClickCount)
+        assertTrue(pauses.count { it == 100L } in 52..60)
+    }
+
+    @Test
+    fun `pdd foreground without stable product evidence times out at fifteen seconds`() {
+        val pauses = mutableListOf<Long>()
+        val driver = FakePurchaseDriver(loadingPddCaptures = 200)
+        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { "{}" }, pause = pauses::add)
+            .execute(input().copy(phase = "spec_probe"), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+
+        assertEquals("PDD_DETAIL_ENTRY_FAILED", outcome.errorCode)
+        assertEquals("打开拼多多后未识别到稳定商品页面", outcome.message)
+        assertEquals(150, pauses.count { it == 100L })
+    }
+
+    @Test
+    fun `explicit pdd login page fails before the product timeout`() {
+        val pauses = mutableListOf<Long>()
+        val driver = FakePurchaseDriver(pddProblemLabels = listOf("手机号登录", "登录后继续"))
+        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { "{}" }, pause = pauses::add)
+            .execute(input().copy(phase = "spec_probe"), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+
+        assertEquals("PDD_LOGIN_REQUIRED", outcome.errorCode)
+        assertTrue(pauses.count { it == 100L } < 5)
     }
 
     @Test
@@ -476,6 +788,21 @@ class PurchaseRehearsalExecutorTest {
         assertFalse(outcome.message.orEmpty().contains("确认款式"))
     }
 
+    @Test
+    fun `changed product page retries a still visible spec entry once`() {
+        val driver = FakePurchaseDriver(
+            entryActionHasEffect = false,
+            entryActionChangesPageWithoutPanel = true,
+            specTapResult = FreshActionResult.SUCCESS,
+        )
+        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { null }, pause = {})
+            .execute(input(), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+
+        assertEquals(outcome.toString(), "rehearsal_completed", outcome.resultType)
+        assertEquals(1, driver.openEntryClickCount)
+        assertEquals(1, driver.specTapCount)
+    }
+
     @Test
     fun `unchanged spec entry action uses one verified center gesture`() {
         val driver = FakePurchaseDriver(
@@ -505,6 +832,20 @@ class PurchaseRehearsalExecutorTest {
         assertFalse(driver.panel)
     }
 
+    @Test
+    fun `failed spec entry gesture preserves the action click no effect reason`() {
+        val driver = FakePurchaseDriver(
+            entryActionHasEffect = false,
+            specTapResult = FreshActionResult.FAILED,
+        )
+        val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { null }, pause = {})
+            .execute(input(), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
+
+        assertEquals("PURCHASE_SPEC_ENTRY_CLICK_FAILED", outcome.errorCode)
+        assertEquals("gesture_failed_after_action_click_no_effect", outcome.message)
+        assertFalse(outcome.message.contains("unknown"))
+    }
+
     @Test
     fun `missing spec entry emits scalar source counts without node text`() {
         val diagnostics = mutableListOf<String>()
@@ -520,11 +861,9 @@ class PurchaseRehearsalExecutorTest {
 
         assertEquals("PURCHASE_SPEC_ENTRY_NOT_FOUND", outcome.errorCode)
         assertEquals(
-            "specEntryCandidates=0;explicit=0;nested=0;bottomPurchase=0;panelAlreadyOpen=false;reviewPage=false;pageEvidence=true;entryReadyWaitPolls=20;entryReadyWaitMillis=2000",
+            "specEntryCandidates=0;explicit=0;nested=0;bottomPurchase=0;source=none;panelAlreadyOpen=false;reviewPage=false;pageEvidence=true;entryReadyWaitPolls=20;entryReadyWaitMillis=2000",
             diagnostics.single(),
         )
-        // One 100ms pause belongs to the existing open-product foreground poll;
-        // the diagnostic proves the entry-ready loop itself used exactly 20.
         assertEquals(21, pauses.count { it == 100L })
         assertFalse(diagnostics.single().contains("选择规格"))
     }
@@ -540,18 +879,20 @@ class PurchaseRehearsalExecutorTest {
         assertTrue(driver.clickedPaths.contains("buy"))
         // One 100ms pause belongs to the existing open-product foreground poll;
         // two belong to the entry-ready wait before the bottom bar appears.
-        assertEquals(3, pauses.count { it == 100L })
+        assertEquals(4, pauses.count { it == 100L })
     }
 
     @Test
-    fun `verify product waits for product evidence instead of a visible loading frame`() {
+    fun `purchase reopens and waits for product evidence instead of a visible loading frame`() {
         val pauses = mutableListOf<Long>()
         val driver = FakePurchaseDriver(loadingPddCaptures = 1)
         val outcome = PurchaseRehearsalExecutor(driver, { driver.browser = true; true }, { null }, pause = pauses::add)
             .execute(input(), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
 
         assertEquals("rehearsal_completed", outcome.resultType)
-        assertEquals(1, pauses.count { it == 100L })
+        // Two stable reads belong to reopening the product; verifyProduct then
+        // independently requires its second stable read before continuing.
+        assertEquals(4, pauses.count { it == 100L })
     }
 
     @Test
@@ -716,7 +1057,7 @@ class PurchaseRehearsalExecutorTest {
 
         assertEquals("PURCHASE_SPEC_ENTRY_NOT_FOUND", outcome.errorCode)
         assertEquals(
-            "没有找到安全的商品规格入口 [specEntryCandidates=0;explicit=0;nested=0;bottomPurchase=0;panelAlreadyOpen=false;reviewPage=false;pageEvidence=true;entryReadyWaitPolls=20;entryReadyWaitMillis=2000]",
+            "没有找到安全的商品规格入口 [specEntryCandidates=0;explicit=0;nested=0;bottomPurchase=0;source=none;panelAlreadyOpen=false;reviewPage=false;pageEvidence=true;entryReadyWaitPolls=20;entryReadyWaitMillis=2000]",
             outcome.message,
         )
 
@@ -726,7 +1067,7 @@ class PurchaseRehearsalExecutorTest {
 
         assertEquals("PURCHASE_SPEC_ENTRY_TARGET_AMBIGUOUS", ambiguous.errorCode)
         assertEquals(
-            "规格入口点击目标不唯一 [specEntryCandidates=1;explicit=1;nested=0;bottomPurchase=0;panelAlreadyOpen=false;reviewPage=false;pageEvidence=true;entryReadyWaitPolls=0;entryReadyWaitMillis=0]",
+            "规格入口点击目标不唯一 [specEntryCandidates=1;explicit=1;nested=0;bottomPurchase=0;source=explicit_selection;panelAlreadyOpen=false;reviewPage=false;pageEvidence=true;entryReadyWaitPolls=1;entryReadyWaitMillis=100]",
             ambiguous.message,
         )
     }
@@ -875,6 +1216,9 @@ class PurchaseRehearsalExecutorTest {
 
     private class FakePurchaseDriver(
         private val colors: List<String> = listOf("黑色"),
+        private val horizontalColorPages: List<List<String>>? = null,
+        private val horizontalSizePages: List<List<String>>? = null,
+        private val horizontalSpecSwipeSucceeds: Boolean = true,
         private val sizes: List<String> = listOf("XL"),
         private val priceCent: Long = 2_000,
         private val duplicateOpen: Boolean = false,
@@ -882,10 +1226,15 @@ class PurchaseRehearsalExecutorTest {
         private val missingSpecEntry: Boolean = false,
         private val specEntryVisibleAfterPddCaptures: Int = 0,
         private val loadingPddCaptures: Int = 0,
+        private val browserOpenVisibleAfterCaptures: Int = 0,
+        private val pddProblemLabels: List<String> = emptyList(),
         private val includeReviewEntry: Boolean = false,
         private val openReviewOnBottomClick: Boolean = false,
         private val reviewBackSucceeds: Boolean = true,
         private val hiddenSizeUntilUpSwipes: Int = 0,
+        private val prefixlessSingleHeadingAfterColor: Boolean = false,
+        private val hideSizeAfterSelection: Boolean = false,
+        private val revealGridSizeAfterUpSwipes: Int? = null,
         private val openClickResults: MutableList<FreshActionResult> = mutableListOf(),
         private val openPddOnFailedClick: Boolean = false,
         private val sizeClickResults: MutableList<FreshActionResult> = mutableListOf(),
@@ -893,6 +1242,7 @@ class PurchaseRehearsalExecutorTest {
         private val forcedEntryClickReason: FreshClickReason? = null,
         private val initialSize: String? = null,
         private val entryActionHasEffect: Boolean = true,
+        private val entryActionChangesPageWithoutPanel: Boolean = false,
         private val specTapResult: FreshActionResult = FreshActionResult.FAILED,
         private val specTapHasEffect: Boolean = true,
         private val sizeSelectsOnFailedClick: Boolean = false,
@@ -901,6 +1251,8 @@ class PurchaseRehearsalExecutorTest {
         private val hideColorAfterQuantitySet: Boolean = false,
         private val hideSizeAfterQuantitySet: Boolean = false,
         private val hideSelectedSummaryAfterQuantitySet: Boolean = false,
+        private val restoreHiddenColorOnDownSwipe: Boolean = false,
+        private val selectedColorOverrideAfterQuantitySet: String? = null,
         private val selectedSummaryOverrideAfterQuantitySet: String? = null,
         private val finalSizesAfterQuantitySet: List<String>? = null,
         soldOut: Boolean = false,
@@ -912,8 +1264,11 @@ class PurchaseRehearsalExecutorTest {
         private val nonScrollablePanel: Boolean = false,
         private val unrecognizedPanel: Boolean = false,
         private val purchaseSwipeSucceeds: Boolean = true,
+        initiallyInAgent: Boolean = false,
+        private val panelBecomesUnknownAfterSizeProof: Boolean = false,
     ) : PurchaseUiDriver {
         var browser = false
+        private var inAgent = initiallyInAgent
         var panel = false
         var color: String? = null
         var size: String? = initialSize
@@ -925,26 +1280,58 @@ class PurchaseRehearsalExecutorTest {
         var pullDownCount = 0
         var backCount = 0
         var specTapCount = 0
+        val horizontalSpecDirections = mutableListOf<SwipeDirection>()
+        val horizontalSpecDimensions = mutableListOf<String>()
+        val horizontalSpecAnchorPaths = mutableListOf<String>()
         val swipeInPaths = mutableListOf<String>()
         private var soldOut = soldOut
         private var allSpecsUnavailable = allSpecsUnavailable
         private var productEvidenceLost = false
         private var reviewPage = false
         private var pddCaptureCount = 0
+        private var browserCaptureCount = 0
+        private var entryActionChanged = false
+        private var hiddenColorRestored = false
+        private var horizontalColorPage = 0
+        private var horizontalSizePage = 0
+        private var capturesAfterSizeSelection = 0
         val clicked = mutableListOf<String>()
         val clickedPaths = mutableListOf<String>()
 
         override fun capture(): UiSnapshot {
+            if (inAgent) {
+                return UiSnapshot("cn.ilapage.goauto.agent", "MainActivity", listOf(node("content", "", 0, 0, 1080, 2200)))
+            }
             if (browser && !panel && color == null && size == null) {
+                browserCaptureCount++
+                if (browserCaptureCount <= browserOpenVisibleAfterCaptures) {
+                    return UiSnapshot("com.heytap.browser", "BrowserActivity", listOf(node("content", "", 0, 0, 1080, 2200)))
+                }
                 val openNodes = mutableListOf(node("open", "打开", 0, 100, 300, 180, clickable = true))
                 if (duplicateOpen) openNodes += node("open2", "打开", 400, 100, 700, 180, clickable = true)
                 openNodes += node("content", "", 0, 0, 1080, 2200)
                 return UiSnapshot("com.heytap.browser", "BrowserActivity", openNodes)
             }
+            if (panelBecomesUnknownAfterSizeProof && panel && size != null) {
+                capturesAfterSizeSelection++
+                if (capturesAfterSizeSelection > 1) {
+                    return UiSnapshot(PDD, ACTIVITY, listOf(
+                        node("content", "", 0, 0, 1080, 2200),
+                        node("price", "¥20.00", 20, 300, 300, 360),
+                        node("quantity", "1", 400, 800, 600, 870, className = "android.widget.EditText"),
+                        node("confirm", "确定", 20, 900, 500, 980, clickable = true),
+                    ))
+                }
+            }
             pddCaptureCount++
             if (pddCaptureCount <= loadingPddCaptures) {
                 return UiSnapshot(PDD, ACTIVITY, listOf(node("content", "", 0, 0, 1080, 2200)))
             }
+            if (pddProblemLabels.isNotEmpty()) {
+                return UiSnapshot(PDD, ACTIVITY, pddProblemLabels.mapIndexed { index, label ->
+                    node("problem-$index", label, 20, 100 + index * 100, 900, 180 + index * 100)
+                })
+            }
             if (!panel) {
                 if (reviewPage) {
                     return UiSnapshot(PDD, ACTIVITY, listOf(
@@ -977,6 +1364,7 @@ class PurchaseRehearsalExecutorTest {
                 } else if (!missingSpecEntry && specEntryReady) {
                     nodes += node("spec", "选择规格", 20, 1000, 900, 1100, clickable = true)
                 }
+                if (entryActionChanged) nodes += node("rerender", "页面已刷新", 20, 1100, 400, 1180)
                 if (includeReviewEntry) nodes += node("review", "商品评价", 20, 1200, 900, 1300, clickable = true)
                 return UiSnapshot(PDD, ACTIVITY, nodes)
             }
@@ -986,8 +1374,9 @@ class PurchaseRehearsalExecutorTest {
                     node("panel-title", "确认款式", 20, 396, 300, 430),
                 ))
             }
-            val hideColor = hideColorAfterQuantitySet && quantity == 2L
-            val hideSize = hideSizeAfterQuantitySet && quantity == 2L
+            val singleHeading = prefixlessSingleHeadingAfterColor && color != null
+            val hideColor = singleHeading || (hideColorAfterQuantitySet && quantity == 2L && !hiddenColorRestored)
+            val hideSize = (hideSizeAfterQuantitySet && quantity == 2L) || (hideSizeAfterSelection && size != null)
             val hideSummary = hideSelectedSummaryAfterQuantitySet && quantity == 2L
             val displayedSummary = if (quantity == 2L && selectedSummaryOverrideAfterQuantitySet != null) {
                 selectedSummaryOverrideAfterQuantitySet
@@ -1000,46 +1389,82 @@ class PurchaseRehearsalExecutorTest {
                 node("title", "确认款式", 20, 396, 300, 430),
             )
             if (!nonScrollablePanel) nodes += node("scroll", "", 0, 400, 1080, 950, scrollable = true)
-            if (!hideSummary) {
+            if (singleHeading) {
+                nodes += node("info", "", 0, 300, 1080, 400)
+                nodes += node("info/summary", displayedSummary, 20, 320, 700, 350, parentPath = "info")
+                nodes += node("close", "关闭", 980, 300, 1060, 350, clickable = true)
+                nodes += node("minus", "减少数量", 300, 360, 380, 390, clickable = true)
+                nodes += node("plus", "增加数量", 620, 360, 700, 390, clickable = true)
+                nodes += node("payment", "微信支付", 600, 1000, 900, 1050)
+            } else if (!hideSummary) {
                 nodes += node("selected", "已选 $displayedSummary", 20, 365, 700, 395)
             }
             if (!hideColor) {
                 nodes += node("scroll/color-heading", "颜色分类", 20, 410, 300, 450, parentPath = "scroll")
-                colors.forEachIndexed { index, value ->
-                    nodes += node("scroll/color-$index", value, 20 + index * 220, 470, 200 + index * 220, 540, clickable = true, selected = color == value, enabled = !allSpecsUnavailable, parentPath = "scroll")
+                val selectedColor = if (quantity == 2L) selectedColorOverrideAfterQuantitySet ?: color else color
+                val visibleColors = horizontalColorPages?.get(horizontalColorPage) ?: colors
+                val colorParent = if (horizontalColorPages != null && visibleColors.size > 1) "scroll/color-row" else "scroll"
+                if (colorParent != "scroll") {
+                    nodes += node(colorParent, "", 0, 460, 1080, 550, scrollable = true, parentPath = "scroll")
+                }
+                visibleColors.forEachIndexed { index, value ->
+                    nodes += node(
+                        "scroll/color-$index",
+                        value,
+                        20 + index * 220,
+                        470,
+                        200 + index * 220,
+                        540,
+                        clickable = true,
+                        selected = selectedColor == value,
+                        enabled = !allSpecsUnavailable,
+                        parentPath = colorParent,
+                    )
                 }
             }
             if (!hideSize) {
                 nodes += node("scroll/size-heading", "尺码", 20, 650, 300, 690, parentPath = "scroll")
-                val visibleSizes = if (quantity == 2L && finalSizesAfterQuantitySet != null) {
+                val visibleSizes = if (revealGridSizeAfterUpSwipes != null) {
+                    if (upSwipeCount >= revealGridSizeAfterUpSwipes) sizes else listOf("S", "M")
+                } else horizontalSizePages?.get(horizontalSizePage) ?: if (quantity == 2L && finalSizesAfterQuantitySet != null) {
                     finalSizesAfterQuantitySet
                 } else if (upSwipeCount >= hiddenSizeUntilUpSwipes) {
                     sizes
                 } else {
                     listOf("S")
                 }
+                val sizeParent = if (horizontalSizePages != null) "scroll/size-row" else "scroll"
+                if (horizontalSizePages != null) {
+                    nodes += node(sizeParent, "", 0, 700, 1080, 800, scrollable = true, parentPath = "scroll")
+                }
                 visibleSizes.forEachIndexed { index, visibleSize ->
                     nodes += node(
-                        "scroll/size-$index",
+                        "$sizeParent/size-$index",
                         visibleSize,
                         20 + index * 250,
-                        710,
+                        710 - if (revealGridSizeAfterUpSwipes != null) upSwipeCount.coerceAtMost(10) * 2 else 0,
                         220 + index * 250,
-                        780,
+                        780 - if (revealGridSizeAfterUpSwipes != null) upSwipeCount.coerceAtMost(10) * 2 else 0,
                         clickable = true,
                         selected = !hideSizeSelectedState && size == visibleSize,
                         enabled = !allSpecsUnavailable && visibleSize !in unavailableSizes,
-                        parentPath = "scroll",
+                        parentPath = sizeParent,
                     )
                 }
             }
-            nodes += node("quantity", quantity.toString(), 400, 800, 600, 870, className = "android.widget.EditText")
-            nodes += node("confirm", "确定", 20, 900, 500, 980, clickable = true)
-            nodes += node("order", "提交订单", 20, 1100, 500, 1180, clickable = true)
+            nodes += if (singleHeading) node("info/quantity", quantity.toString(), 400, 360, 600, 390, className = "android.widget.EditText", parentPath = "info")
+                else node("quantity", quantity.toString(), 400, 800, 600, 870, className = "android.widget.EditText")
+            if (!singleHeading) nodes += node("confirm", "确定", 20, 900, 500, 980, clickable = true)
+            nodes += node("order", "提交订单", 20, if (singleHeading) 2000 else 1100, 500, if (singleHeading) 2080 else 1180, clickable = true)
             nodes += node("pay", "立即支付", 520, 1100, 1020, 1180, clickable = true)
             return UiSnapshot(PDD, ACTIVITY, nodes)
         }
 
+        fun leaveAgentAndOpenBrowser() {
+            inAgent = false
+            browser = true
+        }
+
         override fun clickFresh(target: SnapshotNode): FreshActionResult {
             clicked += target.label
             clickedPaths += target.path
@@ -1056,14 +1481,17 @@ class PurchaseRehearsalExecutorTest {
                     if (result == FreshActionResult.SUCCESS || openPddOnFailedClick) browser = false
                     return result
                 }
-                "选择规格", "免拼购买" -> if (entryActionHasEffect) panel = true
-                in sizes -> {
+                "选择规格", "免拼购买" -> {
+                    if (entryActionChangesPageWithoutPanel) entryActionChanged = true
+                    if (entryActionHasEffect) panel = true
+                }
+                in (horizontalSizePages.orEmpty().flatten() + sizes) -> {
                     sizeClickCount++
                     val result = sizeClickResults.removeFirstOrNull() ?: FreshActionResult.SUCCESS
                     if (result == FreshActionResult.SUCCESS || sizeSelectsOnFailedClick) size = target.label
                     return result
                 }
-                in colors -> color = target.label
+                in (horizontalColorPages?.flatten() ?: colors) -> color = target.label
                 "增加数量" -> quantity++
                 "减少数量" -> quantity--
             }
@@ -1080,7 +1508,7 @@ class PurchaseRehearsalExecutorTest {
                 }
                 return FreshClickOutcome(result, forcedEntryClickReason)
             }
-            if (target.label in sizes && forcedSizeClickReason != null) {
+            if (target.label in (horizontalSizePages?.flatten() ?: sizes) && forcedSizeClickReason != null) {
                 sizeClickCount++
                 val result = when (forcedSizeClickReason) {
                     FreshClickReason.ROOT_UNAVAILABLE, FreshClickReason.TARGET_NOT_FOUND -> FreshActionResult.NOT_FOUND
@@ -1107,12 +1535,15 @@ class PurchaseRehearsalExecutorTest {
             if (specTapResult != FreshActionResult.SUCCESS || !specTapHasEffect) return specTapResult
             when {
                 target.path in setOf("spec", "buy") -> panel = true
-                target.label in sizes -> size = target.label
+                target.label in (horizontalSizePages?.flatten() ?: sizes) -> size = target.label
                 target.label in colors -> color = target.label
             }
             return FreshActionResult.SUCCESS
         }
 
+        val openEntryClickCount: Int
+            get() = clicked.count { it == "选择规格" || it == "免拼购买" }
+
         override fun inputFresh(target: SnapshotNode, value: String): FreshActionResult {
             quantity = value.toLong()
             return FreshActionResult.SUCCESS
@@ -1126,9 +1557,34 @@ class PurchaseRehearsalExecutorTest {
 
         override fun swipePurchaseIn(target: SnapshotNode, direction: SwipeDirection, durationMs: Long): Boolean {
             swipeInPaths += target.path
+            if (restoreHiddenColorOnDownSwipe && quantity == 2L && direction == SwipeDirection.DOWN) {
+                hiddenColorRestored = true
+            }
             return swipePurchase(direction, durationMs)
         }
 
+        override fun swipeSpecRow(target: SnapshotNode, direction: SwipeDirection): Boolean {
+            horizontalSpecDirections += direction
+            horizontalSpecAnchorPaths += target.path
+            val dimension = if (target.label in (horizontalSizePages?.flatten() ?: emptyList())) "size" else "color"
+            horizontalSpecDimensions += dimension
+            if (!horizontalSpecSwipeSucceeds) return false
+            if (dimension == "size") {
+                horizontalSizePage = when (direction) {
+                    SwipeDirection.LEFT -> (horizontalSizePage + 1).coerceAtMost((horizontalSizePages?.lastIndex ?: 0))
+                    SwipeDirection.RIGHT -> (horizontalSizePage - 1).coerceAtLeast(0)
+                    else -> horizontalSizePage
+                }
+            } else {
+                horizontalColorPage = when (direction) {
+                    SwipeDirection.LEFT -> (horizontalColorPage + 1).coerceAtMost((horizontalColorPages?.lastIndex ?: 0))
+                    SwipeDirection.RIGHT -> (horizontalColorPage - 1).coerceAtLeast(0)
+                    else -> horizontalColorPage
+                }
+            }
+            return true
+        }
+
         override fun pullDownGoodsPage(): Boolean {
             pullDownCount++
             if (!pullDownSucceeds) return false

android/app/src/test/java/cn/ilapage/goauto/agent/PurchaseRetryPolicyTest.kt

@@ -16,19 +16,22 @@ class PurchaseRetryPolicyTest {
     }
 
     @Test
-    fun `retry confirmation explains new task current archive and no payment`() {
+    fun `ordinary retry uses same task new attempt and no payment`() {
         val message = PurchaseRetryPolicy.confirmationMessage()
-        assertTrue(message.contains("保留原任务"))
-        assertTrue(message.contains("当前商品档案"))
-        assertTrue(message.contains("最新采购规则"))
-        assertTrue(message.contains("新采购任务"))
+        assertTrue(PurchaseRetryPolicy.usesInPlaceReset(continuing = false))
+        assertTrue(message.contains("复用原采购任务"))
+        assertTrue(message.contains("新一次执行"))
+        assertTrue(message.contains("当前有效采购规则"))
+        assertTrue(message.contains("任务快照保持不变"))
         assertTrue(message.contains("待付款订单"))
         assertTrue(message.contains("不会支付"))
+        assertFalse(message.contains("新采购任务"))
     }
 
     @Test
     fun `continue confirmation remains a new purchase task`() {
         val message = PurchaseRetryPolicy.confirmationMessage(continuing = true)
+        assertFalse(PurchaseRetryPolicy.usesInPlaceReset(continuing = true))
         assertTrue(message.contains("新采购任务"))
         assertTrue(message.contains("替代商品"))
         assertTrue(message.contains("不会支付"))

android/app/src/test/java/cn/ilapage/goauto/agent/PurchaseScrollLocatorTest.kt

@@ -0,0 +1,39 @@
+package cn.ilapage.goauto.agent
+
+import cn.ilapage.goauto.agent.automation.NodeBounds
+import cn.ilapage.goauto.agent.automation.PurchaseScrollCandidate
+import cn.ilapage.goauto.agent.automation.PurchaseScrollLocator
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class PurchaseScrollLocatorTest {
+    private val outer = PurchaseScrollCandidate("0/1", "RecyclerView", NodeBounds(0, 1038, 1080, 2079))
+    private val inner = PurchaseScrollCandidate("0/1/0", "RecyclerView", NodeBounds(36, 1149, 1080, 2007))
+
+    @Test fun nestedContainersWithNearbyCentersResolveOuter() {
+        assertEquals(outer, PurchaseScrollLocator.locate(outer, listOf(inner, outer)))
+    }
+
+    @Test fun pathDisambiguatesIdenticalBounds() {
+        val nested = outer.copy(path = "0/1/0")
+        assertEquals(outer, PurchaseScrollLocator.locate(outer, listOf(nested, outer)))
+    }
+
+    @Test fun changedPathRequiresUniqueFullBoundsMatch() {
+        val moved = outer.copy(path = "0/2")
+        assertEquals(moved, PurchaseScrollLocator.locate(outer, listOf(inner, moved)))
+        assertNull(PurchaseScrollLocator.locate(outer, listOf(moved, moved.copy(path = "0/3"))))
+    }
+
+    @Test fun reusedPathWithDifferentGeometryIsRejected() {
+        assertNull(PurchaseScrollLocator.locate(outer, listOf(inner.copy(path = outer.path))))
+    }
+
+    @Test fun classAndAllEdgesAreValidated() {
+        assertNull(PurchaseScrollLocator.locate(outer, listOf(outer.copy(className = "ScrollView"))))
+        assertNull(PurchaseScrollLocator.locate(outer, listOf(
+            outer.copy(bounds = NodeBounds(0, 1138, 1080, 1979)),
+        )))
+    }
+}

android/app/src/test/java/cn/ilapage/goauto/agent/persistence/AgentDiagnosticStoreMigrationTest.kt

@@ -83,6 +83,24 @@ class AgentDiagnosticStoreMigrationTest {
         assertEquals(1, rowCount(db))
     }
 
+    @Test
+    fun v2MigrationAddsPurchaseFailureColumnsWithoutDroppingRows() = withDatabase { db ->
+        db.createStatement().use { statement ->
+            statement.execute(CREATE_V1_TABLE_SQL)
+            statement.execute(
+                "INSERT INTO agent_diagnostic " +
+                    "(task_id, stage, reason, attempt, elapsed_ms, agent_version, created_at) " +
+                    "VALUES (153, 'SPEC_PANEL_ENTRY', 'PURCHASE_FAILURE', 2, 120, '0.9.99', 1000)",
+            )
+        }
+        AgentDiagnosticSchema.migrationStatements(1, 3, columnNames(db)).forEach { sql ->
+            db.createStatement().use { it.execute(sql) }
+        }
+        assertTrue(columnNames(db).containsAll(AgentDiagnosticSchema.purchaseFailureColumns.keys))
+        assertEquals(1, rowCount(db))
+        assertTrue(AgentDiagnosticSchema.migrationStatements(3, 3, columnNames(db)).isEmpty())
+    }
+
     private fun migrateV1ToV2(db: Connection) {
         AgentDiagnosticSchema.v2MigrationStatements(1, 2, columnNames(db)).forEach { sql ->
             db.createStatement().use { it.execute(sql) }

docs/00-project-profile.md

@@ -2,8 +2,8 @@
 generated: true (请先修改 Gitea Wiki，禁止直接编辑本文件)
 wiki_page: Project-Profile
 wiki_url: https://git.ilapage.cn/OPC/goauto/wiki/Project-Profile.-
-wiki_revision: b1b1b343917e66288f4282bc6b3b90ea4ff3cca0
-synchronized_at: 2026-09-04T11:29:41Z
+wiki_revision: 7468b9fbdd4d0bbbb9a73580c22ec868b3085753
+synchronized_at: 2026-09-05T07:16:39Z
 <!-- gitea-wiki-mirror:end -->
 
 # 项目档案
@@ -21,16 +21,20 @@ synchronized_at: 2026-09-04T11:29:41Z
 | 后续设计范围 | 从 SYB 创建采购任务、创建待付款订单、物流采集与自动回填 |
 | 预计规模 | 20 台 Android；每天约 100 个采集任务、200 个采购任务 |
 
+## 项目治理模式
+
+GoAuto 默认采用轻量治理：文案、注释、格式、局部样式或布局、预期行为明确的小 Bug，以及不改变接口、数据结构、权限和安全边界的单模块低风险调整可以直接实施，无需为了留痕补建工单。完整独立需求、新页面、跨模块功能，以及涉及 API、数据结构、权限、安全、迁移或范围不明确的变化必须建立单元工单。采购、创建订单、真实个人或生产数据、权限、安全、并发、迁移、删除、发布和不可逆操作始终升级为高风险，必须具备对象和范围明确的人工授权；已有有效授权时不机械重复确认，范围或环境发生实质变化时重新确认。永久禁止付款以及设备、隐私、AI 和真机安全红线不可裁剪。
+
 ## 建设基线
 
 | 基线 | 来源与版本 | 许可证 / 使用方式 | GoAuto 适配 |
 |---|---|---|---|
-| DevHarness | `D:\OPC\dev_harness`，目标提交 `4bbacf4d7fb265984396bb5589c544105043fa0b` | 开发流程与文档模板 | 2026-08-27 升级（#114）：在 #76 已采用的单人工单事实源基础上，增量加入部署模板、Gitea MCP 与最小工单读取、线上原型默认审核与按需 HTML 导出、PowerShell UTF-8/ExecutionPolicy 边界；继续保留 GoAuto 专用安全与设计门禁 |
+| DevHarness | `D:\OPC\dev_harness`，目标提交 `ecab899` | 开发流程与文档模板 | 2026-09-05 升级（#221）：在既有单人工单事实源基础上，选择性加入轻量治理、明确授权边界、中文默认沟通、Windows PowerShell 安全规则，以及按 revision 增量同步与显式深度检查；继续保留 GoAuto 专用高风险与安全门禁 |
 | 服务端 | `go-admin` v2.3.0 | 上游开源管理端基线；升级时复核许可证和安全公告 | 保留认证、菜单、配置和管理端基础能力，新增 GoAuto 业务模块 |
 | 管理端 | `go-admin-ui` v3.0.0，`web/package.json` 标注 MIT | Vue 管理界面基线 | 保留应用外壳与通用组件，新增 GoAuto 页面 |
 | Android | 原生 Kotlin Agent | 自研业务客户端 | 通过管理员明确配置的 HTTP 或 HTTPS Origin 直连服务端，不保留 Windows 桌面 Client/ADB 作为生产拓扑 |
 
-升级必须比较当前记录的目标提交与新的明确提交，不能笼统复制“最新版”。本次上一基线为 `bfdf648962d11a8024f62768380d8571e1f45f68`，目标为 `4bbacf4d7fb265984396bb5589c544105043fa0b`，区间共 13 个提交；更早基线 `b1f500128d6eb100985792d4a715db8b6b5ae203` 的适配见 #47。模板内容一律按 GoAuto 事实改写：不复制 DevHarness 的项目事实、任务记录、占位部署参数或历史归档；`harness.py` 继续校验 GoAuto 实际核心页面与产品 README，GoAuto 更严格的付款、订单、设备、数据和真机门禁继续优先。
+升级必须比较当前记录的目标提交与新的明确提交，不能笼统复制“最新版”。本次上一基线为 `4bbacf4d7fb265984396bb5589c544105043fa0b`，目标为 `ecab899`，选择性适配其后的 7 个提交；更早基线适配见 #47 与 #114。模板内容一律按 GoAuto 事实改写：不复制 DevHarness 的项目事实、任务记录、占位部署参数或历史归档；`harness.py` 继续校验 GoAuto 实际核心页面与产品 README，GoAuto 更严格的付款、订单、设备、数据和真机门禁继续优先。
 
 ## 交付单元
 

docs/01-workflow.md

@@ -2,12 +2,18 @@
 generated: true (请先修改 Gitea Wiki，禁止直接编辑本文件)
 wiki_page: Development-Workflow
 wiki_url: https://git.ilapage.cn/OPC/goauto/wiki/Development-Workflow.-
-wiki_revision: b1b1b343917e66288f4282bc6b3b90ea4ff3cca0
-synchronized_at: 2026-09-04T11:29:46Z
+wiki_revision: 62ddbe4469740c02ce4a6ca2fd1966a89a79322f
+synchronized_at: 2026-09-05T07:16:44Z
 <!-- gitea-wiki-mirror:end -->
 
 # 开发工作流
 
+## 语言与术语
+
+- 用户可以使用中文、英文或合理的中英混合语言交流；默认使用中文分析、回复、编写工单和维护内部项目文档。
+- 代码标识符、命令、参数、路径、文件名、API 名称、协议名、日志和错误原文保持原样；必要时补充简短中文解释。
+- 用户明确要求某次回复或交付物使用其他语言时，按该次要求执行，不改写接口契约或影响搜索和执行的原文。
+
 ## 事实来源
 
 | 信息 | 唯一事实来源 |
@@ -18,7 +24,7 @@ synchronized_at: 2026-09-04T11:29:46Z
 | 源码、迁移、测试、版本绑定分析、本地原型和核心 Wiki 镜像 | Git |
 | 可编辑交互设计 | QuantUX；App ID、版本、链接和确认状态记录在工单 |
 
-核心页面通过 `wiki-docs.json` 显式映射，固定执行 Wiki → `docs/` 单向同步。既有 Wiki 任务归档和 `docs/task/` 只作历史兼容；标准任务不创建或导出，只有用户明确要求专项快照时才使用 `archive` / `export`。
+核心页面通过 `wiki-docs.json` 显式映射，固定执行 Wiki → `docs/` 单向同步。日常 `sync` 与 `sync --check` 先比较页面 revision，revision 未变化时不重复下载正文；疑似镜像损坏或需要完整核对时显式使用 `sync --deep-check`。既有 Wiki 任务归档和 `docs/task/` 只作历史兼容；标准任务不创建或导出，只有用户明确要求专项快照时才使用 `archive` / `export`。
 
 ## 权威源与事实边界
 
@@ -53,6 +59,19 @@ synchronized_at: 2026-09-04T11:29:46Z
 - 每个核心页面写入后必须在线回读并取得 revision。页面缺失、回读失败或没有 revision 时停止初始化。
 - 产品编码前运行 `python dev_scripts/harness.py sync --verify`；全部成功才表示初始化完成。
 
+## 项目治理模式与不可裁剪底线
+
+GoAuto 默认采用轻量治理。文案、注释、格式、局部样式或布局、预期行为明确的小 Bug，以及不改变接口、数据结构、权限和安全边界的单模块低风险调整可以直接实施，无需为了留痕补建工单。完整独立需求、新页面、跨模块功能，以及 API、数据结构、权限、安全、迁移或范围不明确的变化必须建单。
+
+采购、创建订单、真实个人或生产数据、权限、安全、并发、数据库迁移、删除数据、发布和其他不可逆操作始终升级为高风险。无论任务采用何种最小门禁，凭据保护、永久禁止付款、个人与生产数据最小化、设备互斥、Agent 禁止 OCR/VLM、控件树与整屏截图禁存、工作区保护、真实测试和人工验收均不可裁剪。
+
+### 明确授权后的执行
+
+- 当前聊天中用户给出的明确指令，或 Gitea 工单中能够归属于有权人工的明确授权，可以作为执行依据，不要求把同一授权重复复制到工单后再次确认。
+- 授权必须能识别操作、对象和范围；Agent 自动生成的工单、草稿、摘要或对用户意图的转述不能单独构成人工授权。
+- 获得有效授权后，只核对准确目标、授权范围和当前状态等最小必要前提，不得仅因操作不可逆而重复询问或拒绝。
+- 授权不自动覆盖相邻对象或后续任务；环境、对象、范围或影响发生实质变化时重新确认。平台自身强制的审批、安全策略或权限限制继续有效。
+
 ## 工单与设计证据双门禁
 
 正式实施前先判断是否需要工单，再判断需要什么设计证据。工单不能替代原型确认，原型也不能替代技术方案、安全检查和单元工单。

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: bd2748f2b58daee92eaa1e5ed16ce61fa18f728f
-synchronized_at: 2026-09-05T01:00:01Z
+wiki_revision: 670a5592a6db8301cd115295bf820f7f4b6e06d7
+synchronized_at: 2026-09-07T03:21:47Z
 <!-- gitea-wiki-mirror:end -->
 
 # 业务规则与术语
@@ -144,7 +144,7 @@ synchronized_at: 2026-09-05T01:00:01Z
 - SYB 商品页的 PDD 采集资格独立于采购处理阶段：只要已关联的 PDD 商品未停用、没有 `pending` / `running` 采集任务且存在可用采集规则，即可创建采集任务；因此已完成采集并进入“可创建采购”的商品也可以重新采集。相同 PDD 商品在批量创建前按商品去重，服务端创建时仍按最新状态复核。
 - 批量创建读取管理员选定的当前采购规则并重新执行契约校验，每条任务保存不可变快照；当前规则缺失或无效时明确阻断，不回退到代码常量。设备默认人工指定，也可以留空由符合能力的空闲设备领取。
 - 批量创建的价格保护来自 PDD 商品档案而不是 SYB/Shopee 的 TWD 售价：当前采购规则可用 `priceGuard.minRatio`（0.1～1.0）和 `maxRatio`（1.0～3.0）配置比例，缺省仍为 0.2 / 1.5；最低价向下取整、最高价向上取整到人民币分。已确认颜色映射时按该颜色计算，待规格探测时以全部可用颜色的最低/最高价计算，参考价取最高价；没有可用颜色价格时不能创建。
-- 地址后缀为 `_cg{purchase_task.id}`。选好规格和数量后，Agent 仍停留在当前规格/下单面板；若收货地址被面板裁切，只允许在唯一、可见且占据主要宽度的纵向滚动容器内有限向下拉动来显示地址，禁止按页面最大滚动区域盲目滑动。Agent 只在唯一地址入口、唯一修改按钮和唯一详细地址输入框均成立时修改；脱敏手机号文字本身不可点击时，仍以该唯一文字节点的中心坐标执行一次精确手势点击，不沿用可能覆盖整个下单面板的可点击祖先。“修改”“保存”和“提交订单”等文字节点即使依赖可点击父节点，也必须保留原始文字节点作为每次重新定位的锚点，父节点只用于验证存在可点击路径。近乎完全重叠的无障碍重复节点按一个目标处理，仍有多个独立目标或页面切换超时则明确失败。按首个 `-` 或 `_` 截取地址主体后追加当前后缀，保存后必须回读完整新地址。修改或回读失败时禁止创建订单，地址全文和控件树不落库。
+- 地址后缀为 `_cg{purchase_task.id}`。精确规格、数量、价格和摘要核验通过后，若仍处于已识别的规格面板，Agent 只允许点击唯一、可见、启用、可点击且文案精确命中“确定/确认”别名的规格确认控件；不得点击提交订单、确认购买、付款、支付、地址修改或地址保存控件，也不使用中心手势兜底。点击后必须重新读取并确认已出现订单确认页或地址入口强证据，否则明确失败。进入订单确认页后，若收货地址被面板裁切，只允许在唯一、可见且占据主要宽度的纵向滚动容器内有限向下拉动来显示地址，禁止按页面最大滚动区域盲目滑动。Agent 只在唯一地址入口、唯一修改按钮和唯一详细地址输入框均成立时修改；脱敏手机号文字本身不可点击时，仍以该唯一文字节点的中心坐标执行一次精确手势点击，不沿用可能覆盖整个下单面板的可点击祖先。“修改”“保存”和“提交订单”等文字节点即使依赖可点击父节点，也必须保留原始文字节点作为每次重新定位的锚点，父节点只用于验证存在可点击路径。近乎完全重叠的无障碍重复节点按一个目标处理，仍有多个独立目标或页面切换超时则明确失败。按首个 `-` 或 `_` 截取地址主体后追加当前后缀，保存后必须回读完整新地址。修改或回读失败时禁止创建订单，地址全文和控件树不落库。
 - 地址编辑页可以同时存在收货人、手机号和详细地址等多个输入框；Agent 只选择与“详细地址”标签纵向重叠且位于其右侧的唯一输入框，不能用页面输入框总数或顺序猜测。
 - 点击创建订单前，Agent 必须先在本地事务保存 `order_submit_started`、不可逆时间、稳定请求 ID 和不含地址全文的最终确认快照，再用同一请求 ID通知服务端；两侧成功后才允许精确点击唯一创建订单按钮一次。
 - 进入不可逆边界后，进程重启、断网、点击结果不明或无法取得唯一订单号/下单时间时只允许只读核单并进入 `order_result_unknown`，禁止再次点击；任务与订单正式关联仍以完整 PDD 订单号为准。
@@ -257,13 +257,13 @@ synchronized_at: 2026-09-05T01:00:01Z
 ## Agent 受控重试采购
 
 - 当前设备只可重试自身最近 30 天内、服务端标记 `retryable=true` 的正式采购失败任务；列表和详情都只能发起单任务重试，不支持多选、批量或自动重试。
-- 普通“重试采购”调用既有 `AgentRetry → BatchRetry → Create`：原失败任务及其商品、目标规格、执行规格、价格和执行记录保持不可变；服务端根据当前 SYB、虾皮/PDD 档案、当前采购规则和当前设备创建不同 `purchase_task.id` 的新任务。
-- 新 SYB 采购任务继续遵循 #215 的强制当次规格探测，首趟不得直接使用历史任务的规格决策；当前档案、规则、价格、设备或能力门禁不通过时拒绝创建，旧任务保持失败状态。
+- 普通“重试采购”调用就地 `/reset`：复用原 `purchase_task.id`，只新增 attempt；新 attempt 使用当前有效采购规则和最新版 Agent 代码，商品、目标规格、执行规格、数量、价格、地址及既有规格决策等业务快照保持不变。
+- 就地重试不恢复已经消耗的真机规格探测资格；目标规格存在但对应执行规格为空时必须拒绝，不能进入正式采购阶段。需要按替代商品或已变化业务规格重新决策时，必须走明确的新任务流程。
 - 已出现 `order_submit_started` 证据，或存在不可逆时间、订单提交请求、PDD 订单号、下单时间的任务一律拒绝重试，并提示走既有“授权重新采购”流程，防止重复下单。
-- `requestId` 按“来源任务 + 请求”幂等；相同请求重放返回同一新任务，不重复创建。
-- Android 只在服务端 `retryable=true` 且状态为 `failed` 时显示普通“重试采购”。确认和成功反馈必须说明旧任务保留、新任务读取当前档案和规则、可能创建待付款订单且系统不会支付。
-- 历史兼容的就地 `/reset` 服务端入口不得把“目标规格存在但对应执行规格为空”的任务恢复到正式采购阶段；此类异常快照必须拒绝，并提示创建新任务。Android 普通重试不再调用该入口。
-- 替代商品匹配完成后的“继续采购”和 Admin 批量重试继续使用同一新任务语义；取消订单、修改既有订单和支付仍禁止。真机重试可能进入创建待付款订单流程，执行前必须再次取得人工授权。
+- `requestId` 按“任务 + 重置请求”幂等；相同请求重放返回同一 task ID 和 attempt，不重复递增。
+- Android 只在服务端 `retryable=true` 且状态为 `failed` 时显示普通“重试采购”。确认和成功反馈必须说明复用原任务、新增一次执行、使用当前规则但业务快照不变、可能创建待付款订单且系统不会支付。
+- `/reset` 不得把“目标规格存在但对应执行规格为空”的任务恢复到正式采购阶段；此类异常快照必须拒绝，并提示使用明确的新任务流程。
+- 替代商品匹配完成后的“继续采购”继续调用 `AgentRetry → BatchRetry → Create`，按当前档案创建不同 task ID；Admin 批量重试也保持新任务语义。取消订单、修改既有订单和支付仍禁止。真机重试可能进入创建待付款订单流程，执行前必须再次取得人工授权。
 
 ## Agent 状态页手动检查任务
 
@@ -341,7 +341,7 @@ synchronized_at: 2026-09-05T01:00:01Z
 
 ## SYB 采购强制当次规格探测（#215）
 
-- 每个新 SYB 采购任务固定执行“首趟只读探测 → 服务端确定性优先/必要时 AI → 固化任务级精确规格 → 第二趟正式采购”。已有长期映射只作商品档案事实，不直接进入任务执行规格。
+- 每个新 SYB 采购任务固定执行“首趟只读探测 → 服务端确定性优先/必要时 AI → 固化任务级精确规格 → 第二趟正式采购”。首趟只打开一次浏览器商品链接；匹配期间当前设备保留给同一任务，不领取其他采购或采集任务。连续进入第二趟且当前仍有 PDD 商品页或规格面板强证据时复用当前页、不再次打开链接；手动同任务重试，或当前处于 Agent、其他应用及缺少上述强证据时，重新打开任务固化的商品 URL。复用或重开均不严格核验标题、goodsId 或页面指纹，但仍要求 PDD 包名与商品/规格/订单页面结构安全证据。已有长期映射只作商品档案事实，不直接进入任务执行规格。
 - 首趟候选与 `taskId`、`taskAttemptId`、`deviceId`、规则快照哈希和幂等结果哈希关联；第二趟失败不得回到首趟循环探测。备货 `stock/direct_select` 没有 SYB 目标规格，继续使用用户逐字选择的档案规格，不进入本规则。
 - 候选和 Provider 结果仅保存颜色、尺码原始标签及结构化决策，不保存控件树、整屏截图、账号、地址、订单或支付数据；付款仍永久禁止。
 
@@ -429,3 +429,18 @@ synchronized_at: 2026-09-05T01:00:01Z
 - 管理员可在设备管理对未停用设备发起“重置设备身份”。此动作不删除设备记录、不改变设备 ID、能力或已绑定的待领取任务；它立即使旧 Token 无效，并只生成一次、有效期 10 分钟的恢复码。
 - 恢复码仅显示给发起操作的管理员一次，服务端只保存摘要；不得进入列表、日志、任务记录、Android 持久化或普通接口。手机操作员必须在同一安装实例的 Agent 设置中手动输入。
 - 服务端只接受同一 `installId`、未过期且尚未使用的恢复码完成重新注册，成功后签发新 Token 并使恢复码失效。过期、重复使用、installId 不符或停用均明确失败；不能通过清空数据、直接改库或“吊销 Token”恢复原任务归属。
+
+- 自 #223 起，任务创建时把与冻结 SYB 目标对应的已确认商品规格映射保存为不可变的探测指导快照，但仍不得跳过首趟真机探测。探测完成后，每个角色先验证快照映射能否按既有规范化规则唯一对应当次候选，能对应时固化当次候选原文；不能对应时只对该未解决角色执行确定性匹配，仍无结果才调用 AI。已解决角色不重复交给 AI，任一最终值仍必须逐字属于当次候选；历史映射失效、规范化后歧义或角色不符时不得复用。候选完整但无法决策时提示“已采集到当前规格，但未能确定颜色或尺码映射”，不再误报候选不存在。
+
+## 采购商品深链入口（#232）
+
+- Android 采购新任务（含探测与人工重试）打开商品时，优先使用指定 PDD 包名的 ACTION_VIEW，并设置 NEW_TASK 与 CLEAR_TASK，以清理旧任务栈后交付该任务链接。清理的是 Activity 返回历史，不是清除应用数据或强制停止进程。
+- 直接启动失败（包括无可处理 Activity）时回退既有浏览器入口；启动请求被接受后仍由执行器验证稳定商品页面，停留首页不会仅因启动成功而判定完成。
+- 清栈不用于改地址后返回、下单后回到 PDD、订单核查；采集入口继续使用既有浏览器流程，避免绕过规则中的浏览器步骤。
+- 当前通用商品页面结构验证不能独立证明页面 goods_id；解析结果携带的任务 goodsId 不是页面回读证据。首次直接深链上线仍需以实际目标商品真机核对，ADB 实验不替代 Agent 上下文验证。
+## SYB 批量采购设备偏好（#233）
+
+- SYB 商品页“批量创建采购任务”按当前登录用户 ID、当前浏览器来源与 API 环境记住最近一次设备选择；主动清空也记忆为不指定设备。只保存设备 ID，不保存 Token、账号凭据或订单信息。
+- 弹窗打开后先按现有在线/可选/采购能力条件加载设备，再恢复选择并以相同设备预检。记忆设备当前不可用时保留偏好并提示用户重新选择或明确清空，不静默切换设备或自动领取。
+- 预检加载中、失败或记忆设备不可用时不能提交；过期预检结果不覆盖新的设备选择。服务端原有设备及采购资格校验不变。
+- 偏好只作用于此入口，不影响采集、其他创建入口和采购重试。浏览器存储失败时仍允许手动操作；刷新或关闭再打开浏览器可恢复，清理浏览器数据或沿用现有退出登录清理存储行为后需重新选择。

docs/04-local-development-and-verification.md

@@ -2,8 +2,8 @@
 generated: true (请先修改 Gitea Wiki，禁止直接编辑本文件)
 wiki_page: Local-Development-and-Verification
 wiki_url: https://git.ilapage.cn/OPC/goauto/wiki/Local-Development-and-Verification.-
-wiki_revision: b1b1b343917e66288f4282bc6b3b90ea4ff3cca0
-synchronized_at: 2026-09-04T11:30:02Z
+wiki_revision: 835494c4a63a1494601658561fde1ab76657be3d
+synchronized_at: 2026-09-05T07:17:05Z
 <!-- gitea-wiki-mirror:end -->
 
 # 本地开发与验证
@@ -24,6 +24,32 @@ T01 已建立可执行的三端骨架。建议从仓库根目录运行统一脚
 - 不得仅为设置编码重复启动一层 PowerShell；嵌套进程会增加启动时间、转义复杂度和错误定位成本。
 - 代码发现优先使用项目配置的代码图工具；检索字符串、配置和非代码文件，或图工具不足时使用 `rg`。
 
+### PowerShell 语法与外部命令
+
+- Windows 命令不得默认套用 Bash 语法；复杂正则优先先赋给变量或使用 `rg -e`，避免在多层引号中继续嵌套。
+- 多行 Python 或 JSON 正文使用单引号 PowerShell here-string，避免 `$()`、反引号和变量被 PowerShell 提前展开：
+
+```powershell
+$script = @'
+print("保持原文")
+'@
+$script | python -
+```
+
+- `foreach`、`if` 等语句块应保留在同一个 PowerShell 解析上下文中；需要收集表达式结果时使用数组表达式：
+
+```powershell
+$items = @(foreach ($path in $paths) {
+    if (Test-Path -LiteralPath $path) { Get-Item -LiteralPath $path }
+})
+```
+
+- `rg` 使用真实目录配合 `-g/--glob`，不要把 Bash 风格通配路径作为目录参数：
+
+```powershell
+rg -n -g '*.md' 'sync --check' docs
+```
+
 ### 文件编码与控制台输出
 
 文件解码和控制台输出是两个边界。读取 UTF-8 文本时，在命令支持的情况下显式指定字面路径与编码：

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: 644b864833730130cf4a2098a01611da0c0ac45d
-synchronized_at: 2026-09-05T01:01:14Z
+wiki_revision: f3242938de4ac55c47f5c6eebd69184024e6a0ea
+synchronized_at: 2026-09-05T09:04:42Z
 <!-- gitea-wiki-mirror:end -->
 
 # MVP 共享 API 契约
@@ -415,7 +415,7 @@ POST /api/agent/v1/tasks/{taskId}/fail
 | 状态 | 含义 | 是否占用 SYB 活动槽 |
 |---|---|---|
 | `pending` | 待执行 | 是 |
-| `spec_probe_pending` | 第一趟探测结束，待服务端固化规格并重新派发 | 是 |
+| `spec_probe_pending` | 第一趟探测结束，服务端规格匹配中；当前设备保留同任务连续流程且不得领取其他任务 | 是 |
 | `running` | Agent 执行中 | 是 |
 | `rehearsal_completed` | 演练安全结束，未改地址、未创建订单 | 否 |
 | `order_submit_started` | 不可逆标记已落库，只能核单，禁止再次点击 | 是 |
@@ -529,17 +529,17 @@ Admin 列表与详情由 #35 实现；#67 增加 `shopeeOrderNoSnapshot` 的列
 
 | 方法 | 路径 | 说明 |
 |---|---|---|
-| `GET` | `/api/agent/v1/purchase-tasks/next` | 返回与设备能力兼容的指定任务或空闲任务 |
+| `GET` | `/api/agent/v1/purchase-tasks/next` | 优先返回当前设备的运行任务；存在 `spec_probe_pending` 时返回同一等待任务以阻止其他任务插队，否则返回能力兼容的指定任务或空闲任务 |
 | `POST` | `/api/agent/v1/purchase-tasks/{taskId}/claim` | `requestId` 原子领取，并建立设备/可选账号租约 |
 | `POST` | `/api/agent/v1/purchase-tasks/{taskId}/start` | 创建不可变 `taskAttemptId` |
 | `POST` | `/api/agent/v1/purchase-tasks/{taskId}/order-submit-started` | 创建订单前先落不可逆标记；演练任务和 `spec_probe` attempt 永远拒绝 |
 | `POST` | `/api/agent/v1/purchase-tasks/{taskId}/result` | 请求体携带 `taskAttemptId` 和 `requestId`；幂等提交演练、规格探测、订单或失败结果 |
 
-自 #215 起，新建 SYB 采购任务不再从 PDD 档案创建持久匹配工作项，也不在首次派发前调用外部 AI；部署前已存在的 `purchase_spec_match_work_item` 继续按原状态兼容处理。新任务首次 `start` 固定得到 `phase=spec_probe`，Android 通过既有结果字段回传当次候选；匹配成功后的第二次 `start` 才得到 `phase=purchase` 和服务端固化的精确 PDD 原始标签。Android 不接收 AI 配置或自由决策权限。
+自 #215 起，新建 SYB 采购任务不再从 PDD 档案创建持久匹配工作项，也不在首次派发前调用外部 AI；部署前已存在的 `purchase_spec_match_work_item` 继续按原状态兼容处理。新任务首次 `start` 固定得到 `phase=spec_probe`，Android 通过浏览器打开任务链接一次并经既有结果字段回传当次候选；匹配成功后的第二次 `start` 才得到 `phase=purchase` 和服务端固化的精确 PDD 原始标签。连续第二阶段仅在当前 PDD 页面仍有商品页或规格面板强证据时复用首趟页面、不再次打开浏览器链接；手动同任务重试，或当前为 Agent、其他应用及缺少上述强证据时，Android 重新打开任务 `urlSnapshot`。两种路径都不以标题、goodsId 或页面指纹做严格同页校验，仍必须通过 PDD 包名和商品/规格/订单页面结构安全证据。Android 不接收 AI 配置或自由决策权限。
 
-结果提交至少关联 `taskId`、`taskAttemptId`、`deviceId`、规则快照哈希和结构化结果。相同 attempt 的相同结果重复提交返回同一事实；不同内容拒绝覆盖。每个新 SYB 采购任务的第一趟只读遍历当次 PDD 规格面板并提交颜色、尺码原始候选，随后释放设备与已知账号租约并进入 `spec_probe_pending`；服务端只以任务冻结的 SYB 目标和当次候选先做繁简、空白/全半角/大小写及公斤/斤的唯一确定性匹配，仍无唯一结果才调用 AI。AI 的颜色和尺码必须逐字属于当次对应候选，否则按无匹配失败。第二趟只会收到服务端固化的精确 PDD 原始标签；Agent 只在已打开的规格面板内做有限纵向滑动，每次重新读取节点并按完整规范化文字精确点击，连续没有新证据或达到上限即停止。尺码的任务目标与页面值在选择边界使用同一安全尾价规范化；不改写任务快照，规范化为空、仍含货币符号或多个原始候选折叠为同一值时安全失败。
+结果提交至少关联 `taskId`、`taskAttemptId`、`deviceId`、规则快照哈希和结构化结果。相同 attempt 的相同结果重复提交返回同一事实；不同内容拒绝覆盖。每个新 SYB 采购任务的第一趟只读遍历当次 PDD 规格面板并提交颜色、尺码原始候选，随后释放数据库租约和已知账号运行守卫并进入 `spec_probe_pending`，但服务端调度与 Agent 必须把当前设备保留给同一采购流程：`next` 返回该等待任务，Agent 只轮询等待，不领取其他采购或采集任务。服务端只以任务冻结的 SYB 目标和当次候选先做繁简、空白/全半角/大小写及公斤/斤的唯一确定性匹配，仍无唯一结果才调用 AI。AI 的颜色和尺码必须逐字属于当次对应候选，否则按无匹配失败。第二趟只会收到服务端固化的精确 PDD 原始标签；Agent 复用首趟仍打开的页面，只在已打开的规格面板内做有限纵向滑动，每次重新读取节点并按完整规范化文字精确点击，连续没有新证据或达到上限即停止。尺码的任务目标与页面值在选择边界使用同一安全尾价规范化；不改写任务快照，规范化为空、仍含货币符号或多个原始候选折叠为同一值时安全失败。
 
-任务 payload 的必传布尔字段 `specResolutionAllowed` 是 Android 是否可以提交规格探测的唯一资格事实。新建 `taskType=syb_order` 任务必须由声明 `purchase.spec-probe.v1` 的规则创建，初始 `SpecDecisionRequestID` 为空且 `specSource=unresolved`，首趟返回 `true`；当次决策固化后返回 `false`。`stock`、`direct_select`、已固化规格决策、能力缺失及其他组合均返回 `false`。历史兼容的就地 `/reset` 保留 `SpecDecisionRequestID`、目标规格、映射规格和规格决策快照，不能恢复探测资格；映射不完整时必须拒绝，不能进入正式采购阶段。普通 Agent 重试创建新任务并重新取得一次探测资格。Android 不得根据映射是否非空、错误文字或本地判断扩大资格。
+任务 payload 的必传布尔字段 `specResolutionAllowed` 是 Android 是否可以提交规格探测的唯一资格事实。新建 `taskType=syb_order` 任务必须由声明 `purchase.spec-probe.v1` 的规则创建，初始 `SpecDecisionRequestID` 为空且 `specSource=unresolved`，首趟返回 `true`；当次决策固化后返回 `false`。`stock`、`direct_select`、已固化规格决策、能力缺失及其他组合均返回 `false`。普通 Agent 重试使用就地 `/reset`，保留 `SpecDecisionRequestID`、目标规格、映射规格和规格决策快照，不能恢复探测资格；映射不完整时必须拒绝，不能进入正式采购阶段。只有替代商品“继续采购”或 Admin 批量重试创建的新任务才按 #215 重新取得一次探测资格。Android 不得根据映射是否非空、错误文字或本地判断扩大资格。
 
 Android 规格失败使用五个稳定阶段：`PURCHASE_SPEC_TARGET_NOT_VISIBLE`、`PURCHASE_SPEC_TARGET_AMBIGUOUS`、`PURCHASE_SPEC_SAFE_TARGET_MISSING`、`PURCHASE_SPEC_CLICK_FAILED` 和 `PURCHASE_SPEC_SELECTION_UNCONFIRMED`。`PURCHASE_SPEC_CLICK_FAILED` 的 `errorMessage` 只允许稳定子原因 `root_unavailable`、`target_stale`、`no_clickable_ancestor`、`action_click_false` 或 `unknown`；其他阶段的消息不得包含规格原文、坐标、控件树或截图。只有 `PURCHASE_SPEC_TARGET_NOT_VISIBLE && specResolutionAllowed=true` 可以提交规格探测，其他四态直接提交真实失败，服务端原样保留稳定阶段/子原因。旧 Agent 在资格已用尽后再次提交 `spec_probe_completed` 时，服务端以 `PURCHASE_SPEC_REPROBE_REJECTED` fail-closed，释放租约并保留第一次规格决策，不再冒充新的选择根因或再次派发。无匹配、候选不完整、歧义或 Provider 异常同样使任务失败。`order_result_unknown` 只允许管理员或采购员人工解除，永不自动重派。
 
@@ -617,9 +617,9 @@ Content-Type: application/json
 - 响应返回 `taskId`、`attemptNumber`、`status` 和可选的 `replayed`，不返回规则快照、URL、Token、控件树或截图。
 - 设备离线、任务非终态、设备忙、规则不可用或同商品存在活动任务时返回明确冲突，不支持离线排队。
 
-## Agent 受控采购重试（#95、#157、#217）
+## Agent 受控采购重试（#95、#157、#217、#225）
 
-普通失败任务的“重试采购”和替代商品匹配完成后的“继续采购”统一调用新任务接口：
+替代商品匹配完成后的“继续采购”调用新任务接口；普通失败任务的“重试采购”使用下方同任务重置接口：
 
 ```http
 POST /api/agent/v1/purchase-tasks/{taskId}/retry
@@ -647,11 +647,11 @@ Content-Type: application/json
 - 来源任务不得存在 `irreversibleAt`、`orderSubmitRequestId`、PDD 订单号或下单时间。已有任何不可逆证据时返回 `PURCHASE_RETRY_UNSAFE`，提示走“授权重新采购”，不得创建新任务。
 - `AgentRetry → BatchRetry → Create` 保留来源失败任务并创建不同 `purchase_task.id` 的新任务；新任务重新读取当前 SYB、虾皮/PDD 档案、当前采购规则、价格保护和设备能力，重新生成地址后缀，不继承来源任务的旧规格决策。
 - 新 SYB 任务按 #215 固定从 `spec_probe` 开始。相同 `requestId` 重放返回同一新任务且 `replayed=true`；不同 requestId 再次请求受同一 SYB 商品最新任务和设备并发门禁约束。
-- Android 只在服务端 `retryable=true` 且状态为 `failed` 时显示普通“重试采购”；确认文案和成功反馈必须说明原任务保留、新任务使用当前档案与规则、可能产生待付款订单且系统不会支付。
+- 本新任务接口只供替代商品“继续采购”；确认和成功反馈必须说明保留来源任务、按当前替代商品档案创建新任务、可能产生待付款订单且系统不会支付。
 - 规则无效、当前档案或价格不合格、设备离线/忙、能力不匹配、任务状态变化或同一 SYB 商品已有更新任务时，服务端明确拒绝且不得部分创建。
 - Admin 批量重试继续使用相同的新任务语义；替代商品“继续采购”仍在 AgentRetry 前额外验证替换分项与继续采购资格。
 
-历史兼容的就地重置接口仍保留，但 Android 普通重试不再调用：
+普通失败任务的“重试采购”调用同任务重置接口：
 
 ```http
 POST /api/agent/v1/purchase-tasks/{taskId}/reset
@@ -661,8 +661,8 @@ Content-Type: application/json
 {"requestId":"<uuid>"}
 ```
 
-- `/reset` 只允许安全失败、无不可逆证据且不存在更新任务的原任务；它保留原业务快照并刷新当前规则。
-- 目标颜色存在但映射颜色为空，或目标尺码存在但映射尺码为空时，必须返回 `PURCHASE_SPEC_MAPPING_REQUIRED`，不得创建 `purchase` attempt 或下发正式采购 payload。
+- `/reset` 只允许当前设备的安全失败任务且不得存在不可逆证据或更新任务；它复用原 `purchase_task.id`、新增 attempt、刷新当前有效规则，并保持商品、目标/执行规格、数量、价格、地址和规格决策等业务快照不变。
+- 目标颜色存在但映射颜色为空，或目标尺码存在但映射尺码为空时，必须返回 `PURCHASE_SPEC_MAPPING_REQUIRED`，不得创建 `purchase` attempt 或下发正式采购 payload。相同 `requestId` 重放返回同一 task ID 和 attempt，不重复递增；Android 必须明确提示复用原任务和新的 attempt 序号。
 - 两个入口都不执行支付。真机调用可能创建待付款订单，必须先取得人工授权。
 
 ## Agent 任务记录范围与同步（#99）
@@ -865,3 +865,5 @@ X-GoAuto-Device-Recovery-Code: <one-time-code>
 仅管理员可以对未停用的既有设备发起身份重置。服务端立即使旧 Device Token 无效，并生成 10 分钟内仅能使用一次的恢复码；恢复码只在该管理员操作的响应中返回一次，服务端仅保存不可逆摘要，管理端设备列表、日志、任务接口和 Android 本地持久化均不得保存或返回原文。管理员将恢复码经受控人工渠道输入同一安装实例的 Agent 设置页。
 
 Agent 携带既有 Token（可已失效）及恢复码重新调用注册接口。服务端必须同时校验同一 `installId`、未停用状态、恢复码摘要、未过期和未使用；成功后使用原 `deviceId` 写入新 Token 摘要并返回一次新 Token，清除恢复码摘要和有效期。旧 Token 与恢复码都立即失效，已分配的 pending 采集或采购任务保持原 `deviceId`，不创建替代设备记录。缺少或错误恢复码仍为 `DEVICE_INSTALL_ID_CONFLICT`；过期码为 `DEVICE_RECOVERY_EXPIRED`；停用设备为 `DEVICE_DISABLED`。
+
+自 #223 起，新建 SYB 任务在保持 `mappedColor` / `mappedSize` 为空和首趟 `spec_probe` 不变的同时，把创建时与目标规格对应的 confirmed 商品映射冻结为仅供服务端决策的指导快照。服务端收到当次候选后按角色验证该快照：只有规范化后唯一对应当次候选时才复用，并固化当次候选原文；否则该角色继续执行确定性匹配，仍未解决才把该角色及其封闭候选交给 AI。已解决角色不得重复发送给 AI，最终颜色和尺码仍须逐字属于各自当次候选。任务决策快照通过 `roleSources` 记录每个角色的 `manual_mapping` / `exact_match` / `ai_match` 来源；任务级 `specSource` 使用现有枚举汇总，不新增 Agent 决策权限。

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: ad9adc22e69e48c9a8fd87d7121066eecca55fd6
-synchronized_at: 2026-09-04T11:30:50Z
+wiki_revision: df0fe874c7f3f3e9c031f2f793f8f6a0511ace25
+synchronized_at: 2026-09-07T06:25:27Z
 <!-- gitea-wiki-mirror:end -->
 
 # 12 顺云宝（SYB）ERP 接口契约
@@ -228,6 +228,14 @@ Admin 默认 `max_matches = 10000`，可以在配置中调整；上限针对整
 读取完整明细并按既有 upsert 保存，但本次同步仍记为失败、明确提示当天未形成
 稳定快照且不推进游标，下一次继续覆盖今天。任何尝试都不得突破 `max_matches`；
 网络/业务错误、非法 ID 或不完整明细不属于可放宽的快照漂移。
+`[必须，#235]` 当天跨页重复 ID 纳入上述最多 3 次列表快照尝试（含首次），
+不增加另一层重试次数。发现跨页重复后丢弃本次列表，从预检总数和第一页重新开始，
+使用全新 ID 集合；最后一次仍重复时直接失败，不得去重后按成功或降级数据保存。
+已经完成的历史日期保持其已有结果，不重复拉取；历史日期重复不适用此恢复。
+每页先检查非法 ID 和页内重复，再检查跨页重叠；同页同时存在页内重复和跨页重叠时
+仍作为硬错误停止。原有总数漂移/短页的合法唯一列表降级保存条件保持不变。
+重复诊断只记录日期、当天尝试序号、首次/当前页码与行号、start、pageSize、
+expectedTotal 和已获取唯一数量，不记录真实重复 ID、原始响应或个人数据。
 
 ### 4.4 统一日期范围同步与覆盖游标
 

server/app/goauto/aimatching/types.go

@@ -35,11 +35,12 @@ type CandidateSnapshot struct {
 }
 
 type DecisionSnapshot struct {
-	Source     string            `json:"source"`
-	Provider   string            `json:"provider,omitempty"`
-	Model      string            `json:"model,omitempty"`
-	Candidates CandidateSnapshot `json:"candidates"`
-	Matched    struct {
+	Source      string            `json:"source"`
+	Provider    string            `json:"provider,omitempty"`
+	Model       string            `json:"model,omitempty"`
+	Candidates  CandidateSnapshot `json:"candidates"`
+	RoleSources map[string]string `json:"roleSources,omitempty"`
+	Matched     struct {
 		Color string `json:"color,omitempty"`
 		Size  string `json:"size,omitempty"`
 	} `json:"matched"`

server/app/goauto/purchase/lifecycle.go

@@ -33,6 +33,19 @@ func (s *Service) Next(ctx context.Context, token string) (*TaskPayload, error)
 	} else if !errors.Is(err, gorm.ErrRecordNotFound) {
 		return nil, internal(err)
 	}
+	// A completed probe reserves the device's purchase flow while the server
+	// resolves the exact specs. Returning that task as a waiting payload keeps
+	// the Agent from claiming another purchase or collection task and preserves
+	// the PDD page that the probe just inspected.
+	var waiting models.PurchaseTask
+	if err = s.DB.WithContext(ctx).
+		Where("device_id = ? AND status = ?", d.ID, models.PurchaseTaskStatusSpecProbePending).
+		Order("created_at, id").
+		First(&waiting).Error; err == nil {
+		return s.payload(waiting, nil, false)
+	} else if !errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, internal(err)
+	}
 	now := s.Now()
 	var candidates []models.PurchaseTask
 	if err = s.DB.WithContext(ctx).Where("status IN ? AND (lease_expires_at IS NULL OR lease_expires_at <= ?) AND (device_id IS NULL OR device_id = ?)", []string{models.PurchaseTaskStatusPending, models.PurchaseTaskStatusSpecProbePending}, now, d.ID).Order("CASE WHEN device_id IS NULL THEN 1 ELSE 0 END, created_at, id").Limit(100).Find(&candidates).Error; err != nil {
@@ -537,8 +550,8 @@ func (s *Service) resolveProbedSpecs(ctx context.Context, taskID uint64, attempt
 		decision.NoMatch, decision.Decision = true, snapshot
 		decision.FailureCode, decision.FailureMessage = "PURCHASE_SPEC_NOT_MATCHED", "没有找到可采购的 PDD 颜色或尺码"
 	} else {
-		matched, matchErr := s.matcher().Resolve(ctx, request)
-		valid := matchErr == nil && (matched.Source == aimatching.SourceExact || matched.Source == aimatching.SourceAI) &&
+		matched, matchErr := s.resolveProbedMatch(ctx, task, request)
+		valid := matchErr == nil && (matched.Source == "manual_mapping" || matched.Source == aimatching.SourceExact || matched.Source == aimatching.SourceAI) &&
 			matchCandidateValid(request.TargetColor, matched.MappedColor, request.Colors) &&
 			matchCandidateValid(request.TargetSize, matched.MappedSize, request.Sizes)
 		if valid {
@@ -577,7 +590,7 @@ func purchaseMatchReason(err error) string {
 			return "AI 规格匹配暂时不可用，请稍后重新创建采购任务"
 		}
 	}
-	return "没有找到可采购的 PDD 颜色或尺码"
+	return "已采集到当前规格，但未能确定颜色或尺码映射"
 }
 
 type probedSpecCandidates struct {
@@ -659,7 +672,7 @@ func (s *Service) withRunning(ctx context.Context, taskID uint64, token string,
 
 func ensureDeviceFree(tx *gorm.DB, deviceID, taskID uint64, now time.Time) error {
 	var count int64
-	if e := tx.Model(&models.PurchaseTask{}).Where("id <> ? AND device_id = ? AND (status IN ? OR (status IN ? AND lease_expires_at > ?))", taskID, deviceID, []string{models.PurchaseTaskStatusRunning, models.PurchaseTaskStatusOrderSubmitStarted}, []string{models.PurchaseTaskStatusPending, models.PurchaseTaskStatusSpecProbePending}, now).Count(&count).Error; e != nil {
+	if e := tx.Model(&models.PurchaseTask{}).Where("id <> ? AND device_id = ? AND (status IN ? OR (status = ? AND lease_expires_at > ?))", taskID, deviceID, []string{models.PurchaseTaskStatusRunning, models.PurchaseTaskStatusOrderSubmitStarted, models.PurchaseTaskStatusSpecProbePending}, models.PurchaseTaskStatusPending, now).Count(&count).Error; e != nil {
 		return internal(e)
 	}
 	if count > 0 {
@@ -678,7 +691,7 @@ func ensureAccountFree(tx *gorm.DB, accountID *uint64, taskID uint64, now time.T
 		return nil
 	}
 	var count int64
-	if e := tx.Model(&models.PurchaseTask{}).Where("id <> ? AND pdd_account_id = ? AND (status IN ? OR (status IN ? AND lease_expires_at > ?))", taskID, *accountID, []string{models.PurchaseTaskStatusRunning, models.PurchaseTaskStatusOrderSubmitStarted}, []string{models.PurchaseTaskStatusPending, models.PurchaseTaskStatusSpecProbePending}, now).Count(&count).Error; e != nil {
+	if e := tx.Model(&models.PurchaseTask{}).Where("id <> ? AND pdd_account_id = ? AND (status IN ? OR (status = ? AND lease_expires_at > ?))", taskID, *accountID, []string{models.PurchaseTaskStatusRunning, models.PurchaseTaskStatusOrderSubmitStarted, models.PurchaseTaskStatusSpecProbePending}, models.PurchaseTaskStatusPending, now).Count(&count).Error; e != nil {
 		return internal(e)
 	}
 	if count > 0 {

server/app/goauto/purchase/probe_resolution.go

@@ -0,0 +1,207 @@
+package purchase
+
+import (
+	"context"
+	"encoding/json"
+	"strings"
+
+	"go-admin/app/goauto/aimatching"
+	"go-admin/app/goauto/models"
+	"go-admin/app/goauto/shopeeproduct"
+)
+
+// resolveProbedMatch keeps the live probe as the source of executable labels.
+// Confirmed product mappings may guide the decision only when they still map
+// uniquely to a label observed by this attempt.
+func (s *Service) resolveProbedMatch(ctx context.Context, task models.PurchaseTask, request aimatching.MatchRequest) (aimatching.MatchResult, error) {
+	resolvedColor, resolvedSize := "", ""
+	roleSources := map[string]string{}
+
+	mappings := probeGuidanceFromSnapshot(task.SpecDecisionSnapshot)
+	if candidate, ok := currentMappedCandidate(mappings.color.value, request.Colors); ok {
+		resolvedColor, roleSources[shopeeproduct.RoleColor] = candidate, mappings.color.source
+	}
+	if candidate, ok := currentMappedCandidate(mappings.size.value, request.Sizes); ok {
+		resolvedSize, roleSources[shopeeproduct.RoleSize] = candidate, mappings.size.source
+	}
+
+	if task.TargetColorSnapshot != "" && resolvedColor == "" {
+		if exact, ok := aimatching.DeterministicMatch(aimatching.MatchRequest{TargetColor: task.TargetColorSnapshot, Colors: request.Colors}); ok {
+			resolvedColor, roleSources[shopeeproduct.RoleColor] = exact.MappedColor, aimatching.SourceExact
+		}
+	}
+	if task.TargetSizeSnapshot != "" && resolvedSize == "" {
+		if exact, ok := aimatching.DeterministicMatch(aimatching.MatchRequest{TargetSize: task.TargetSizeSnapshot, Sizes: request.Sizes}); ok {
+			resolvedSize, roleSources[shopeeproduct.RoleSize] = exact.MappedSize, aimatching.SourceExact
+		}
+	}
+
+	missingColor := task.TargetColorSnapshot != "" && resolvedColor == ""
+	missingSize := task.TargetSizeSnapshot != "" && resolvedSize == ""
+	var providerDecision aimatching.DecisionSnapshot
+	if missingColor || missingSize {
+		remaining := aimatching.MatchRequest{}
+		if missingColor {
+			remaining.TargetColor, remaining.Colors = task.TargetColorSnapshot, request.Colors
+		}
+		if missingSize {
+			remaining.TargetSize, remaining.Sizes = task.TargetSizeSnapshot, request.Sizes
+		}
+		matched, err := s.matcher().Resolve(ctx, remaining)
+		if err != nil {
+			return aimatching.MatchResult{}, err
+		}
+		if matched.Source != aimatching.SourceExact && matched.Source != aimatching.SourceAI {
+			return aimatching.MatchResult{}, &aimatching.Error{Code: aimatching.CodeNoMatch, Message: "规格匹配来源无效"}
+		}
+		providerDecision = matched.Decision
+		if missingColor {
+			if !matchCandidateValid(remaining.TargetColor, matched.MappedColor, remaining.Colors) {
+				return aimatching.MatchResult{}, &aimatching.Error{Code: aimatching.CodeNoMatch, Message: "AI 返回的颜色不属于当次候选"}
+			}
+			resolvedColor, roleSources[shopeeproduct.RoleColor] = matched.MappedColor, matched.Source
+		}
+		if missingSize {
+			if !matchCandidateValid(remaining.TargetSize, matched.MappedSize, remaining.Sizes) {
+				return aimatching.MatchResult{}, &aimatching.Error{Code: aimatching.CodeNoMatch, Message: "AI 返回的尺码不属于当次候选"}
+			}
+			resolvedSize, roleSources[shopeeproduct.RoleSize] = matched.MappedSize, matched.Source
+		}
+	}
+
+	source := probeSourceSummary(roleSources)
+	reason := "当次候选完成确定性匹配"
+	if containsRoleSource(roleSources, "manual_mapping") || containsRoleSource(roleSources, aimatching.SourceAI) {
+		reason = "已确认映射经当次候选验证，未解决规格按确定性或 AI 匹配"
+	}
+	result := aimatching.RecordedMatch(request, source, resolvedColor, resolvedSize, reason)
+	result.Decision.RoleSources = roleSources
+	result.Decision.Provider = providerDecision.Provider
+	result.Decision.Model = providerDecision.Model
+	result.Decision.Confidence = providerDecision.Confidence
+	return result, nil
+}
+
+type confirmedProbeMapping struct {
+	value   string
+	source  string
+	invalid bool
+}
+
+type confirmedProbeMappingSet struct {
+	color confirmedProbeMapping
+	size  confirmedProbeMapping
+}
+
+type probeGuidanceSnapshot struct {
+	ConfirmedMappings map[string]probeGuidanceMapping `json:"confirmedMappings,omitempty"`
+}
+
+type probeGuidanceMapping struct {
+	Value  string `json:"value"`
+	Source string `json:"source"`
+}
+
+func newProbeGuidanceSnapshot(raw, targetColor, targetSize string) (string, error) {
+	mappings := confirmedProbeMappings(raw, targetColor, targetSize)
+	snapshot := probeGuidanceSnapshot{ConfirmedMappings: map[string]probeGuidanceMapping{}}
+	if mappings.color.value != "" {
+		snapshot.ConfirmedMappings[shopeeproduct.RoleColor] = probeGuidanceMapping{Value: mappings.color.value, Source: mappings.color.source}
+	}
+	if mappings.size.value != "" {
+		snapshot.ConfirmedMappings[shopeeproduct.RoleSize] = probeGuidanceMapping{Value: mappings.size.value, Source: mappings.size.source}
+	}
+	encoded, err := json.Marshal(snapshot)
+	return string(encoded), err
+}
+
+func probeGuidanceFromSnapshot(raw string) confirmedProbeMappingSet {
+	var snapshot probeGuidanceSnapshot
+	if json.Unmarshal([]byte(raw), &snapshot) != nil {
+		return confirmedProbeMappingSet{}
+	}
+	result := confirmedProbeMappingSet{}
+	if mapping, ok := snapshot.ConfirmedMappings[shopeeproduct.RoleColor]; ok {
+		result.color = confirmedProbeMapping{value: strings.TrimSpace(mapping.Value), source: mapping.Source}
+	}
+	if mapping, ok := snapshot.ConfirmedMappings[shopeeproduct.RoleSize]; ok {
+		result.size = confirmedProbeMapping{value: strings.TrimSpace(mapping.Value), source: mapping.Source}
+	}
+	return result
+}
+
+func confirmedProbeMappings(raw, targetColor, targetSize string) confirmedProbeMappingSet {
+	var specs []shopeeproduct.SpecDimension
+	if json.Unmarshal([]byte(raw), &specs) != nil {
+		return confirmedProbeMappingSet{}
+	}
+	result := confirmedProbeMappingSet{}
+	for _, dimension := range specs {
+		for _, value := range dimension.Values {
+			if value.Mapping == nil || value.Mapping.Status != shopeeproduct.MappingStatusConfirmed {
+				continue
+			}
+			mapping := confirmedProbeMapping{value: strings.TrimSpace(value.Mapping.PDDValue), source: mapSource(value.Mapping.Source)}
+			switch {
+			case dimension.Role == shopeeproduct.RoleColor && value.Name == targetColor:
+				result.color = mergeConfirmedProbeMapping(result.color, mapping)
+			case dimension.Role == shopeeproduct.RoleSize && value.Name == targetSize:
+				result.size = mergeConfirmedProbeMapping(result.size, mapping)
+			}
+		}
+	}
+	return result
+}
+
+func mergeConfirmedProbeMapping(current, incoming confirmedProbeMapping) confirmedProbeMapping {
+	if current.invalid {
+		return current
+	}
+	if current.value == "" {
+		return incoming
+	}
+	if current.value != incoming.value {
+		return confirmedProbeMapping{invalid: true}
+	}
+	return current
+}
+
+func currentMappedCandidate(mapped string, candidates []string) (string, bool) {
+	mapped = strings.TrimSpace(mapped)
+	if mapped == "" {
+		return "", false
+	}
+	matches := make([]string, 0, 1)
+	seen := map[string]bool{}
+	for _, candidate := range candidates {
+		candidate = strings.TrimSpace(candidate)
+		if candidate == "" || seen[candidate] || aimatching.Normalize(candidate) != aimatching.Normalize(mapped) {
+			continue
+		}
+		seen[candidate] = true
+		matches = append(matches, candidate)
+	}
+	if len(matches) != 1 {
+		return "", false
+	}
+	return matches[0], true
+}
+
+func probeSourceSummary(roleSources map[string]string) string {
+	if containsRoleSource(roleSources, "manual_mapping") {
+		return "manual_mapping"
+	}
+	if containsRoleSource(roleSources, aimatching.SourceAI) {
+		return aimatching.SourceAI
+	}
+	return aimatching.SourceExact
+}
+
+func containsRoleSource(roleSources map[string]string, target string) bool {
+	for _, source := range roleSources {
+		if source == target {
+			return true
+		}
+	}
+	return false
+}

server/app/goauto/purchase/service.go

@@ -281,9 +281,14 @@ func (s *Service) create(ctx context.Context, req CreateRequest) (models.Purchas
 				currency = shopee.Currency
 			}
 			// Every new SYB purchase must use the candidates observed on the
-			// current PDD page. Persisted mappings remain product-level history,
-			// but they cannot skip this task's read-only probe phase.
+			// current PDD page. Freeze confirmed mappings only as guidance for
+			// validation against that future probe; they never skip the probe.
 			mappedColor, mappedSize, specSource = "", "", "unresolved"
+			guidance, marshalErr := newProbeGuidanceSnapshot(shopee.SpecsJSON, targetColor, targetSize)
+			if marshalErr != nil {
+				return internal(marshalErr)
+			}
+			decisionSnapshot = guidance
 		}
 		candidates, archiveUsable := archiveCandidates(pdd.SpecsJSON, targetColor, targetSize)
 		matchRequest := aimatching.MatchRequest{TargetColor: targetColor, TargetSize: targetSize, Colors: candidates.Colors, Sizes: candidates.Sizes}
@@ -293,7 +298,7 @@ func (s *Service) create(ctx context.Context, req CreateRequest) (models.Purchas
 		} else if req.ExecutionMode == models.PurchaseExecutionModeLive {
 			// The first attempt is always spec_probe for an SYB purchase. The
 			// exact task-level decision is frozen only from that probe result.
-			mappedColor, mappedSize, specSource, decisionSnapshot = "", "", "unresolved", "{}"
+			mappedColor, mappedSize, specSource = "", "", "unresolved"
 		} else if pdd.Status != "active" {
 			mappedColor, mappedSize, specSource = "", "", "unresolved"
 		} else if specSource == "manual_mapping" || specSource == "exact_match" || specSource == "ai_match" {

server/app/goauto/purchase/service_test.go

@@ -31,13 +31,15 @@ type fixture struct {
 }
 
 type liveProbeMatcher struct {
-	result aimatching.MatchResult
-	err    error
-	calls  int
+	result  aimatching.MatchResult
+	err     error
+	calls   int
+	request aimatching.MatchRequest
 }
 
-func (matcher *liveProbeMatcher) Resolve(context.Context, aimatching.MatchRequest) (aimatching.MatchResult, error) {
+func (matcher *liveProbeMatcher) Resolve(_ context.Context, request aimatching.MatchRequest) (aimatching.MatchResult, error) {
 	matcher.calls++
+	matcher.request = request
 	return matcher.result, matcher.err
 }
 
@@ -422,10 +424,109 @@ func TestLiveProbeCallsAIOnlyAfterCandidatesAreReturned(t *testing.T) {
 	}
 }
 
+func TestLiveProbeReusesConfirmedColorAndResolvesCurrentSizeWithoutAI(t *testing.T) {
+	db := testDB(t)
+	f := seed(t, db, liveCaps(), true)
+	if err := db.Model(&models.SYBProduct{}).Where("id = ?", f.syb.ID).Updates(map[string]any{
+		"target_color": "薑黃色",
+		"target_size":  "5XL",
+	}).Error; err != nil {
+		t.Fatal(err)
+	}
+	specs := []shopeeproduct.SpecDimension{
+		{Name: "颜色", Role: shopeeproduct.RoleColor, Values: []shopeeproduct.SpecValue{{Name: "薑黃色", Source: shopeeproduct.ValueSourceImport, Mapping: &shopeeproduct.Mapping{PDDValue: "黄色", Source: shopeeproduct.MappingSourceManual, Status: shopeeproduct.MappingStatusConfirmed}}}},
+		{Name: "尺码", Role: shopeeproduct.RoleSize, Values: []shopeeproduct.SpecValue{{Name: "5XL", Source: shopeeproduct.ValueSourceImport, Mapping: &shopeeproduct.Mapping{PDDValue: "XXXXXL", Source: shopeeproduct.MappingSourceAIMatch, Status: shopeeproduct.MappingStatusConfirmed, Reason: "历史档案原文"}}}},
+	}
+	raw, _ := json.Marshal(specs)
+	if err := db.Model(&models.ShopeeProduct{}).Where("id = ?", f.shopee.ID).Update("specs_json", string(raw)).Error; err != nil {
+		t.Fatal(err)
+	}
+	matcher := &liveProbeMatcher{err: errors.New("AI should not be called")}
+	s := testService(db)
+	s.Matcher = matcher
+	task, err := createLive(t, s, f)
+	if err != nil || task.MappedColorSnapshot != "" || task.MappedSizeSnapshot != "" {
+		t.Fatalf("live task skipped mandatory probe: %+v err=%v", task, err)
+	}
+	if err = db.Model(&models.ShopeeProduct{}).Where("id = ?", f.shopee.ID).Update("specs_json", `[]`).Error; err != nil {
+		t.Fatal(err)
+	}
+	if _, err = s.Claim(context.Background(), task.ID, ActionRequest{RequestID: uuid.NewString()}, f.token); err != nil {
+		t.Fatal(err)
+	}
+	first, err := s.Start(context.Background(), task.ID, ActionRequest{RequestID: uuid.NewString()}, f.token)
+	if err != nil {
+		t.Fatal(err)
+	}
+	probe := ResultRequest{RequestID: uuid.NewString(), TaskAttemptID: first.TaskAttemptID, ResultType: "spec_probe_completed", ProbedSpecs: []byte(`{"dimensions":[{"key":"color","values":["白色","黄色","黑色"]},{"key":"size","values":["4XL","5XL"]}]}`)}
+	resolved, err := s.SubmitResult(context.Background(), task.ID, probe, f.token)
+	if err != nil || matcher.calls != 0 || resolved.Status != models.PurchaseTaskStatusPending {
+		t.Fatalf("confirmed mapping resolution failed: %+v calls=%d err=%v", resolved, matcher.calls, err)
+	}
+	if resolved.MappedColor != "黄色" || resolved.MappedSize != "5XL" {
+		t.Fatalf("task did not freeze current probe labels: %+v", resolved)
+	}
+	var saved models.PurchaseTask
+	if err = db.First(&saved, task.ID).Error; err != nil {
+		t.Fatal(err)
+	}
+	var decision struct {
+		RoleSources map[string]string `json:"roleSources"`
+	}
+	if err = json.Unmarshal([]byte(saved.SpecDecisionSnapshot), &decision); err != nil {
+		t.Fatal(err)
+	}
+	if saved.SpecSource != "manual_mapping" || decision.RoleSources[shopeeproduct.RoleColor] != "manual_mapping" || decision.RoleSources[shopeeproduct.RoleSize] != aimatching.SourceExact {
+		t.Fatalf("mixed role sources were not audited: task=%+v decision=%+v", saved, decision)
+	}
+}
+
+func TestLiveProbeCallsAIOnlyForRoleWithoutCurrentConfirmedMapping(t *testing.T) {
+	db := testDB(t)
+	f := seed(t, db, liveCaps(), true)
+	if err := db.Model(&models.SYBProduct{}).Where("id = ?", f.syb.ID).Update("target_color", "薑黃色").Error; err != nil {
+		t.Fatal(err)
+	}
+	specs := []shopeeproduct.SpecDimension{
+		{Name: "颜色", Role: shopeeproduct.RoleColor, Values: []shopeeproduct.SpecValue{{Name: "薑黃色", Source: shopeeproduct.ValueSourceImport, Mapping: &shopeeproduct.Mapping{PDDValue: "旧黄色", Source: shopeeproduct.MappingSourceManual, Status: shopeeproduct.MappingStatusConfirmed}}}},
+		{Name: "尺码", Role: shopeeproduct.RoleSize, Values: []shopeeproduct.SpecValue{{Name: "XL", Source: shopeeproduct.ValueSourceImport, Mapping: &shopeeproduct.Mapping{PDDValue: "XL", Source: shopeeproduct.MappingSourceManual, Status: shopeeproduct.MappingStatusConfirmed}}}},
+	}
+	raw, _ := json.Marshal(specs)
+	if err := db.Model(&models.ShopeeProduct{}).Where("id = ?", f.shopee.ID).Update("specs_json", string(raw)).Error; err != nil {
+		t.Fatal(err)
+	}
+	aiRequest := aimatching.MatchRequest{TargetColor: "薑黃色", Colors: []string{"黄色"}}
+	matcher := &liveProbeMatcher{result: aimatching.RecordedMatch(aiRequest, aimatching.SourceAI, "黄色", "", "当前颜色候选匹配")}
+	s := testService(db)
+	s.Matcher = matcher
+	task, err := createLive(t, s, f)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err = s.Claim(context.Background(), task.ID, ActionRequest{RequestID: uuid.NewString()}, f.token); err != nil {
+		t.Fatal(err)
+	}
+	first, err := s.Start(context.Background(), task.ID, ActionRequest{RequestID: uuid.NewString()}, f.token)
+	if err != nil {
+		t.Fatal(err)
+	}
+	probe := ResultRequest{RequestID: uuid.NewString(), TaskAttemptID: first.TaskAttemptID, ResultType: "spec_probe_completed", ProbedSpecs: []byte(`{"dimensions":[{"key":"color","values":["黄色"]},{"key":"size","values":["XL"]}]}`)}
+	resolved, err := s.SubmitResult(context.Background(), task.ID, probe, f.token)
+	if err != nil || matcher.calls != 1 || resolved.MappedColor != "黄色" || resolved.MappedSize != "XL" {
+		t.Fatalf("partial AI resolution failed: %+v request=%+v err=%v", resolved, matcher.request, err)
+	}
+	if matcher.request.TargetColor != "薑黃色" || matcher.request.TargetSize != "" || len(matcher.request.Colors) != 1 || len(matcher.request.Sizes) != 0 {
+		t.Fatalf("resolved size was unnecessarily sent to AI: %+v", matcher.request)
+	}
+}
+
 func TestLiveProbeRejectsMatcherValueOutsideCurrentCandidates(t *testing.T) {
 	db := testDB(t)
 	f := seed(t, db, liveCaps(), false)
-	request := aimatching.MatchRequest{TargetColor: "黑色", TargetSize: "XL", Colors: []string{"黑色"}, Sizes: []string{"XL"}}
+	if err := db.Model(&models.SYBProduct{}).Where("id = ?", f.syb.ID).Update("target_color", "象牙黑").Error; err != nil {
+		t.Fatal(err)
+	}
+	request := aimatching.MatchRequest{TargetColor: "象牙黑", Colors: []string{"黑色"}}
 	matcher := &liveProbeMatcher{result: aimatching.RecordedMatch(request, aimatching.SourceAI, "候选外颜色", "XL", "无效返回")}
 	s := testService(db)
 	s.Matcher = matcher
@@ -449,6 +550,42 @@ func TestLiveProbeRejectsMatcherValueOutsideCurrentCandidates(t *testing.T) {
 	if err = db.First(&saved, task.ID).Error; err != nil || saved.ErrorCode == nil || *saved.ErrorCode != "PURCHASE_SPEC_NOT_MATCHED" {
 		t.Fatalf("outside-candidate failure was not persisted: %+v err=%v", saved, err)
 	}
+	if saved.ErrorMessage == nil || *saved.ErrorMessage != "已采集到当前规格，但未能确定颜色或尺码映射" {
+		t.Fatalf("outside-candidate failure reason was not preserved: %+v", saved)
+	}
+}
+
+func TestLiveProbeUsesAccurateMessageWhenCompleteCandidatesCannotBeMatched(t *testing.T) {
+	db := testDB(t)
+	f := seed(t, db, liveCaps(), false)
+	if err := db.Model(&models.SYBProduct{}).Where("id = ?", f.syb.ID).Update("target_color", "薑黃色").Error; err != nil {
+		t.Fatal(err)
+	}
+	s := testService(db)
+	s.Matcher = &liveProbeMatcher{err: &aimatching.Error{Code: aimatching.CodeNoMatch, Message: "no match"}}
+	task, err := createLive(t, s, f)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err = s.Claim(context.Background(), task.ID, ActionRequest{RequestID: uuid.NewString()}, f.token); err != nil {
+		t.Fatal(err)
+	}
+	first, err := s.Start(context.Background(), task.ID, ActionRequest{RequestID: uuid.NewString()}, f.token)
+	if err != nil {
+		t.Fatal(err)
+	}
+	probe := ResultRequest{RequestID: uuid.NewString(), TaskAttemptID: first.TaskAttemptID, ResultType: "spec_probe_completed", ProbedSpecs: []byte(`{"dimensions":[{"key":"color","values":["黄色"]},{"key":"size","values":["XL"]}]}`)}
+	resolved, err := s.SubmitResult(context.Background(), task.ID, probe, f.token)
+	if err != nil || resolved.Status != models.PurchaseTaskStatusFailed {
+		t.Fatalf("no-match probe did not converge: %+v err=%v", resolved, err)
+	}
+	var saved models.PurchaseTask
+	if err = db.First(&saved, task.ID).Error; err != nil {
+		t.Fatal(err)
+	}
+	if saved.ErrorMessage == nil || *saved.ErrorMessage != "已采集到当前规格，但未能确定颜色或尺码映射" {
+		t.Fatalf("complete candidates used misleading failure reason: %+v", saved)
+	}
 }
 
 func TestSecondSpecProbeFailsClosedWithoutClearingDecision(t *testing.T) {
@@ -625,6 +762,42 @@ func TestCreateDispatchesProbeInsteadOfExternalArchiveMatching(t *testing.T) {
 	}
 }
 
+func TestNextReturnsAssignedProbeWaitingTaskBeforeOtherWork(t *testing.T) {
+	db := testDB(t)
+	f := seed(t, db, liveCaps(), true)
+	if err := db.Model(&models.PDDProduct{}).Where("id = ?", f.pdd.ID).Update("specs_json", `[{"name":"颜色","role":"color","values":[{"name":"黑色","selectable":true,"priceCent":1200}]},{"name":"尺码","role":"size","values":[{"name":"XL","selectable":true}]}]`).Error; err != nil {
+		t.Fatal(err)
+	}
+	service := testService(db)
+	request := StockCreateRequest{
+		RequestID: uuid.NewString(), ExecutionMode: models.PurchaseExecutionModeLive,
+		PDDProductID: f.pdd.ID, DeviceID: &f.device.ID, Color: "黑色", Size: "XL",
+		Quantity: 1, MinUnitPriceCent: 900, MaxUnitPriceCent: 1500,
+	}
+	waiting, _, err := service.CreateStock(context.Background(), request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	request.RequestID = uuid.NewString()
+	other, _, err := service.CreateStock(context.Background(), request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err = db.Session(&gorm.Session{SkipHooks: true}).Model(&models.PurchaseTask{}).Where("id = ?", waiting.ID).Updates(map[string]any{
+		"status": models.PurchaseTaskStatusSpecProbePending, "mapped_color_snapshot": "", "mapped_size_snapshot": "",
+	}).Error; err != nil {
+		t.Fatal(err)
+	}
+
+	next, err := service.Next(context.Background(), f.token)
+	if err != nil || next == nil || next.TaskID != waiting.ID || next.Status != models.PurchaseTaskStatusSpecProbePending {
+		t.Fatalf("waiting probe task not reserved: next=%+v other=%d err=%v", next, other.ID, err)
+	}
+	if _, err = service.Claim(context.Background(), other.ID, ActionRequest{RequestID: uuid.NewString()}, f.token); code(err) != CodeDeviceBusy {
+		t.Fatalf("other purchase claimed while probe waits: %v", err)
+	}
+}
+
 func TestOrderUnknownIsNotAutomaticallyRedispatched(t *testing.T) {
 	db := testDB(t)
 	f := seed(t, db, liveCaps(), true)

server/app/goauto/sybimport/pagination_overlap_test.go

@@ -0,0 +1,101 @@
+package sybimport
+
+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)
+	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 {
+			return []int64{1001, 1002}
+		}
+		return nil
+	}
+	db := newSyncTestDB(t)
+	report, err := Sync(context.Background(), db, newSyncClient(t, f), SyncConfig{PageSize: 2, MaxMatches: 100}, "2026-08-28", "2026-08-29")
+	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"} {
+		if !strings.Contains(err.Error(), token) {
+			t.Fatalf("missing %s in %v", token, err)
+		}
+	}
+	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 {
+		t.Fatalf("unexpected retry/import boundary: pages=%d details=%d orders=%d", len(f.listCalls), f.detailCalls, report.OrderCount)
+	}
+	var count int64
+	if e := db.Table("syb_product").Count(&count).Error; e != nil || count != 2 {
+		t.Fatalf("yesterday not preserved: count=%d err=%v", count, e)
+	}
+}
+
+func TestPaginationHardErrorsDoNotUseOverlapRecovery(t *testing.T) {
+	freezePaginationToday(t)
+	for _, tc := range []struct {
+		name, date, message string
+		page                int
+		ids                 []int64
+		calls               int
+	}{
+		{"same page", "2026-08-29", "同页重复", 0, []int64{1000, 1000}, 1},
+		{"mixed overlap and same page", "2026-08-29", "同页重复", 2, []int64{1001, 1001}, 2},
+		{"overlap and invalid ID", "2026-08-29", "非法 id", 2, []int64{1001, 0}, 2},
+		{"historical overlap", "2026-08-28", "跨页重复", 2, []int64{1001, 1002}, 2},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			f := &fakeSYB{perDay: map[string]int{tc.date: 4}}
+			f.pageIDs = func(_ string, start, _ int) []int64 {
+				if start == tc.page {
+					return tc.ids
+				}
+				return nil
+			}
+			rows, err := loadDailyListWithRecovery(context.Background(), newSyncClient(t, f), tc.date, 2, 4, 100)
+			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/sync.go

@@ -358,7 +358,7 @@ func loadDailyListWithRecovery(ctx context.Context, client *sybclient.Client, da
 		}
 		var drift *snapshotDriftError
 		if !errors.As(err, &drift) {
-			return nil, err
+			return nil, fmt.Errorf("今天第 %d/%d 次拉取失败: %w", attempt, maxTodaySnapshotAttempts, err)
 		}
 		last = drift
 	}
@@ -370,7 +370,8 @@ func loadDailyListWithRecovery(ctx context.Context, client *sybclient.Client, da
 
 func loadDailyList(ctx context.Context, client *sybclient.Client, date string, pageSize, expectedTotal int) ([]sybclient.StockRow, error) {
 	rows := make([]sybclient.StockRow, 0, expectedTotal)
-	seen := make(map[int64]struct{}, expectedTotal)
+	type position struct{ page, row int }
+	seen := make(map[int64]position, expectedTotal)
 
 	for start := 0; start < expectedTotal; start += pageSize {
 		pageIndex := start/pageSize + 1
@@ -386,14 +387,27 @@ func loadDailyList(ctx context.Context, client *sybclient.Client, date string, p
 		if pageCount != len(page) {
 			return nil, fmt.Errorf("%s 货运单列表第 %d 页响应条数不自洽：total=%d，list=%d", date, pageIndex, pageCount, len(page))
 		}
-		for _, row := range page {
+		// Validate the whole page first: a same-page duplicate must not be
+		// hidden behind an earlier, recoverable cross-page overlap.
+		pageSeen := make(map[int64]int, len(page))
+		for index, row := range page {
 			if row.ID <= 0 {
 				return nil, fmt.Errorf("%s 货运单列表包含非法 id=%d", date, row.ID)
 			}
-			if _, duplicate := seen[row.ID]; duplicate {
-				return nil, fmt.Errorf("%s 货运单列表重复返回 id=%d", date, row.ID)
+			if firstRow, duplicate := pageSeen[row.ID]; duplicate {
+				return nil, fmt.Errorf("%s 货运单列表同页重复 [firstPage=%d,firstRow=%d,page=%d,row=%d,start=%d,pageSize=%d,expectedTotal=%d,unique=%d]",
+					date, pageIndex, firstRow, pageIndex, index+1, start, pageSize, expectedTotal, len(rows))
 			}
-			seen[row.ID] = struct{}{}
+			pageSeen[row.ID] = index + 1
+		}
+		for index, row := range page {
+			if first, duplicate := seen[row.ID]; duplicate {
+				// No rows/valid flag: overlapping pages are never eligible for
+				// the existing final-attempt degraded save, even after deduping.
+				return nil, &snapshotDriftError{message: fmt.Sprintf("%s 货运单列表跨页重复 [firstPage=%d,firstRow=%d,page=%d,row=%d,start=%d,pageSize=%d,expectedTotal=%d,unique=%d]",
+					date, first.page, first.row, pageIndex, index+1, start, pageSize, expectedTotal, len(rows))}
+			}
+			seen[row.ID] = position{page: pageIndex, row: index + 1}
 			rows = append(rows, row)
 		}
 		if len(page) != expectedPageCount {

server/app/goauto/sybimport/sync_test.go

@@ -60,6 +60,9 @@ type fakeSYB struct {
 	totalOverride    map[int]int
 	shortPageAtIndex int
 	detailDropID     int64
+	listCalls        []string
+	pageIDs          func(date string, start, call int) []int64
+	detailCalls      int
 	// shopNames 按货运单序号轮换；留空表示全部用「测试店铺」。
 	shopNames []string
 	// detailShopName 非空时，明细响应里的 shopName 用它覆盖，
@@ -96,6 +99,7 @@ func (f *fakeSYB) server(t *testing.T) *httptest.Server {
 		start := int(body["start"].(float64))
 		pageSize := int(body["length"].(float64))
 		total := f.perDay[date]
+		f.listCalls = append(f.listCalls, fmt.Sprintf("%s:%d", date, start))
 
 		rows := []map[string]any{}
 		for i := start; i < total && len(rows) < pageSize; i++ {
@@ -108,9 +112,18 @@ func (f *fakeSYB) server(t *testing.T) *httptest.Server {
 		if f.shortPageAtIndex > 0 && start/pageSize+1 == f.shortPageAtIndex && len(rows) > 0 {
 			rows = rows[:len(rows)-1]
 		}
+		if f.pageIDs != nil {
+			if ids := f.pageIDs(date, start, len(f.listCalls)); ids != nil {
+				rows = nil
+				for _, id := range ids {
+					rows = append(rows, map[string]any{"id": id, "code": "TEST", "shopName": f.shopFor(0)})
+				}
+			}
+		}
 		writeEnvelope(w, map[string]any{"list": rows, "total": len(rows)})
 	})
 	mux.HandleFunc("/am/stock/detail/listByStock", func(w http.ResponseWriter, r *http.Request) {
+		f.detailCalls++
 		var body struct {
 			IDs []int64 `json:"ids"`
 		}

server/app/goauto/task/current_page.go

@@ -182,9 +182,9 @@ func ensureDeviceIdleForCurrentPage(tx *gorm.DB, deviceID uint64, now time.Time)
 		return serviceError(CodeDeviceBusy, "设备正在执行任务，请稍后再试")
 	}
 	if err := tx.Model(&models.PurchaseTask{}).
-		Where("device_id = ? AND (status IN ? OR (status IN ? AND lease_expires_at > ?))", deviceID,
-			[]string{models.PurchaseTaskStatusRunning, models.PurchaseTaskStatusOrderSubmitStarted},
-			[]string{models.PurchaseTaskStatusPending, models.PurchaseTaskStatusSpecProbePending}, now).
+		Where("device_id = ? AND (status IN ? OR (status = ? AND lease_expires_at > ?))", deviceID,
+			[]string{models.PurchaseTaskStatusRunning, models.PurchaseTaskStatusOrderSubmitStarted, models.PurchaseTaskStatusSpecProbePending},
+			models.PurchaseTaskStatusPending, now).
 		Count(&busy).Error; err != nil {
 		return internalError(err)
 	}

server/app/goauto/task/lifecycle_service.go

@@ -246,9 +246,9 @@ func ensureDeviceIdleForReset(tx *gorm.DB, deviceID, taskID uint64, now time.Tim
 		return serviceError(CodeDeviceBusy, "设备正在执行其他任务")
 	}
 	if err := tx.Model(&models.PurchaseTask{}).
-		Where("device_id = ? AND (status IN ? OR (status IN ? AND lease_expires_at > ?))", deviceID,
-			[]string{models.PurchaseTaskStatusRunning, models.PurchaseTaskStatusOrderSubmitStarted},
-			[]string{models.PurchaseTaskStatusPending, models.PurchaseTaskStatusSpecProbePending}, now).
+		Where("device_id = ? AND (status IN ? OR (status = ? AND lease_expires_at > ?))", deviceID,
+			[]string{models.PurchaseTaskStatusRunning, models.PurchaseTaskStatusOrderSubmitStarted, models.PurchaseTaskStatusSpecProbePending},
+			models.PurchaseTaskStatusPending, now).
 		Count(&busy).Error; err != nil {
 		return internalError(err)
 	}

web/src/store/getters.js

@@ -5,6 +5,7 @@ const getters = {
   visitedViews: state => state.tagsView.visitedViews,
   cachedViews: state => state.tagsView.cachedViews,
   token: state => state.user.token,
+  userId: state => state.user.userId,
   avatar: state => state.user.avatar,
   name: state => state.user.name,
   introduction: state => state.user.introduction,

web/src/store/modules/user.js

@@ -5,6 +5,7 @@ import storage from '@/utils/storage'
 
 const state = {
   token: getToken(),
+  userId: null,
   name: '',
   avatar: '',
   introduction: '',
@@ -16,6 +17,10 @@ const state = {
 const mutations = {
   SET_TOKEN: (state, token) => {
     state.token = token
+    if (!token) state.userId = null
+  },
+  SET_USER_ID: (state, userId) => {
+    state.userId = Number(userId) || null
   },
   SET_INTRODUCTION: (state, introduction) => {
     state.introduction = introduction
@@ -63,13 +68,14 @@ const actions = {
           return resolve()
         }
 
-        const { roles, name, avatar, introduction, permissions } = response.data
+        const { roles, name, avatar, introduction, permissions, userId } = response.data
 
         // roles must be a non-empty array
         if (!roles || roles.length <= 0) {
           return reject('getInfo: roles must be a non-null array!')
         }
         commit('SET_PERMISSIONS', permissions)
+        commit('SET_USER_ID', userId)
         commit('SET_ROLES', roles)
         commit('SET_NAME', name)
         commit('SET_AVATAR', avatar)

web/src/utils/purchase-device-preference.js

@@ -0,0 +1,29 @@
+function preferenceKey(userId) {
+  const id = Number(userId)
+  if (!Number.isSafeInteger(id) || id <= 0) return null
+  return `goauto:purchase-device:${encodeURIComponent(process.env.VUE_APP_BASE_API || '/')}:user:${id}`
+}
+
+export function readPurchaseDevice(userId) {
+  try {
+    const key = preferenceKey(userId)
+    if (!key) return null
+    const id = JSON.parse(localStorage.getItem(key) || 'null')
+    return Number.isSafeInteger(id) && id > 0 ? id : null
+  } catch {
+    return null
+  }
+}
+
+export function rememberPurchaseDevice(userId, deviceId) {
+  try {
+    const key = preferenceKey(userId)
+    if (!key) return false
+    const id = deviceId == null || deviceId === '' ? null : Number(deviceId)
+    if (id !== null && (!Number.isSafeInteger(id) || id <= 0)) return false
+    localStorage.setItem(key, JSON.stringify(id))
+    return true
+  } catch {
+    return false
+  }
+}

web/src/views/goauto/syb-products/index.vue

@@ -37,8 +37,16 @@
           <el-alert title="每条 SYB 商品分别创建一个采购任务和一个待付款 PDD 订单；系统永不支付。创建前服务端会再次逐条检查。" type="warning" :closable="false" show-icon class="notice" />
           <div class="purchase-summary" aria-live="polite"><span>已选择 <strong>{{ purchaseDialog.selectedCount }}</strong> 条 SYB 明细</span><span class="success-text">其中 {{ purchaseDialog.eligibleCount }} 条适用于采购</span><span v-if="purchaseDialog.skippedCount" class="danger-text">预检后另有 {{ purchaseDialog.skippedCount }} 条不可创建</span></div>
           <el-form label-width="110px" class="purchase-settings">
-            <el-form-item label="Android 设备"><el-select v-model="purchaseDialog.deviceId" clearable placeholder="不指定，由空闲设备领取" style="width:360px" @change="refreshPurchasePreview"><el-option v-for="device in purchaseDevices" :key="device.id" :label="`${device.name} · ${device.model}`" :value="device.id" /></el-select><span class="field-help">默认人工指定；留空时由符合能力的空闲设备领取。</span></el-form-item>
+            <el-form-item label="Android 设备">
+              <el-select v-model="purchaseDialog.deviceId" clearable placeholder="不指定，由空闲设备领取" style="width:360px" :disabled="purchaseDialog.saving" @change="changePurchaseDevice">
+                <el-option v-if="purchaseDeviceUnavailable" :value="purchaseDialog.deviceId" label="上次选择的设备（当前不可用）" disabled />
+                <el-option v-for="device in purchaseDevices" :key="device.id" :label="`${device.name} · ${device.model}`" :value="device.id" />
+              </el-select>
+              <span v-if="purchaseDeviceUnavailable" class="field-help danger-text" role="alert">上次选择的设备当前不可用，请重新选择，或清空后由空闲设备领取。</span>
+              <span v-else class="field-help">记住当前用户在此浏览器的选择；留空时由符合能力的空闲设备领取。</span>
+            </el-form-item>
           </el-form>
+          <el-alert v-if="purchaseDialog.previewError" :title="purchaseDialog.previewError" type="error" :closable="false" show-icon class="notice"><el-button link type="primary" @click="openPurchaseBatch">重试</el-button></el-alert>
           <el-table :data="purchaseDialog.items" border size="small" max-height="380" empty-text="没有可创建的商品">
             <el-table-column label="SYB 商品" min-width="150"><template #default="{ row }"><strong>{{ row.orderCode || `ID ${row.sybProductId}` }}</strong><div class="muted">{{ row.shopeeItemId || '未关联蝦皮商品' }}</div></template></el-table-column>
             <el-table-column label="商品" min-width="210"><template #default="{ row }"><div class="ellipsis">{{ row.productTitle || '—' }}</div><div class="muted">PDD {{ row.pddGoodsId || '未关联' }}</div></template></el-table-column>
@@ -47,7 +55,7 @@
           </el-table>
           <p class="muted">如果某条商品在确认后状态发生变化，只跳过该条，不撤销其他成功任务。</p>
         </div>
-        <template #footer><el-button :disabled="purchaseDialog.saving" @click="purchaseDialog.open = false">返回列表</el-button><el-button type="primary" :loading="purchaseDialog.saving" :disabled="purchaseDialog.loading || purchaseDialog.eligibleCount === 0" @click="submitPurchaseBatch">创建 {{ purchaseDialog.eligibleCount }} 个采购任务</el-button></template>
+        <template #footer><el-button :disabled="purchaseDialog.saving" @click="purchaseDialog.open = false">返回列表</el-button><el-button type="primary" :loading="purchaseDialog.saving" :disabled="purchaseDialog.loading || purchaseDeviceUnavailable || !!purchaseDialog.previewError || purchaseDialog.eligibleCount === 0" @click="submitPurchaseBatch">创建 {{ purchaseDialog.eligibleCount }} 个采购任务</el-button></template>
       </el-dialog>
 
       <!-- 批量创建采购任务结果 -->
@@ -171,6 +179,7 @@ import { createPurchaseTasksBatch, matchPurchaseSpecsBatch, previewPurchaseTasks
 import { batchCreateCollectionTasks } from '@/api/goauto/collection-tasks'
 import { listCollectionRules } from '@/api/goauto/collection-rules'
 import { createRequestId } from '@/utils/request-id'
+import { readPurchaseDevice, rememberPurchaseDevice } from '@/utils/purchase-device-preference'
 import ShopeeProductDetailDrawer from '../shopee-products/ShopeeProductDetailDrawer.vue'
 import PddProductDetailDrawer from '../pdd-products/PddProductDetailDrawer.vue'
 
@@ -183,8 +192,9 @@ export default {
       loading: false, products: [], selectedProducts: [], total: 0,
       purchaseReadiness: {}, purchaseReadinessLoading: false, specMatchLoading: false, loadGeneration: 0,
       purchaseDevices: [],
+      purchasePreviewGeneration: 0,
       shopOptions: [], shopOptionsLoaded: false, shopOptionsPromise: null,
-      purchaseDialog: { open: false, loading: false, saving: false, ids: [], selectedCount: 0, deviceId: null, items: [], eligibleCount: 0, skippedCount: 0 },
+      purchaseDialog: { open: false, loading: false, saving: false, ids: [], selectedCount: 0, deviceId: null, items: [], eligibleCount: 0, skippedCount: 0, previewError: '' },
       purchaseResult: { open: false, items: [], createdCount: 0, failedCount: 0 },
       specMatchResult: { open: false, items: [], selectedIDs: [], autoConfirmedCount: 0, pendingCount: 0, failedCount: 0, skippedCount: 0 },
       collectionBatch: this.emptyCollectionBatch(),
@@ -198,6 +208,7 @@ export default {
     }
   },
   computed: {
+    purchaseDeviceUnavailable() { return !!this.purchaseDialog.deviceId && !this.purchaseDevices.some(device => device.id === this.purchaseDialog.deviceId) },
     canPurchase() { const roles = this.$store.getters.roles || []; return roles.includes('admin') || roles.includes('purchaser') },
     processStageOptions() { return [{ value: 'manual_action', label: '待人工处理' }, { value: 'pdd_unlinked', label: '未关联 PDD' }, { value: 'pdd_pending', label: 'PDD 待采集' }, { value: 'pdd_collecting', label: 'PDD 采集中' }, { value: 'pdd_collection_failed', label: 'PDD 采集失败' }, { value: 'color_mapping', label: '规格待匹配' }, { value: 'purchase_ready', label: '可创建采购' }, { value: 'task_created', label: '已创建任务' }, { value: 'purchase_succeeded', label: '采购成功' }, { value: 'order_review', label: '待人工核对' }] },
     aiMatchCandidates() { return this.selectedProducts.filter(row => this.purchaseReady(row).aiMatchEligible === true) },
@@ -353,23 +364,46 @@ export default {
       const candidates = this.purchaseCandidates
       if (!candidates.length) return
       const ids = candidates.map(item => item.id)
-      this.purchaseDialog = { open: true, loading: true, saving: false, ids, selectedCount: this.selectedProducts.length, deviceId: null, items: [], eligibleCount: 0, skippedCount: 0 }
+      this.purchaseDevices = []
+      this.purchaseDialog = { open: true, loading: true, saving: false, ids, selectedCount: this.selectedProducts.length, deviceId: readPurchaseDevice(this.$store.getters.userId), items: [], eligibleCount: 0, skippedCount: 0, previewError: '' }
+      const dialog = this.purchaseDialog
       try {
-        const [preview, devices] = await Promise.all([
-          previewPurchaseTasks({ sybProductIds: ids }),
-          listDevices({ page: 1, pageSize: 100, status: 'online' })
-        ])
-        this.applyPurchasePreview(preview.data)
+        const devices = await listDevices({ page: 1, pageSize: 100, status: 'online' })
+        if (this.purchaseDialog !== dialog || !dialog.open) return
         const required = ['purchase.live.v1', 'purchase.address-update.v1', 'purchase.order-create.v1', 'purchase.spec-probe.v1']
         this.purchaseDevices = devices.data.items.filter(device => device.selectable && required.every(capability => (device.capabilities || []).includes(capability)))
-      } finally { this.purchaseDialog.loading = false }
+        await this.refreshPurchasePreview()
+      } catch {
+        if (this.purchaseDialog === dialog) {
+          dialog.previewError = '设备列表加载失败，请重试。'
+          dialog.loading = false
+        }
+      }
     },
     applyPurchasePreview(data) { this.purchaseDialog.items = data.items; this.purchaseDialog.eligibleCount = data.eligibleCount; this.purchaseDialog.skippedCount = data.skippedCount },
+    changePurchaseDevice() {
+      if (!rememberPurchaseDevice(this.$store.getters.userId, this.purchaseDialog.deviceId)) ElMessage.warning('本次选择已生效，但未能保存设备偏好；下次可能需要重新选择。')
+      return this.refreshPurchasePreview()
+    },
     async refreshPurchasePreview() {
-      this.purchaseDialog.loading = true
-      try { const r = await previewPurchaseTasks({ sybProductIds: this.purchaseDialog.ids, deviceId: this.purchaseDialog.deviceId || undefined }); this.applyPurchasePreview(r.data) } finally { this.purchaseDialog.loading = false }
+      const dialog = this.purchaseDialog
+      const generation = ++this.purchasePreviewGeneration
+      dialog.eligibleCount = 0
+      dialog.items = []
+      dialog.previewError = ''
+      if (this.purchaseDeviceUnavailable) { dialog.loading = false; return }
+      dialog.loading = true
+      try {
+        const r = await previewPurchaseTasks({ sybProductIds: dialog.ids, deviceId: dialog.deviceId || undefined })
+        if (this.purchaseDialog === dialog && generation === this.purchasePreviewGeneration) this.applyPurchasePreview(r.data)
+      } catch {
+        if (this.purchaseDialog === dialog && generation === this.purchasePreviewGeneration) dialog.previewError = '采购预检失败，请重试。'
+      } finally {
+        if (this.purchaseDialog === dialog && generation === this.purchasePreviewGeneration) dialog.loading = false
+      }
     },
     async submitPurchaseBatch() {
+      if (this.purchaseDialog.loading || this.purchaseDialog.saving || this.purchaseDeviceUnavailable || this.purchaseDialog.previewError || !this.purchaseDialog.eligibleCount) return
       this.purchaseDialog.saving = true
       try {
         const r = await createPurchaseTasksBatch({ requestId: createRequestId(), sybProductIds: this.purchaseDialog.ids, deviceId: this.purchaseDialog.deviceId || undefined })

web/tests/e2e/purchase-device-preference.spec.ts

@@ -0,0 +1,132 @@
+import { expect, test } from '@playwright/test'
+
+const required = ['purchase.live.v1', 'purchase.address-update.v1', 'purchase.order-create.v1', 'purchase.spec-probe.v1']
+const routes = [{ path: '/workbench', component: 'Layout', menuName: 'Workbench', title: '工作台', visible: '0', children: [
+  { path: '/syb-products', component: '/goauto/syb-products/index', menuName: 'GoAutoSybProducts', title: 'SYB 商品', visible: '0' }
+] }]
+
+async function mock(page: any) {
+  const state = { userId: 1, available: true, previewFailed: false, previews: [] as any[], created: [] as any[] }
+  await page.context().addCookies([{ name: 'Admin-Token', value: 'mock-token', domain: 'localhost', path: '/' }])
+  await page.route('**/api/**', async (route: any) => {
+    const url = new URL(route.request().url())
+    const ok = (data: any) => route.fulfill({ json: { code: 200, data } })
+    if (url.pathname.startsWith('/src/api/')) return route.continue()
+    if (url.pathname.endsWith('/api/v1/getinfo')) return ok({ userId: state.userId, roles: ['admin'], name: '同名测试用户', avatar: '', introduction: '', permissions: [] })
+    if (url.pathname.endsWith('/api/v1/menurole')) return ok(routes)
+    if (url.pathname.endsWith('/api/admin/v1/syb-products')) return ok({ items: [
+      { id: 1, orderCode: 'TEST-1', shopeeItemId: '1001', shopeeProductId: 2, productTitle: '测试商品', targetColor: '黑色', targetSize: 'XL', quantity: 1, parseStatus: 'success' }
+    ], total: 1, page: 1, pageSize: 20 })
+    if (url.pathname.endsWith('/api/admin/v1/devices')) return ok({ items: [
+      { id: 10, name: '测试设备A', model: 'A', selectable: state.available, capabilities: required },
+      { id: 20, name: '测试设备B', model: 'B', selectable: true, capabilities: required }
+    ], total: 2 })
+    if (url.pathname.endsWith('/purchase-tasks/batch-preview')) {
+      const body = route.request().postDataJSON()
+      state.previews.push(body)
+      if (state.previewFailed) return route.fulfill({ status: 500, json: { code: 500, message: '模拟预检失败' } })
+      return ok({ items: [{ sybProductId: 1, eligible: true, processStage: 'purchase_ready', reason: '规格就绪', quantity: 1 }], eligibleCount: 1, skippedCount: 0 })
+    }
+    if (url.pathname.endsWith('/purchase-tasks/batch')) {
+      state.created.push(route.request().postDataJSON())
+      return ok({ items: [], createdCount: 1, failedCount: 0 })
+    }
+    return ok([])
+  })
+  return state
+}
+
+async function open(page: any, reload = false) {
+  if (reload) await page.reload()
+  else await page.goto('/#/syb-products')
+  await expect(page.locator('tbody').getByText('可创建采购', { exact: true })).toBeVisible()
+  await page.locator('.el-table__body-wrapper tbody tr').first().locator('.el-checkbox').click()
+  await page.getByRole('button', { name: /^创建采购\s*1$/ }).click()
+  const dialog = page.getByRole('dialog', { name: '批量创建采购任务' })
+  await expect(dialog).toBeVisible()
+  await expect(dialog.locator('.el-loading-mask')).toBeHidden()
+  return dialog
+}
+
+async function choose(page: any, dialog: any, name: string) {
+  await dialog.locator('.el-select').click()
+  await page.getByRole('option', { name, exact: true }).click()
+  await expect(dialog.locator('.el-loading-mask')).toBeHidden()
+}
+
+test('设备选择跨弹窗和刷新恢复，预检与创建使用同一设备', async ({ page }) => {
+  const state = await mock(page)
+  let dialog = await open(page)
+  await choose(page, dialog, '测试设备A · A')
+  await dialog.getByRole('button', { name: '返回列表' }).click()
+  await page.getByRole('button', { name: /^创建采购\s*1$/ }).click()
+  await expect(dialog.getByText('测试设备A · A', { exact: true })).toBeVisible()
+  await expect.poll(() => state.previews.at(-1)?.deviceId).toBe(10)
+  dialog = await open(page, true)
+  await expect(dialog.getByText('测试设备A · A', { exact: true })).toBeVisible()
+  await dialog.getByRole('button', { name: '创建 1 个采购任务' }).click()
+  await expect.poll(() => state.created.length).toBe(1)
+  expect(state.created[0].deviceId).toBe(10)
+})
+
+test('不可用设备不被静默替换，主动清空后保持不指定', async ({ page }) => {
+  const state = await mock(page)
+  let dialog = await open(page)
+  await choose(page, dialog, '测试设备A · A')
+  state.available = false
+  dialog = await open(page, true)
+  await expect(dialog.getByRole('alert').filter({ hasText: '上次选择的设备当前不可用' })).toBeVisible()
+  await expect(dialog.getByRole('button', { name: /创建 .* 个采购任务/ })).toBeDisabled()
+  await dialog.locator('.el-select').hover()
+  await dialog.locator('.el-select__clear').click()
+  await expect.poll(() => state.previews.at(-1)?.deviceId).toBeUndefined()
+  dialog = await open(page, true)
+  await expect(dialog.getByText('上次选择的设备（当前不可用）', { exact: true })).toHaveCount(0)
+  await expect(dialog.getByText('不指定，由空闲设备领取', { exact: true })).toBeVisible()
+})
+
+test('同名用户偏好按ID隔离，预检失败禁用创建', async ({ page }) => {
+  const state = await mock(page)
+  let dialog = await open(page)
+  await choose(page, dialog, '测试设备A · A')
+  state.userId = 2
+  dialog = await open(page, true)
+  await expect(dialog.getByText('不指定，由空闲设备领取', { exact: true })).toBeVisible()
+  await choose(page, dialog, '测试设备B · B')
+  state.userId = 1
+  dialog = await open(page, true)
+  await expect(dialog.getByText('测试设备A · A', { exact: true })).toBeVisible()
+  state.previewFailed = true
+  await choose(page, dialog, '测试设备B · B')
+  await expect(dialog.getByText('采购预检失败，请重试。', { exact: true })).toBeVisible()
+  await expect(dialog.getByRole('button', { name: /创建 .* 个采购任务/ })).toBeDisabled()
+  expect(state.created).toHaveLength(0)
+})
+
+test('关闭重开后旧预检响应不覆盖新设备结果', async ({ page }) => {
+  await mock(page)
+  const dialog = await open(page)
+  let held = false
+  let finished = false
+  let release: () => void = () => {}
+  const gate = new Promise<void>(resolve => { release = resolve })
+  await page.route('**/purchase-tasks/batch-preview', async route => {
+    if (route.request().postDataJSON().deviceId !== 10 || held) return route.fallback()
+    held = true
+    await gate
+    await route.fulfill({ json: { code: 200, data: { items: [], eligibleCount: 0, skippedCount: 1 } } })
+    finished = true
+  })
+  await dialog.locator('.el-select').click()
+  await page.getByRole('option', { name: '测试设备A · A', exact: true }).click()
+  await expect.poll(() => held).toBe(true)
+  await expect(dialog.getByRole('button', { name: /创建 .* 个采购任务/ })).toBeDisabled()
+  await dialog.getByRole('button', { name: '返回列表' }).click()
+  await page.getByRole('button', { name: /^创建采购\s*1$/ }).click()
+  await expect(dialog.locator('.el-loading-mask')).toBeHidden()
+  await choose(page, dialog, '测试设备B · B')
+  release()
+  await expect.poll(() => finished).toBe(true)
+  await expect(dialog.getByText('测试设备B · B', { exact: true })).toBeVisible()
+  await expect(dialog.getByRole('button', { name: '创建 1 个采购任务' })).toBeEnabled()
+})

web/tests/unit/utils/purchase-device-preference.spec.js

@@ -0,0 +1,32 @@
+import { readPurchaseDevice, rememberPurchaseDevice } from '@/utils/purchase-device-preference'
+
+describe('purchase device preference', () => {
+  beforeEach(() => { localStorage.clear() })
+  afterEach(() => { jest.restoreAllMocks() })
+
+  it('isolates users and remembers an explicit empty selection', () => {
+    expect(rememberPurchaseDevice(1, 10)).toBe(true)
+    expect(rememberPurchaseDevice(2, 20)).toBe(true)
+    expect(readPurchaseDevice(1)).toBe(10)
+    expect(readPurchaseDevice(2)).toBe(20)
+    expect(rememberPurchaseDevice(1, '')).toBe(true)
+    expect(readPurchaseDevice(1)).toBeNull()
+    expect(readPurchaseDevice(2)).toBe(20)
+  })
+
+  it('does not share a fallback key when user identity is missing', () => {
+    expect(rememberPurchaseDevice(null, 10)).toBe(false)
+    expect(readPurchaseDevice(null)).toBeNull()
+    expect(localStorage.length).toBe(0)
+  })
+
+  it('ignores corrupt preferences and tolerates unavailable browser storage', () => {
+    rememberPurchaseDevice(1, 10)
+    localStorage.setItem(localStorage.key(0), '{broken')
+    expect(readPurchaseDevice(1)).toBeNull()
+    jest.spyOn(Storage.prototype, 'getItem').mockImplementation(() => { throw new Error('disabled') })
+    jest.spyOn(Storage.prototype, 'setItem').mockImplementation(() => { throw new Error('disabled') })
+    expect(readPurchaseDevice(1)).toBeNull()
+    expect(rememberPurchaseDevice(1, 10)).toBe(false)
+  })
+})