feat(web): 采集任务页新增设备筛选 (#383)

筛选区在「来源」后新增「设备」下拉（可清空、可搜索，含已停用设备），
查询传 deviceId，重置清空；设备列表加载失败时下拉为空且不影响列表。
批量取消接口不支持设备维度，选择设备筛选时禁用该按钮，避免取消范围超出当前列表。

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NTDbDcwbDw1TSAcE6wfh2F

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

@@ -69,6 +69,9 @@ interface PddCollectorDriver {
         reason = FreshClickReason.UNKNOWN,
     )
     fun swipeSpec(direction: SwipeDirection, anchor: SnapshotNode? = null): Boolean
+    // Why the latest swipeSpec returned false (anchorMissing / anchorAmbiguous
+    // mean the gesture anchor no longer resolves to exactly one node).
+    fun specRowSwipeFailureReason(): String = "unknown"
     fun pullDownSpecPanel(anchor: SnapshotNode): Boolean = swipeSpec(SwipeDirection.DOWN, anchor)
     fun pullDownGoodsPage(): Boolean
     fun back(): Boolean
@@ -169,6 +172,8 @@ data class ParsedPddScreen(
     val requiredEvidenceSameContainer: Boolean = false,
     /** Only populated by the final-confirmation opt-in; existing selectedSummary behavior is unchanged. */
     val finalSelectionSummaries: List<String> = emptyList(),
+    /** #379: option cards whose truncated caption (price + badge) was merged into the outer card; count only. */
+    val badgeCaptionMerged: Int = 0,
 ) {
     /** The three #331 required spec-panel items are all visible. */
     val hasRequiredPanelEvidence: Boolean get() = hasAddressEntry && hasPaymentEntry && hasQuantityInput
@@ -245,6 +250,8 @@ 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 badgeCaptionSuffix =
+        Regex("[\\s\\u00a0\\u3000]*[¥￥][\\s\\u00a0\\u3000]*(\\d+(?:\\.\\d{1,2})?)[\\s\\u00a0\\u3000]+[^¥￥\\d\\s\\u00a0\\u3000]{1,8}$")
     private val salesPattern = Regex("已拼\\s*[0-9]+(?:\\.[0-9]+)?\\s*(?:万|亿)?\\s*\\+?\\s*(?:件|人)?")
     private val reviewPattern = Regex("(?:商品评价\\s*[（(]?\\s*[0-9]+(?:\\.[0-9]+)?\\s*(?:万|亿)?|[0-9]+(?:\\.[0-9]+)?\\s*(?:万|亿)?\\s*\\+?\\s*条?评价|评价\\s*[0-9]+)")
     private val excludedOptionWords = listOf(
@@ -371,6 +378,7 @@ object PddScreenParser {
             visible.filter { it.path == region.path || it.path.startsWith("${region.path}/") }
         } ?: visible
         val headings = panelVisible.filter { !it.clickable && isHeading(it.label, config) }.sortedBy { it.bounds.top }
+        val badgeMergedBlocks = mutableSetOf<String>()
         val dimensions = buildList<VisibleDimension> {
             headings.forEachIndexed { index, heading ->
                 val lower = headings.getOrNull(index + 1)?.bounds?.top ?: Int.MAX_VALUE
@@ -394,7 +402,7 @@ object PddScreenParser {
                 // node is still chosen by safeOptionRank among the members.
                 val values = candidates
                     .groupBy { candidate ->
-                        optionBlock(candidate, candidates, visibleByPath, sourceByPath, ::inValueRegion)?.path ?: candidate.path
+                        optionBlock(candidate, candidates, visibleByPath, sourceByPath, ::inValueRegion) { badgeMergedBlocks += it }?.path ?: candidate.path
                     }
                     .map { (blockPath, members) ->
                         val block = visibleByPath[blockPath]
@@ -593,6 +601,7 @@ object PddScreenParser {
             problem = problem,
             sourceNodes = visibleNodes,
             isPddPackage = snapshot.packageName == PDD_PACKAGE,
+            badgeCaptionMerged = badgeMergedBlocks.size,
         )
     }
 
@@ -612,6 +621,7 @@ object PddScreenParser {
         visibleByPath: Map<String, SnapshotNode>,
         sourceByPath: Map<String, SnapshotNode>,
         inValueRegion: (SnapshotNode) -> Boolean,
+        onBadgeMerge: (String) -> Unit,
     ): SnapshotNode? {
         fun compact(value: String) = value.replace(Regex("\\s+"), "")
         var block: SnapshotNode? = null
@@ -626,7 +636,7 @@ object PddScreenParser {
                 val outer = compact(resolved.label)
                 val members = candidates.filter { it.path == resolved.path || it.path.startsWith("${resolved.path}/") }
                 val existingBlock = outer.isNotEmpty() && members.all { compact(it.label).startsWith(outer) }
-                if (!existingBlock && !isTruncatedDisplayCard(resolved, members, sourceByPath)) break
+                if (!existingBlock && !isTruncatedDisplayCard(resolved, members, sourceByPath) { onBadgeMerge(resolved.path) }) break
                 block = resolved
             }
             parentPath = raw.parentPath
@@ -656,6 +666,7 @@ object PddScreenParser {
         block: SnapshotNode,
         members: List<SnapshotNode>,
         sourceByPath: Map<String, SnapshotNode>,
+        onBadgeMerge: () -> Unit,
     ): Boolean {
         fun name(label: String) = SpecValueNormalizer.normalizeColor(label).filterNot { it.isWhitespace() }
         val full = name(block.label)
@@ -664,7 +675,11 @@ object PddScreenParser {
         val image = children.singleOrNull { it.className == "android.widget.ImageView" } ?: return false
         val caption = children.singleOrNull { it.className == "android.widget.TextView" } ?: return false
         if (children.size != 2 || name(image.label) != full) return false
-        val short = name(caption.label)
+        // #379: a caption such as "名称...\n ¥11.8 零差评" keeps a price plus a badge
+        // after its truncated name, which the terminal-price grammar cannot strip.
+        val plainCaption = SpecValueNormalizer.normalizeColor(caption.label)
+        val badgeName = if (plainCaption.any { it == '¥' || it == '￥' }) badgeCaptionName(caption.label, block.label) else null
+        val short = (badgeName ?: plainCaption).filterNot { it.isWhitespace() }
         if (short.isEmpty() || short == full || !full.startsWith(short)) return false
 
         val descendants = sourceByPath.values.filter { it.path.startsWith("${block.path}/") }
@@ -682,7 +697,24 @@ object PddScreenParser {
             minOf(image.bounds.right, caption.bounds.right) <= maxOf(image.bounds.left, caption.bounds.left)) return false
 
         val prices = members.mapNotNull { SpecValueNormalizer.trailingPriceAmount(it.label) }
-        return prices.isEmpty() || prices.all { it.compareTo(prices.first()) == 0 }
+        val merged = prices.isEmpty() || prices.all { it.compareTo(prices.first()) == 0 }
+        if (merged && badgeName != null) onBadgeMerge()
+        return merged
+    }
+
+    /**
+     * #379: truncated name of a caption shaped `名称... ¥金额 徽标`, or null. The
+     * badge is 1-8 characters without currency symbols, digits or whitespace and
+     * the amount must equal the outer card's terminal price.
+     */
+    private fun badgeCaptionName(captionLabel: String, fullLabel: String): String? {
+        val match = badgeCaptionSuffix.find(captionLabel) ?: return null
+        val amount = match.groupValues[1].toBigDecimalOrNull() ?: return null
+        val fullAmount = SpecValueNormalizer.trailingPriceAmount(fullLabel) ?: return null
+        if (amount.compareTo(fullAmount) != 0) return null
+        val head = captionLabel.substring(0, match.range.first).filterNot { it.isWhitespace() }
+            .replace(Regex("(?:\\.{3}|…)+$"), "")
+        return head.takeIf { it.isNotEmpty() && head.none { ch -> ch == '¥' || ch == '￥' } }
     }
 
     /** The nearby clickable row holding [node], or null when there is none or it is not a plausible entry row. */
@@ -1319,7 +1351,7 @@ class PddProductDetailCollector(
         val missing = linkedSetOf<String>()
         val unsupported = linkedSetOf<String>()
         val colorImages = linkedMapOf<String, ByteArray>()
-        val colorNormalization = ColorNormalizationTracker()
+        val colorNormalization = ColorNormalizationTracker(trace)
         val specPanelContainer = openedScreen.specPanelContainer
         collectColors(goodsId, config, evidence, deadline, specPanelContainer, colors, prices, missing, unsupported, colorImages, colorNormalization)?.let { return it }
 
@@ -1328,15 +1360,20 @@ class PddProductDetailCollector(
             prices.clear()
             colorImages.clear()
             missing += "spec_dimension_invalid:color"
+        } else if (colorNormalization.conflict) {
+            // #379: same normalized name from different raw labels keeps one value.
+            missing += "spec_dimension_conflict:color"
         }
         moveSpecPanelToTop(goodsId, config, evidence, deadline, specPanelContainer)?.let { return it }
         val sizes = linkedMapOf<String, Boolean>()
-        val sizeNormalization = SizeNormalizationTracker()
+        val sizeNormalization = SizeNormalizationTracker(trace)
         collectSizes(goodsId, config, evidence, deadline, specPanelContainer, sizes, unsupported, sizeNormalization)?.let { return it }
 
         if (sizeNormalization.invalid) {
             sizes.clear()
             missing += "spec_dimension_invalid:size"
+        } else if (sizeNormalization.conflict) {
+            missing += "spec_dimension_conflict:size"
         }
 
         if (colors.isEmpty()) missing += "color"
@@ -1412,6 +1449,14 @@ class PddProductDetailCollector(
         // These signatures stay in memory; only the aggregate tri-state is saved.
         val diagnosticHorizontalRows = mutableMapOf<Set<String>, Boolean?>()
         var diagnosticTermination = AgentDiagnosticReason.COLOR_FOUND
+        // Keep the earliest abnormal reason; later normal ends must not hide it.
+        fun terminate(reason: AgentDiagnosticReason) {
+            if (diagnosticTermination == AgentDiagnosticReason.COLOR_FOUND ||
+                diagnosticTermination == AgentDiagnosticReason.COLOR_EDGE_REACHED
+            ) {
+                diagnosticTermination = reason
+            }
+        }
         val imageAttempts = mutableSetOf<String>()
 
         fun collectVisibleImages(values: List<VisibleSpecValue>) {
@@ -1448,7 +1493,7 @@ class PddProductDetailCollector(
                 diagnosticRowValues.getOrPut(index) { linkedSetOf() }.addAll(row.map(VisibleSpecValue::text))
             }
             val values = rows.flatten()
-            values.forEach(normalization::observe)
+            normalization.observeFrame(values, "parsed", null, screen.badgeCaptionMerged)
             diagnosticParsedValues += values.map(VisibleSpecValue::text)
             diagnosticNonClickableCandidates = maxOf(
                 diagnosticNonClickableCandidates,
@@ -1479,7 +1524,9 @@ class PddProductDetailCollector(
         }
 
         moveSpecPanelToTop(goodsId, config, evidence, deadline, specPanelContainer)?.let { return it }
-        moveColorsToStart(goodsId, config, evidence, deadline)?.let { return it }
+        val colorStart = moveColorsToStart(goodsId, config, evidence, deadline)
+        colorStart.failure?.let { return it }
+        val colorStartConfirmed = colorStart.confirmed
         val initial = parse(goodsId, config, evidence)
         initial.problem?.let { return failure(it.code, it.message) }
         diagnosticInitialSelectedColors = initial.dimensions.filter { it.key == "color" }.flatMap { it.values }
@@ -1530,6 +1577,7 @@ class PddProductDetailCollector(
                     FreshActionResult.BLOCKED -> return sizeAdviceFailure()
                     FreshActionResult.AMBIGUOUS -> return failure("RULE_AMBIGUOUS", "颜色“${value.text}”匹配到多个控件")
                     FreshActionResult.NOT_FOUND, FreshActionResult.FAILED -> {
+                        traceColorClickMiss(screen, value, rows, clickResult)
                         missing += "selection:${value.text}"
                         continue
                     }
@@ -1561,7 +1609,18 @@ class PddProductDetailCollector(
             // established left/right paging behavior.
             if (rows.any { it.size > 1 }) {
                 val rowSeeds = rows.map { row -> row.map(VisibleSpecValue::text).toSet() }
+                // Frame-to-frame row tracking: rows are followed by overlap with
+                // their previous frame, not by the pass's starting frame.
+                val tracks = rows.map(::colorRowTrack).toMutableList()
+                val coveredRows = mutableSetOf<Int>()
+                var coveredIncomplete: Boolean? = null
                 rowSeeds.forEachIndexed { rowIndex, seed ->
+                    if (rowIndex in coveredRows) {
+                        // A shared container already swept this row's values.
+                        diagnosticHorizontalRows[seed] = coveredIncomplete
+                            ?: diagnosticHorizontalRows[seed]?.takeIf { it }
+                        return@forEachIndexed
+                    }
                     val moveRight = rowIndex % 2 == 0
                     val horizontalSignatureReads = mutableMapOf<List<String>, Int>()
                     var diagnosticPreviousSignature: List<String>? = null
@@ -1569,11 +1628,15 @@ class PddProductDetailCollector(
                     var diagnosticMoved = false
                     var diagnosticRowUncertain = false
                     var diagnosticRowIncomplete: Boolean? = null
+                    var sharedMoves = 0
+                    var sharedBroken = tracks.size < 2
+                    var rowEnd = "limit"
+                    var rowSkipNote = "none"
                     for (horizontalPass in 0..config.limits.getValue("specHorizontalSwipes")) {
                         var diagnosticBeforeClicks: List<String>? = null
                         collectVisibleColors { observedRows ->
-                            diagnosticBeforeClicks = observedRows.filter { row -> row.any { it.text in seed } }
-                                .singleOrNull()?.sortedBy { it.node.bounds.left }
+                            diagnosticBeforeClicks = matchColorRow(tracks[rowIndex], observedRows, tracks.size, requireUniqueOverlap = true)
+                                ?.sortedBy { it.node.bounds.left }
                                 ?.let { if (moveRight) it else it.reversed() }?.let(::optionSignature)
                         }?.let { return it }
                         screen = parse(goodsId, config, evidence)
@@ -1581,11 +1644,37 @@ class PddProductDetailCollector(
                         if (!screen.pageEvidenceMatched) return failure("RULE_NOT_MATCHED", "采集期间离开 PDD 商品详情页")
                         rows = colorRows(screen)
                         observeColorDiscovery(screen, rows)
-                        val matchedRow = rows.maxByOrNull { row -> row.count { it.text in seed } }
-                            ?.takeIf { row -> row.any { it.text in seed } }
+                        val matches = tracks.map { matchColorRow(it, rows, tracks.size) }
+                        val matchedRow = matches[rowIndex]
+                        val matchKind = colorRowMatchKind(tracks[rowIndex], rows, tracks.size)
+                        val rowMoved = matchedRow != null && positionSignature(matchedRow) != tracks[rowIndex].signature
+                        val othersDesc = tracks.indices.filter { it != rowIndex }.joinToString(",") { other ->
+                            val match = matches[other]
+                            when {
+                                match == null -> "none"
+                                positionSignature(match) != tracks[other].signature -> "moved"
+                                else -> "unchanged"
+                            }
+                        }
+                        if (rowMoved && matchedRow != null) {
+                            sharedMoves++
+                            // Position (text + bounds), not the text set: a partial
+                            // last swipe moves options without changing which are visible.
+                            val everyOtherRowMoved = tracks.indices.all { other ->
+                                other == rowIndex || matches[other]?.let { match ->
+                                    positionSignature(match) != tracks[other].signature
+                                } == true
+                            }
+                            if (!everyOtherRowMoved) sharedBroken = true
+                        }
+                        matches.forEachIndexed { index, match ->
+                            match?.let { tracks[index] = colorRowTrack(it) }
+                        }
                         if (matchedRow == null) {
+                            trace("color-row row=$rowIndex dir=${if (moveRight) "LEFT" else "RIGHT"} match=$matchKind moved=$rowMoved others=$othersDesc sharedMoves=$sharedMoves sharedBroken=$sharedBroken")
+                            rowEnd = "reflow"
                             diagnosticHorizontalUnknown = true
-                            diagnosticTermination = AgentDiagnosticReason.COLOR_ROW_REFLOWED
+                            terminate(AgentDiagnosticReason.COLOR_ROW_REFLOWED)
                             break
                         }
                         val currentRow = matchedRow.sortedBy { it.node.bounds.left }
@@ -1605,24 +1694,57 @@ class PddProductDetailCollector(
                         diagnosticPreviousSignature = signature
                         val signatureReads = (horizontalSignatureReads[signature] ?: 0) + 1
                         horizontalSignatureReads[signature] = signatureReads
+                        trace("color-row row=$rowIndex dir=${if (moveRight) "LEFT" else "RIGHT"} match=$matchKind moved=$rowMoved others=$othersDesc sharedMoves=$sharedMoves sharedBroken=$sharedBroken uncertain=$diagnosticRowUncertain signatureReads=$signatureReads")
                         if (signatureReads > config.limits.getValue("stableEdgeReads")) {
+                            rowEnd = "edge"
                             if (!diagnosticRowUncertain && diagnosticStableReads >= config.limits.getValue("stableEdgeReads")) {
                                 diagnosticRowIncomplete = false
                             }
+                            // The skip depends only on reaching this row's edge
+                            // with every other row having followed every move,
+                            // not on the diagnostic certainty: a click-induced
+                            // layout change must not force a redundant sweep.
+                            val rest = (rowIndex + 1 until tracks.size).toList()
+                            if (rest.isNotEmpty()) {
+                                // The reverse sweep is the only thing that recovers
+                                // values left of an unconfirmed start, so skipping it
+                                // needs a sweep that began at a confirmed left edge.
+                                val skipOrigin = when {
+                                    !colorStartConfirmed -> "start_unconfirmed"
+                                    verticalPass != 0 -> "later_vertical_pass"
+                                    rowIndex != 0 -> "not_first_row"
+                                    else -> null
+                                }
+                                if (skipOrigin != null) {
+                                    rowSkipNote = "not_skipped reason=$skipOrigin"
+                                } else if (!sharedBroken && sharedMoves > 0) {
+                                    coveredRows += rest
+                                    coveredIncomplete = diagnosticRowIncomplete
+                                    rowSkipNote = "skipped=${rest.joinToString(",")}"
+                                } else {
+                                    rowSkipNote = "not_skipped reason=${if (sharedMoves == 0) "no_shared_moves" else "shared_broken"}"
+                                }
+                            }
                             break
                         }
                         if (horizontalPass == config.limits.getValue("specHorizontalSwipes")) {
+                            rowEnd = "limit"
                             if (diagnosticMoved && !diagnosticRowUncertain) diagnosticRowIncomplete = true
                             break
                         }
                         val direction = if (moveRight) SwipeDirection.LEFT else SwipeDirection.RIGHT
                         if (!driver.swipeSpec(direction, currentRow.first().node)) {
+                            rowEnd = "swipe_failed"
                             if (diagnosticMoved && !diagnosticRowUncertain) diagnosticRowIncomplete = true
                             break
                         }
                         diagnosticHorizontalSwipes++
-                        pause(350)
+                        val settleStartedAt = now()
+                        pause(HORIZONTAL_SETTLE_MILLIS)
+                        lastHorizontalSwipeDoneAt = now()
+                        trace("color-settle waitedMs=${now() - settleStartedAt}")
                     }
+                    trace("color-row-end row=$rowIndex end=$rowEnd skip=$rowSkipNote")
                     // An uncertain revisit cannot erase previously observed
                     // unresolved movement; only reliable stability clears it.
                     diagnosticHorizontalRows[seed] = diagnosticRowIncomplete
@@ -1640,7 +1762,7 @@ class PddProductDetailCollector(
             diagnosticTrailingEmptyReads = if (rows.isEmpty()) diagnosticTrailingEmptyReads + 1 else 0
             if (rows.isEmpty()) diagnosticHorizontalUnknown = true
             if (!discoverVertically) {
-                diagnosticTermination = AgentDiagnosticReason.COLOR_EDGE_REACHED
+                terminate(AgentDiagnosticReason.COLOR_EDGE_REACHED)
                 break
             }
 
@@ -1652,21 +1774,21 @@ class PddProductDetailCollector(
             }
             previousVerticalSignature = verticalSignature
             if (verticalStable >= config.limits.getValue("stableEdgeReads")) {
-                diagnosticTermination = AgentDiagnosticReason.COLOR_EDGE_REACHED
+                terminate(AgentDiagnosticReason.COLOR_EDGE_REACHED)
                 break
             }
             if (verticalPass == config.limits.getValue("specVerticalSwipes")) {
-                diagnosticTermination = AgentDiagnosticReason.COLOR_SCAN_LIMIT
+                terminate(AgentDiagnosticReason.COLOR_SCAN_LIMIT)
                 break
             }
             val anchor = rows.flatten().firstOrNull()?.node ?: specPanelContainer
             if (anchor == null) {
                 diagnosticHorizontalUnknown = true
-                diagnosticTermination = AgentDiagnosticReason.COLOR_CONTAINER_UNAVAILABLE
+                terminate(AgentDiagnosticReason.COLOR_CONTAINER_UNAVAILABLE)
                 break
             }
             if (!driver.swipeSpec(SwipeDirection.UP, anchor)) {
-                diagnosticTermination = AgentDiagnosticReason.COLOR_SWIPE_FAILED
+                terminate(AgentDiagnosticReason.COLOR_SWIPE_FAILED)
                 break
             }
             diagnosticVerticalSwipes++
@@ -1678,6 +1800,31 @@ class PddProductDetailCollector(
 
     private fun sizeAdviceFailure() = failure("SIZE_ADVICE_CLICK_BLOCKED", "已阻止点击尺码建议入口")
 
+    private var lastHorizontalSwipeDoneAt = -1L
+
+    private fun traceColorClickMiss(screen: ParsedPddScreen, value: VisibleSpecValue, rows: List<List<VisibleSpecValue>>, result: FreshActionResult) {
+        val rowIndex = rows.indexOfFirst { row -> row.any { it.text == value.text } }
+        val column = rows.getOrNull(rowIndex).orEmpty().sortedBy { it.node.bounds.left }.indexOfFirst { it.text == value.text }
+        val bounds = value.node.bounds
+        val width = bounds.right - bounds.left
+        val byPath = screen.sourceNodes.associateBy(SnapshotNode::path)
+        var container: SnapshotNode? = byPath[value.node.parentPath]
+        var hops = 0
+        while (container != null && !container.scrollable && hops < 6) {
+            container = container.parentPath?.let { byPath[it] }
+            hops++
+        }
+        val exposed = if (width > 0 && container != null) {
+            val shown = (minOf(bounds.right, container.bounds.right) - maxOf(bounds.left, container.bounds.left)).coerceAtLeast(0)
+            "${shown * 100 / width}%"
+        } else {
+            "unknown"
+        }
+        val containerText = container?.let { "${it.bounds}" } ?: "unknown"
+        val sinceSwipe = if (lastHorizontalSwipeDoneAt < 0) "none" else "${now() - lastHorizontalSwipeDoneAt}ms"
+        trace("color-click-miss color=${traceLabel(value.text)} result=$result row=$rowIndex column=$column bounds=$bounds container=$containerText exposed=$exposed sinceSwipe=$sinceSwipe")
+    }
+
     private fun clickSpecTarget(target: SnapshotNode, stage: AgentDiagnosticStage): FreshActionResult {
         val outcome = driver.clickFreshDetailed(target)
         if (taskId > 0) runCatching { diagnostic(specClickDiagnostic(taskId, stage, target, outcome)) }
@@ -1837,31 +1984,72 @@ class PddProductDetailCollector(
         return null
     }
 
+    private class ColorStart(val failure: PddCollectorResult?, val confirmed: Boolean)
+
     private fun moveColorsToStart(
         goodsId: String,
         config: PddCollectorConfig,
         evidence: PageEvidence,
         deadline: Long,
-    ): PddCollectorResult? {
+    ): ColorStart {
         var previous = emptyList<String>()
         var stable = 0
-        repeat(config.limits.getValue("specHorizontalSwipes")) {
-            if (now() > deadline) return failure("RULE_NOT_MATCHED", "采集超过规则总超时")
+        var swipes = 0
+        var anchorRetries = 0
+        var anchorFailures = 0
+        var confirmed = false
+        var end = "limit"
+        // Reset has its own swipe budget; anchor retries do not consume it.
+        val maxSwipes = config.limits.getValue("specHorizontalSwipes") * 2
+        while (swipes < maxSwipes) {
+            if (now() > deadline) return ColorStart(failure("RULE_NOT_MATCHED", "采集超过规则总超时"), false)
             val screen = parse(goodsId, config, evidence)
-            screen.problem?.let { return failure(it.code, it.message) }
-            if (!screen.pageEvidenceMatched) return failure("RULE_NOT_MATCHED", "采集期间离开 PDD 商品详情页")
+            screen.problem?.let { return ColorStart(failure(it.code, it.message), false) }
+            if (!screen.pageEvidenceMatched) return ColorStart(failure("RULE_NOT_MATCHED", "采集期间离开 PDD 商品详情页"), false)
             val rows = colorRows(screen)
-            if (rows.size > 1 && rows.all { it.size == 1 }) return null
+            if (rows.size > 1 && rows.all { it.size == 1 }) {
+                end = "single_column"
+                break
+            }
             val values = rows.flatten()
             val signature = optionSignature(values)
             stable = if (signature == previous) stable + 1 else 0
             previous = signature
-            if (stable >= config.limits.getValue("stableEdgeReads")) return null
-            val anchor = values.firstOrNull()?.node ?: return null
-            if (!driver.swipeSpec(SwipeDirection.RIGHT, anchor)) return null
+            if (stable >= config.limits.getValue("stableEdgeReads")) {
+                confirmed = true
+                end = "stable"
+                break
+            }
+            // After an anchor failure, try a different color node of this frame.
+            val anchor = values.getOrNull(anchorFailures)?.node ?: values.firstOrNull()?.node
+            if (anchor == null) {
+                end = "no_anchor"
+                break
+            }
+            if (!driver.swipeSpec(SwipeDirection.RIGHT, anchor)) {
+                val reason = driver.specRowSwipeFailureReason()
+                anchorFailures++
+                // A failed gesture says nothing about the position, so the next
+                // equal read must not count as stability.
+                previous = emptyList()
+                stable = 0
+                if (
+                    (reason == "anchorMissing" || reason == "anchorAmbiguous") &&
+                    anchorFailures <= MAX_CONSECUTIVE_RESET_ANCHOR_FAILURES &&
+                    anchorRetries < MAX_RESET_ANCHOR_RETRIES
+                ) {
+                    anchorRetries++
+                    continue
+                }
+                end = "swipe_failed"
+                break
+            }
+            anchorFailures = 0
+            swipes++
             pause(350)
         }
-        return null
+        trace("color-start confirmed=$confirmed swipes=$swipes anchorRetries=$anchorRetries end=$end")
+        return ColorStart(null, confirmed)
     }
 
     private fun collectSizes(
@@ -1887,9 +2075,17 @@ class PddProductDetailCollector(
             screen.dimensions.filter { it.key == "unsupported" }.forEach { unsupported += it.name }
             val parsedSizes = screen.dimensions.filter { it.key == "size" }.flatMap { it.values }
             if (parsedSizes.isNotEmpty()) continuation = buildSizeContinuation(screen, parsedSizes)
-            val visible = if (parsedSizes.isNotEmpty()) parsedSizes else continuationValues(screen, continuation, config)
+            // #379: observe every candidate before continuation de-duplication,
+            // otherwise a same-name conflict is swallowed by groupBy.
+            val continuationCandidates = if (parsedSizes.isNotEmpty()) emptyList() else continuationCandidates(screen, continuation, config)
+            normalization.observeFrame(
+                if (parsedSizes.isNotEmpty()) parsedSizes else continuationCandidates,
+                if (parsedSizes.isNotEmpty()) "parsed" else "continuation",
+                pass,
+                screen.badgeCaptionMerged,
+            )
+            val visible = if (parsedSizes.isNotEmpty()) parsedSizes else dedupeContinuation(continuationCandidates)
             visible.forEach { value ->
-                normalization.observe(value)
                 if (SpecValueNormalizer.isSafeSize(value.text)) {
                     sizes[value.text] = sizes[value.text] == true || value.available
                 }
@@ -1934,37 +2130,75 @@ class PddProductDetailCollector(
         return null
     }
 
-    private class SizeNormalizationTracker {
-        private val sources = linkedMapOf<String, MutableSet<String>>()
+    /**
+     * #160/#379: an empty or currency-bearing normalized value rejects the whole
+     * dimension ([invalid]); a normalized name backed by several raw labels only
+     * marks a [conflict] and the dimension keeps a single value for that name.
+     */
+    private open class SpecNormalizationTracker(
+        private val dim: String,
+        private val isSafe: (String) -> Boolean,
+        private val trace: (String) -> Unit,
+    ) {
+        // normalized text -> raw label -> frames in which that raw label was seen
+        private val sources = linkedMapOf<String, LinkedHashMap<String, MutableSet<Int>>>()
+        private var frameCounter = 0
+        private var invalidTraced = false
+        private var conflictTraced = false
         var invalid: Boolean = false
             private set
+        var conflict: Boolean = false
+            private set
 
-        fun observe(value: VisibleSpecValue) {
-            if (!SpecValueNormalizer.isSafeSize(value.text)) {
-                invalid = true
-                return
+        /** [pass] identifies the frame; without it the tracker numbers its own observations. */
+        fun observeFrame(values: List<VisibleSpecValue>, path: String, pass: Int?, badgeMerged: Int) {
+            val frame = pass ?: ++frameCounter
+            values.forEach { value ->
+                if (!isSafe(value.text)) {
+                    invalid = true
+                    if (!invalidTraced) {
+                        invalidTraced = true
+                        val reason = if (value.text.isBlank()) "empty" else "unsafe_currency"
+                        traceOutcome("invalid_rejected", reason, path, frame, false, false, 1, values.size, badgeMerged)
+                    }
+                    return@forEach
+                }
+                val raws = sources.getOrPut(value.text) { linkedMapOf() }
+                val isNewRaw = value.rawText !in raws
+                raws.getOrPut(value.rawText) { linkedSetOf() } += frame
+                if (raws.size > 1) {
+                    conflict = true
+                    if (isNewRaw && !conflictTraced) {
+                        conflictTraced = true
+                        traceOutcome(
+                            "conflict_kept", "normalized_conflict", path, frame,
+                            raws.values.count { frame in it } > 1,
+                            raws.keys.map { it.replace(TRAILING_PRICE, "") }.toSet().size == 1,
+                            raws.size, values.size, badgeMerged,
+                        )
+                    }
+                }
             }
-            val rawValues = sources.getOrPut(value.text) { linkedSetOf() }
-            rawValues += value.rawText
-            if (rawValues.size > 1) invalid = true
+        }
+
+        // Counts and enum values only: never the raw node text.
+        private fun traceOutcome(
+            outcome: String, reason: String, path: String, pass: Int, sameFrame: Boolean,
+            onlyTrailingPriceDiff: Boolean, rawVariants: Int, candidates: Int, badgeMerged: Int,
+        ) {
+            trace(
+                "spec-normalize dim=$dim outcome=$outcome reason=$reason path=$path pass=$pass sameFrame=$sameFrame " +
+                    "onlyTrailingPriceDiff=$onlyTrailingPriceDiff rawVariants=$rawVariants candidates=$candidates " +
+                    "badgeCaptionMerged=$badgeMerged",
+            )
         }
     }
 
-    private class ColorNormalizationTracker {
-        private val sources = linkedMapOf<String, MutableSet<String>>()
-        var invalid: Boolean = false
-            private set
+    private class SizeNormalizationTracker(trace: (String) -> Unit) :
+        SpecNormalizationTracker("size", SpecValueNormalizer::isSafeSize, trace)
 
-        fun observe(value: VisibleSpecValue) {
-            if (!SpecValueNormalizer.isSafeColor(value.text)) {
-                invalid = true
-                return
-            }
-            val rawValues = sources.getOrPut(value.text) { linkedSetOf() }
-            rawValues += value.rawText
-            if (rawValues.size > 1) invalid = true
-        }
-    }
+    private class ColorNormalizationTracker(trace: (String) -> Unit) :
+        SpecNormalizationTracker("color", SpecValueNormalizer::isSafeColor, trace)
 
     private fun recordSizeDiscovery(
         reason: AgentDiagnosticReason,
@@ -2044,7 +2278,8 @@ class PddProductDetailCollector(
         )
     }
 
-    private fun continuationValues(screen: ParsedPddScreen, context: SizeContinuation?, config: PddCollectorConfig): List<VisibleSpecValue> {
+    /** Normalized continuation candidates before any de-duplication; rawText keeps the original label. */
+    private fun continuationCandidates(screen: ParsedPddScreen, context: SizeContinuation?, config: PddCollectorConfig): List<VisibleSpecValue> {
         if (context == null) return emptyList()
         val headingLabels = (config.colorAliases + config.sizeAliases + config.textAliases.dimension.exactNames +
             config.textAliases.dimension.adaptiveAliases).map { it.replace(" ", "") }.toSet()
@@ -2059,13 +2294,21 @@ class PddProductDetailCollector(
             .filterNot { it.label in context.colorLabels || it.label.replace(" ", "") in headingLabels }
             .filterNot { PddScreenParser.isExcludedOptionLabel(it.label) || priceOnly.matches(it.label.replace(" ", "")) }
             .map { node ->
-                VisibleSpecValue(node.label, node.enabled && listOf("售罄", "缺货", "不可选").none(node.label::contains), node)
+                VisibleSpecValue(
+                    SpecValueNormalizer.normalizeSize(node.label),
+                    node.enabled && listOf("售罄", "缺货", "不可选").none(node.label::contains),
+                    node,
+                    rawText = node.label,
+                )
             }
-            .groupBy(VisibleSpecValue::text)
-            .map { (_, sameLabel) -> sameLabel.minBy { it.node.bounds.top * 10_000 + it.node.bounds.left } }
-            .sortedWith(compareBy({ it.node.bounds.top }, { it.node.bounds.left }))
+            .toList()
     }
 
+    private fun dedupeContinuation(candidates: List<VisibleSpecValue>): List<VisibleSpecValue> = candidates
+        .groupBy(VisibleSpecValue::text)
+        .map { (_, sameLabel) -> sameLabel.minBy { it.node.bounds.top * 10_000 + it.node.bounds.left } }
+        .sortedWith(compareBy({ it.node.bounds.top }, { it.node.bounds.left }))
+
     private fun stablePrice(
         goodsId: String,
         color: String,
@@ -2213,12 +2456,65 @@ class PddProductDetailCollector(
     private fun traceLabel(value: String): String = value.replace(Regex("[\\r\\n\\t]+"), " ").take(40)
 
     private companion object {
+        /** Same terminal-price grammar as [SpecValueNormalizer]; used only to classify a trace, never to normalize. */
+        val TRAILING_PRICE = Regex("""[\s\u00a0\u3000]*(?:¥|￥)[\s\u00a0\u3000]*\d+(?:\.\d{1,2})?[\s\u00a0\u3000]*$""")
         const val PRICE_SETTLE_MILLIS = 300L
+        /** Fixed wait for the color grid to stop coasting after a horizontal swipe (no extra parse). */
+        const val HORIZONTAL_SETTLE_MILLIS = 1200L
+        const val MAX_RESET_ANCHOR_RETRIES = 6
+        const val MAX_CONSECUTIVE_RESET_ANCHOR_FAILURES = 2
         const val SPEC_PANEL_LOST_STABLE_READS = 2
         const val COLOR_IMAGE_MAX_COUNT = 64
         const val COLOR_IMAGE_MAX_TOTAL_BYTES = 8 * 1024 * 1024
     }
 
+    /** Last observed frame of one color row, used to follow it across horizontal swipes. */
+    private class ColorRowTrack(val texts: Set<String>, val centerY: Int, val tolerance: Int, val signature: List<String>)
+
+    private fun colorRowTrack(row: List<VisibleSpecValue>) = ColorRowTrack(
+        row.map(VisibleSpecValue::text).toSet(),
+        row.map { it.node.bounds.centerY }.average().toInt(),
+        (row.first().node.bounds.height / 2).coerceIn(24, 80),
+        positionSignature(row),
+    )
+
+    private fun colorRowMatchKind(
+        track: ColorRowTrack,
+        rows: List<List<VisibleSpecValue>>,
+        trackedRowCount: Int,
+    ): String = when {
+        rows.any { row -> row.any { it.text in track.texts } } -> "overlap"
+        matchColorRow(track, rows, trackedRowCount) != null -> "position"
+        else -> "none"
+    }
+
+    private fun positionSignature(row: List<VisibleSpecValue>): List<String> =
+        optionSignature(row.sortedBy { it.node.bounds.left })
+
+    /**
+     * Finds the current-frame row for a tracked row. Overlap with the previous
+     * frame wins. With no overlap (a whole-page move) a multi-row grid whose
+     * row count is unchanged may match by vertical position, but only when
+     * exactly one current row sits within the colorRows tolerance. Anything
+     * else is not the same row and stays a reflow.
+     */
+    private fun matchColorRow(
+        track: ColorRowTrack,
+        rows: List<List<VisibleSpecValue>>,
+        trackedRowCount: Int,
+        requireUniqueOverlap: Boolean = false,
+    ): List<VisibleSpecValue>? {
+        val overlapping = rows.filter { row -> row.any { it.text in track.texts } }
+        if (overlapping.isNotEmpty()) {
+            if (requireUniqueOverlap && overlapping.size > 1) return null
+            return overlapping.maxByOrNull { row -> row.count { it.text in track.texts } }
+        }
+        if (trackedRowCount < 2 || rows.size != trackedRowCount) return null
+        return rows.filter { row ->
+            kotlin.math.abs(row.map { it.node.bounds.centerY }.average().toInt() - track.centerY) <= track.tolerance
+        }.singleOrNull()
+    }
+
     private fun colorRows(screen: ParsedPddScreen): List<List<VisibleSpecValue>> {
         val values = screen.dimensions.filter { it.key == "color" }.flatMap { it.values }
             .sortedWith(compareBy({ it.node.bounds.centerY }, { it.node.bounds.left }))

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

@@ -0,0 +1,126 @@
+package cn.ilapage.goauto.agent.automation
+
+/** Current-capture evidence only. No clicks, historical selection proof, or whole-screen text fallback. */
+internal object PurchaseFinalSpecVerifier {
+    private fun normalize(value: String) = SpecValueNormalizer.normalizeFinalConfirmation(value)
+
+    fun verify(snapshot: UiSnapshot, input: PurchaseExecutionInput, diagnostic: (String) -> Unit) {
+        val config = PurchaseRehearsalExecutor.DEFAULT_COLLECTOR
+        val byPath = snapshot.nodes.associateBy(SnapshotNode::path)
+        fun within(node: SnapshotNode, container: SnapshotNode): Boolean {
+            val visited = mutableSetOf<String>()
+            var current: SnapshotNode? = node
+            while (current != null && visited.add(current.path)) {
+                if (current.path == container.path) return true
+                current = current.parentPath?.let(byPath::get)
+            }
+            return false
+        }
+        fun contained(node: SnapshotNode, container: SnapshotNode) =
+            node.bounds.width > 0 && node.bounds.height > 0 &&
+                node.bounds.left >= container.bounds.left && node.bounds.right <= container.bounds.right &&
+                node.bounds.top >= container.bounds.top && node.bounds.bottom <= container.bounds.bottom
+
+        val original = PddScreenParser.parse(snapshot, config, input.goodsId, null, forFinalConfirmation = true)
+        val fullPanel = boundedQuantityPanel(snapshot).takeIf { original.specPanelOpen }
+        // #331/#335 sheet ancestry, as represented by SpecPanelFixtures.sheet and taskOptionDedupSheet.
+        // The inner scroll list is not the full sheet: summary and quantity may be its siblings.
+        val scoped = fullPanel?.let { panel ->
+            val nodes = snapshot.nodes.filter { node ->
+                (within(node, panel) && contained(node, panel)) ||
+                    (node.parentPath == null && node.label.isBlank() && !node.clickable)
+            }
+            PddScreenParser.parse(snapshot.copy(nodes = nodes), config, input.goodsId, null, forFinalConfirmation = true)
+                .takeIf { it.specPanelOpen }
+        }
+        val optionScope = if (scoped != null) fullPanel else original.specPanelContainer
+        val dimensions = (scoped ?: original).dimensions.groupBy(VisibleDimension::key).mapValues { (_, groups) ->
+            val options = groups.flatMap(VisibleDimension::values).filter { option ->
+                optionScope != null && within(option.node, optionScope) && contained(option.node, optionScope)
+            }
+            // A blank clickable wrapper and its single text child may survive optionBlock separately.
+            // The #331 size fixture exposes exactly the same rectangle for both. Aggregate only a
+            // same-value ancestor chain with that physical rectangle, never same-label siblings.
+            options.groupBy { option ->
+                options.filter { other -> other.node.bounds == option.node.bounds &&
+                    normalize(other.text) == normalize(option.text) && within(option.node, other.node)
+                }.minBy { it.node.path.length }.node.path
+            }.values.map { members ->
+                members.first().let { first -> first.copy(
+                    available = members.all(VisibleSpecValue::available),
+                    node = first.node.copy(
+                        selected = members.any { it.node.selected },
+                        checked = members.any { it.node.checked },
+                    ),
+                ) }
+            }
+        }
+        val summaries = scoped?.finalSelectionSummaries.orEmpty().map { raw ->
+            // Only the anchored recognized prefix and its optional colon are removed.
+            val trimmed = raw.trim()
+            val prefix = config.textAliases.selection.selectedPrefixes.firstOrNull(trimmed::startsWith)
+            val value = if (prefix == null) trimmed else trimmed.removePrefix(prefix).trimStart().let {
+                if (it.startsWith(':') || it.startsWith('：')) it.drop(1) else it
+            }
+            normalize(value)
+        }.distinct()
+        val targets = linkedMapOf("color" to normalize(input.mappedColor), "size" to normalize(input.mappedSize))
+            .filterValues(String::isNotBlank)
+        fun reject(dimension: String, stage: String, selected: Boolean = false, conflict: Boolean = false): Nothing {
+            val detail = "finalSpec;dimension=$dimension;stage=$stage;summaryPresent=${if (summaries.isNotEmpty()) 1 else 0};" +
+                "selectedFound=${if (selected) 1 else 0};conflict=${if (conflict) 1 else 0}"
+            diagnostic(detail)
+            throw PurchaseLiveException("PURCHASE_SPEC_NOT_MATCHED", "创建订单前规格复核失败；$detail")
+        }
+        if (targets.isEmpty()) reject("none", "missing_target")
+        val selectedProof = mutableSetOf<String>()
+        targets.forEach { (dimension, target) ->
+            val options = dimensions[dimension].orEmpty()
+            val selected = options.filter { it.node.selected || it.node.checked }
+            // Parsed text already follows the established UI trailing-price separation contract.
+            // The final-only normalizer removes no additional content from values, input or summary.
+            val exact = options.filter { normalize(it.text) == target }
+            if (selected.any { normalize(it.text) != target }) reject(dimension, "selected_conflict", selected = true, conflict = true)
+            if (exact.size > 1) reject(dimension, "candidate_collision", selected.isNotEmpty(), conflict = true)
+            if (exact.any { !it.available }) reject(dimension, "unavailable", selected.isNotEmpty(), conflict = true)
+            if (exact.any { it.node.selected || it.node.checked }) selectedProof += dimension
+        }
+        if (summaries.size > 1) reject(targets.keys.first(), "summary_conflict", selectedProof.isNotEmpty(), conflict = true)
+        val summary = summaries.singleOrNull()
+        // Evidence only supports color then size with a space. Do not guess reverse order or comma separators.
+        val expected = targets.values.joinToString(" ")
+        if (summary != null && targets.size == 2) {
+            val colors = (dimensions["color"].orEmpty().map { normalize(it.text) } + targets.getValue("color")).distinct()
+            val sizes = (dimensions["size"].orEmpty().map { normalize(it.text) } + targets.getValue("size")).distinct()
+            if (colors.any { color -> sizes.any { size ->
+                    "$color $size" == summary && (color != targets["color"] || size != targets["size"])
+                } }) reject("color", "composition_ambiguity", selectedProof.isNotEmpty(), conflict = true)
+        }
+        targets.keys.forEach { dimension ->
+            if (dimension !in selectedProof && summary != expected) reject(dimension, "missing_proof")
+        }
+    }
+
+    /** Existing #335 quantity-ancestor form, retaining identity as well as bounds for summary ownership. */
+    private fun boundedQuantityPanel(snapshot: UiSnapshot): SnapshotNode? {
+        val visible = snapshot.nodes.filter(SnapshotNode::visible)
+        val screenWidth = visible.maxOfOrNull { it.bounds.right } ?: return null
+        val screenHeight = visible.maxOfOrNull { it.bounds.bottom } ?: return null
+        val screenArea = screenWidth.toLong() * screenHeight
+        val byPath = visible.associateBy(SnapshotNode::path)
+        var current = visible.singleOrNull {
+            it.enabled && it.className == "android.widget.EditText" && it.label.toIntOrNull()?.let { value -> value > 0 } == true
+        } ?: return null
+        var panel: SnapshotNode? = null
+        val visited = mutableSetOf(current.path)
+        while (true) {
+            val parent = current.parentPath?.let(byPath::get) ?: break
+            if (!visited.add(parent.path)) return null
+            val area = parent.bounds.width.toLong() * parent.bounds.height
+            if (area <= 0 || area >= screenArea || parent.parentPath == null) break
+            panel = parent
+            current = parent
+        }
+        return panel
+    }
+}

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

@@ -3,7 +3,6 @@ package cn.ilapage.goauto.agent.automation
 import java.text.SimpleDateFormat
 import java.util.Locale
 import java.util.TimeZone
-import org.json.JSONObject
 
 data class ShippingAddressProof internal constructor(
     internal val expectedAddress: String,
@@ -18,28 +17,7 @@ data class FinalConfirmationEvidence(
     val unitPriceCent: Long,
     val addressSuffix: String,
     val activityName: String,
-    val observedQuantity: Long? = null,
-    val selectedSummaryPresent: Boolean = false,
-    val summaryPromptPresent: Boolean = false,
-) {
-    /** Local boundary evidence only; never used in the uploaded purchase result. */
-    fun toLocalJson(): String = JSONObject()
-        .put("goodsId", goodsId)
-        .put("mappedColor", mappedColor)
-        .put("mappedSize", mappedSize)
-        .put("targetQuantity", quantity)
-        .put("observedQuantity", observedQuantity ?: JSONObject.NULL)
-        .put("selectedSummaryPresent", selectedSummaryPresent)
-        .put("summaryPromptPresent", summaryPromptPresent)
-        .put("unitPriceCent", unitPriceCent)
-        .put("addressSuffix", addressSuffix)
-        .put("activityName", activityName)
-        .toString()
-}
-
-internal fun observedPurchaseQuantity(snapshot: UiSnapshot): Long? = snapshot.nodes.filter {
-    it.visible && it.enabled && it.className?.endsWith("EditText") == true && it.label.toLongOrNull() != null
-}.singleOrNull()?.label?.toLongOrNull()
+)
 
 data class PurchaseOrderEvidence(val orderNo: String, val submittedAt: String, val pddOrderAmountCent: Long? = null)
 data class PurchaseOrderReadFailure(
@@ -337,20 +315,18 @@ class PurchaseLiveAutomation(
         val snapshot = driver.capture()
         pageProblem(snapshot)
         if (snapshot.packageName != PDD_PACKAGE) fail("PURCHASE_CONFIRMATION_LOST", "最终提交前页面已经变化，禁止创建订单")
-        if (!hasSavedAddressEvidence(snapshot, address.expectedAddress, address.suffix)) {
+        if (!hasFinalSavedAddressEvidence(snapshot, address.expectedAddress, address.suffix)) {
             fail("PURCHASE_ADDRESS_UPDATE_FAILED", "收货地址保存后复核失败，未创建订单")
         }
         val submit = finalSubmitTargets(snapshot)
         if (submit.size != 1) fail("PURCHASE_SUBMIT_TARGET_AMBIGUOUS", "创建订单按钮不是唯一目标，禁止创建订单")
         val screen = PddScreenParser.parse(snapshot, PurchaseRehearsalExecutor.DEFAULT_COLLECTOR, input.goodsId, null)
-        rejectSubmitSelectionPrompt(submit.single())
+        PurchaseFinalSpecVerifier.verify(snapshot, input, panelDiagnostic)
         val price = screen.priceCent ?: fail("RULE_NOT_MATCHED", "创建订单前没有读取到商品单价")
         if (price !in input.minUnitPriceCent..input.maxUnitPriceCent) fail("PURCHASE_PRICE_OUT_OF_RANGE", "当前商品单价超出允许范围", price)
-        val selection = PurchaseSelectionEvidence.observe(snapshot)
-        return FinalConfirmationEvidence(
-            input.goodsId, input.mappedColor, input.mappedSize, input.quantity, price, address.suffix, snapshot.activityName.orEmpty(),
-            observedPurchaseQuantity(snapshot), selection.selectedSummaryPresent, selection.summaryPromptPresent,
-        )
+        val quantities = snapshot.nodes.filter { it.visible && it.enabled && it.className?.endsWith("EditText") == true }.mapNotNull { it.label.toLongOrNull() }
+        if (quantities.singleOrNull() != input.quantity) fail("PURCHASE_QUANTITY_MISMATCH", "创建订单前数量复核失败")
+        return FinalConfirmationEvidence(input.goodsId, input.mappedColor, input.mappedSize, input.quantity, price, address.suffix, snapshot.activityName.orEmpty())
     }
 
     fun submitOrderOnce() {
@@ -361,9 +337,8 @@ class PurchaseLiveAutomation(
         if (snapshot.packageName != PDD_PACKAGE || targets.size != 1) {
             fail("PURCHASE_SUBMIT_TARGET_AMBIGUOUS", "最终页面或创建订单按钮已变化，禁止创建订单")
         }
-        rejectSubmitSelectionPrompt(targets.single())
         submitAttempted = true
-        when (driver.clickFresh(targets.single().chosen)) {
+        when (driver.clickFresh(targets.single())) {
             FreshActionResult.SUCCESS -> Unit
             FreshActionResult.AMBIGUOUS -> fail("PURCHASE_SUBMIT_TARGET_AMBIGUOUS", "创建订单按钮不唯一")
             else -> fail("PURCHASE_ORDER_RESULT_UNKNOWN", "创建订单点击结果不明确，请人工检查")
@@ -904,24 +879,7 @@ class PurchaseLiveAutomation(
      * (Samsung: only a zero-size text node), fail explicitly (`bottom_row_unlabelled`) —
      * never fall back to a higher row.
      */
-    private data class SubmitTarget(val row: SnapshotNode, val chosen: SnapshotNode, val text: String)
-
-    internal fun selectionPromptPresent(snapshot: UiSnapshot): Boolean =
-        PurchaseSelectionEvidence.observe(snapshot).summaryPromptPresent ||
-            finalSubmitTargets(snapshot).singleOrNull()?.let { isSelectionPrompt(it.text) } == true
-
-    private fun isSelectionPrompt(text: String): Boolean =
-        Regex("^(选择|選擇).+(后|後)[，,](提交订单|提交訂單)$").matches(text.filterNot(Char::isWhitespace))
-
-    private fun rejectSubmitSelectionPrompt(target: SubmitTarget) {
-        if (isSelectionPrompt(target.text)) {
-            val detail = "finalSpec;stage=selection_prompt"
-            panelDiagnostic(detail)
-            fail("PURCHASE_SPEC_NOT_MATCHED", "创建订单前规格复核失败；$detail")
-        }
-    }
-
-    private fun finalSubmitTargets(snapshot: UiSnapshot): List<SubmitTarget> {
+    private fun finalSubmitTargets(snapshot: UiSnapshot): List<SnapshotNode> {
         fun hasArea(node: SnapshotNode) = node.bounds.width > 0 && node.bounds.height > 0
         val byPath = snapshot.nodes.associateBy { it.path }
         fun clickableAncestor(node: SnapshotNode): SnapshotNode? {
@@ -990,14 +948,7 @@ class PurchaseLiveAutomation(
                 "leafClass=${chosen.className};rowClass=${row.className};w=${row.bounds.width};h=${row.bounds.height};" +
                 "price=${hasPrice.diagFlag()};legacyMarker=${legacyMarker.diagFlag()};type=${screen.specPanelType}",
         )
-        // Prompt evidence uses each visible leaf's own label exactly once. A nested
-        // clickable button is a separate action and cannot supply text for this row.
-        val text = (listOf(row) + subtreeDescendants(row, snapshot)).filter { node ->
-            node.visible && node.label.isNotBlank() && clickableAncestor(node)?.path == row.path &&
-                subtreeDescendants(node, snapshot).none { it.label.isNotBlank() }
-        }.sortedWith(compareBy<SnapshotNode> { it.bounds.top }.thenBy { it.bounds.left })
-            .joinToString("") { it.label }
-        return listOf(SubmitTarget(row, chosen, text))
+        return listOf(chosen)
     }
 
     private fun subtreeDescendants(node: SnapshotNode, snapshot: UiSnapshot): List<SnapshotNode> {

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

@@ -772,11 +772,6 @@ class PurchaseRehearsalExecutor(
         val summaryTokenMatched = !token.isNullOrBlank() && SpecValueNormalizer.summaryHasExactToken(screen.selectedSummary, token)
         if (!summaryTokenMatched) {
             if (screen.selectedSummary == null && proofUsable) {
-                if (candidates.any { it.available && it.node.visible &&
-                        SpecValueNormalizer.normalizeFinalConfirmation(it.text) == SpecValueNormalizer.normalizeFinalConfirmation(target) &&
-                        !it.node.selected && !it.node.checked }) {
-                    return FinalSpecVerification(false, "target_visible_unselected", false, candidates.size, true, true, matchingNodes.size)
-                }
                 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)
@@ -808,15 +803,12 @@ class PurchaseRehearsalExecutor(
         target: String,
         proof: ExactSpecSelectionProof?,
     ): FinalSpecVerification {
-        var selectionPromptPresent = false
-        fun captureScreen() = currentScreen(input) { snapshot -> selectionPromptPresent = hasSelectionPrompt(snapshot) }
-        var screen = captureScreen()
+        var screen = currentScreen(input)
         screen.problem?.let {
             return FinalSpecVerification(false, it.code, false, 0, proof != null, false)
         }
-        if (selectionPromptPresent) return FinalSpecVerification(false, "selection_prompt", false, 0, proof != null, false)
         var verification = verifyExactSpecSelection(screen, dimension, target, proof)
-        if (verification.confirmed || verification.targetMatchCount > 0 || verification.reason in setOf("visible_selected_conflict", "selection_prompt", "target_visible_unselected")) return verification
+        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 ->
@@ -840,7 +832,7 @@ class PurchaseRehearsalExecutor(
                 }
                 swipes++
                 pause(300)
-                screen = captureScreen()
+                screen = currentScreen(input)
                 screen.problem?.let {
                     return verification.copy(
                         reason = it.code,
@@ -848,9 +840,6 @@ class PurchaseRehearsalExecutor(
                         relocationSwipes = swipes,
                     )
                 }
-                if (selectionPromptPresent) {
-                    return verification.copy(confirmed = false, reason = "selection_prompt", relocationAttempted = true, relocationSwipes = swipes)
-                }
                 if (!screen.specPanelOpen) {
                     return verification.copy(
                         reason = "relocation_panel_closed",
@@ -862,7 +851,7 @@ class PurchaseRehearsalExecutor(
                     relocationAttempted = true,
                     relocationSwipes = swipes,
                 )
-                if (verification.confirmed || verification.targetMatchCount > 0 || verification.reason in setOf("visible_selected_conflict", "selection_prompt", "target_visible_unselected")) return verification
+                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}" }}"
                 }
@@ -1140,9 +1129,6 @@ class PurchaseRehearsalExecutor(
             dimension to (normalizedTarget(dimension, rawTarget)
                 ?: return failure(SPEC_SAFE_TARGET_MISSING, "下发规格无法安全规范化"))
         }
-        if (selected.isEmpty() && hasSelectionPrompt(driver.capture())) {
-            return failure(SPEC_SELECTION_UNCONFIRMED, "最终规格复核未能确认精确选中状态 [reason=selection_prompt]")
-        }
         selected.forEach { (dimension, target) ->
             val verification = verifyExactSpecSelectionWithRelocation(input, dimension, target, selectionProofs[dimension])
             if (!verification.confirmed) {
@@ -1166,9 +1152,6 @@ class PurchaseRehearsalExecutor(
         return null
     }
 
-    private fun hasSelectionPrompt(snapshot: UiSnapshot): Boolean =
-        PurchaseLiveAutomation(driver, pause, panelDiagnostic).selectionPromptPresent(snapshot)
-
     private fun hasAllRecordedSelectionProofs(
         input: PurchaseExecutionInput,
         proofs: Map<String, ExactSpecSelectionProof>,
@@ -1236,9 +1219,8 @@ class PurchaseRehearsalExecutor(
         return normalized.takeIf(SpecValueNormalizer::isSafeSize)
     }
 
-    private fun currentScreen(input: PurchaseExecutionInput, snapshotObserved: (UiSnapshot) -> Unit = {}): ParsedPddScreen {
+    private fun currentScreen(input: PurchaseExecutionInput): ParsedPddScreen {
         val snapshot = driver.capture()
-        snapshotObserved(snapshot)
         val screen = PddScreenParser.parse(snapshot, DEFAULT_COLLECTOR, input.goodsId, null, purchasePanelContext)
         purchasePanelContext = if (screen.isPddPackage && screen.problem == null && screen.specPanelOpen) {
             screen.specPanelContainer?.let {

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

@@ -1,68 +0,0 @@
-package cn.ilapage.goauto.agent.automation
-
-/** Boolean-only summary observations within the #374 bounded quantity panel. */
-internal data class PurchaseSelectionEvidence(
-    val selectedSummaryPresent: Boolean = false,
-    val summaryPromptPresent: Boolean = false,
-) {
-    companion object {
-        fun observe(snapshot: UiSnapshot): PurchaseSelectionEvidence {
-            val config = PurchaseRehearsalExecutor.DEFAULT_COLLECTOR
-            val original = PddScreenParser.parse(snapshot, config, "", null)
-            val panel = boundedQuantityPanel(snapshot).takeIf { original.specPanelOpen }
-                ?: return PurchaseSelectionEvidence()
-            val byPath = snapshot.nodes.associateBy(SnapshotNode::path)
-            fun within(node: SnapshotNode): Boolean {
-                val visited = mutableSetOf<String>()
-                var current: SnapshotNode? = node
-                while (current != null && visited.add(current.path)) {
-                    if (current.path == panel.path) return true
-                    current = current.parentPath?.let(byPath::get)
-                }
-                return false
-            }
-            fun contained(node: SnapshotNode) = node.bounds.width > 0 && node.bounds.height > 0 &&
-                node.bounds.left >= panel.bounds.left && node.bounds.right <= panel.bounds.right &&
-                node.bounds.top >= panel.bounds.top && node.bounds.bottom <= panel.bounds.bottom
-            val nodes = snapshot.nodes.filter { (within(it) && contained(it)) ||
-                (it.parentPath == null && it.label.isBlank() && !it.clickable) }
-            val scoped = PddScreenParser.parse(snapshot.copy(nodes = nodes), config, "", null, forFinalConfirmation = true)
-            if (!scoped.specPanelOpen) return PurchaseSelectionEvidence()
-            val quantity = nodes.singleOrNull { it.visible && it.enabled && it.className == "android.widget.EditText" && it.label.toIntOrNull()?.let { value -> value > 0 } == true }
-            val firstOptionTop = scoped.dimensions.flatMap(VisibleDimension::values).minOfOrNull { it.node.bounds.top } ?: Int.MAX_VALUE
-            val prompt = quantity != null && nodes.any { node ->
-                node.visible && !node.clickable && node.className?.endsWith("TextView") == true &&
-                    node.bounds.bottom <= minOf(quantity.bounds.top, firstOptionTop) &&
-                    node.label.filterNot(Char::isWhitespace).let { it.startsWith("请选择") || it.startsWith("請選擇") }
-            }
-            val selected = scoped.finalSelectionSummaries.any { raw ->
-                val compact = raw.filterNot(Char::isWhitespace)
-                config.textAliases.selection.selectedPrefixes.any(compact::startsWith)
-            }
-            return PurchaseSelectionEvidence(selected, prompt)
-        }
-
-        /** Retains #374's real ancestry and bounded full sheet, not the inner option list. */
-        private fun boundedQuantityPanel(snapshot: UiSnapshot): SnapshotNode? {
-            val visible = snapshot.nodes.filter(SnapshotNode::visible)
-            val screenWidth = visible.maxOfOrNull { it.bounds.right } ?: return null
-            val screenHeight = visible.maxOfOrNull { it.bounds.bottom } ?: return null
-            val screenArea = screenWidth.toLong() * screenHeight
-            val byPath = visible.associateBy(SnapshotNode::path)
-            var current = visible.singleOrNull {
-                it.enabled && it.className == "android.widget.EditText" && it.label.toIntOrNull()?.let { value -> value > 0 } == true
-            } ?: return null
-            var panel: SnapshotNode? = null
-            val visited = mutableSetOf(current.path)
-            while (true) {
-                val parent = current.parentPath?.let(byPath::get) ?: break
-                if (!visited.add(parent.path)) return null
-                val area = parent.bounds.width.toLong() * parent.bounds.height
-                if (area <= 0 || area >= screenArea || parent.parentPath == null) break
-                panel = parent
-                current = parent
-            }
-            return panel
-        }
-    }
-}

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

@@ -35,6 +35,7 @@ data class HeartbeatResult(
     val online: Boolean,
     val busy: Boolean,
     val heartbeatIntervalSeconds: Int,
+    val acceptsClientReport: Boolean = false,
 )
 
 data class AgentAppRelease(
@@ -221,7 +222,10 @@ class AgentApiException(
     val retryable: Boolean,
 ) : Exception(message)
 
-class AgentApiClient(private val serverUrl: String) {
+class AgentApiClient(
+    internal val serverUrl: String,
+    private val connectionFactory: (URL) -> HttpURLConnection = { it.openConnection() as HttpURLConnection },
+) {
     @Volatile var lastResponseServerTimeMillis: Long? = null
         private set
     val failureSnapshotOrigin: String get() = ServerUrlPolicy.normalize(serverUrl)
@@ -309,17 +313,19 @@ class AgentApiClient(private val serverUrl: String) {
         )
     }
 
-    fun heartbeat(token: String, currentTaskId: Long?, capabilities: List<String> = emptyList()): HeartbeatResult {
+    fun heartbeat(token: String, currentTaskId: Long?, capabilities: List<String> = emptyList(), clientReport: JSONObject? = null, requestId: String = UUID.randomUUID().toString()): HeartbeatResult {
         val payload = JSONObject()
-            .put("requestId", UUID.randomUUID().toString())
+            .put("requestId", requestId)
             .put("currentTaskId", currentTaskId ?: JSONObject.NULL)
             .put("capabilities", JSONArray(capabilities))
+        if (clientReport != null) payload.put("clientReport", clientReport)
         val data = post("/api/agent/v1/heartbeat", payload, token).getJSONObject("data")
         return HeartbeatResult(
             deviceId = data.getLong("deviceId"),
             online = data.getBoolean("online"),
             busy = data.getBoolean("busy"),
             heartbeatIntervalSeconds = data.optInt("heartbeatIntervalSeconds", 15),
+            acceptsClientReport = data.opt("acceptsClientReport") == true,
         )
     }
 
@@ -707,7 +713,7 @@ class AgentApiClient(private val serverUrl: String) {
     }
 
     private fun request(method: String, path: String, payload: JSONObject?, token: String?, recoveryCode: String? = null): JSONObject? {
-        val connection = (URL(serverUrl + path).openConnection() as HttpURLConnection).apply {
+        val connection = connectionFactory(URL(serverUrl + path)).apply {
             requestMethod = method
             connectTimeout = 10_000
             readTimeout = 15_000
@@ -719,10 +725,14 @@ class AgentApiClient(private val serverUrl: String) {
             if (!token.isNullOrBlank()) setRequestProperty("Authorization", "Bearer $token")
             if (!recoveryCode.isNullOrBlank()) setRequestProperty("X-GoAuto-Device-Recovery-Code", recoveryCode)
         }
+        var stage = RequestStage.CONNECT
         try {
+            connection.connect()
+            stage = RequestStage.UNKNOWN
             if (payload != null) {
                 connection.outputStream.use { it.write(payload.toString().toByteArray(Charsets.UTF_8)) }
             }
+            stage = RequestStage.RESPONSE
             val status = connection.responseCode
             // Metadata only: batch cutoff must use the API clock, never the phone's clock.
             // A missing Date invalidates the sample instead of retaining an older response.
@@ -740,6 +750,8 @@ class AgentApiClient(private val serverUrl: String) {
                 )
             }
             return json
+        } catch (error: java.net.SocketTimeoutException) {
+            throw AgentTransportTimeout(stage, error)
         } finally {
             connection.disconnect()
         }

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

@@ -0,0 +1,65 @@
+package cn.ilapage.goauto.agent.network
+
+import java.util.UUID
+import org.json.JSONObject
+
+/** Service lifetime, never persisted: a new process must negotiate again. */
+internal class HeartbeatReportNegotiation {
+    var acceptsReport = false
+        private set
+
+    private var origin: String? = null
+    private var token: String? = null
+
+    fun heartbeat(
+        api: AgentApiClient,
+        token: String,
+        taskId: Long?,
+        capabilities: List<String>,
+        report: () -> JSONObject?,
+        ack: () -> Unit,
+        validate: (HeartbeatResult) -> Unit = {},
+    ): HeartbeatResult {
+        if (origin != api.serverUrl || this.token != token) {
+            acceptsReport = false
+            origin = api.serverUrl
+            this.token = token
+        }
+        val snapshot = if (acceptsReport) report() else null
+        val requestId = UUID.randomUUID().toString()
+        val result =
+            try {
+                api.heartbeat(token, taskId, capabilities, snapshot, requestId)
+            } catch (error: AgentApiException) {
+                if (
+                    snapshot == null ||
+                        error.status != 422 ||
+                        error.code != "INVALID_REQUEST" ||
+                        error.message != "请求 JSON 无效"
+                )
+                    throw error
+                acceptsReport = false
+                // A fallback is never an acknowledgement or a capability grant.
+                return api.heartbeat(token, taskId, capabilities, null, requestId).also(validate)
+            }
+        validate(result)
+        acceptsReport = result.acceptsClientReport
+        if (snapshot != null) ack()
+        return result
+    }
+}
+
+internal enum class RequestStage {
+    CONNECT,
+    RESPONSE,
+    UNKNOWN,
+}
+
+internal class AgentTransportTimeout(
+    val stage: RequestStage,
+    cause: java.net.SocketTimeoutException,
+) : java.net.SocketTimeoutException("agent_transport_timeout") {
+    init {
+        initCause(cause)
+    }
+}

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

@@ -1,7 +1,22 @@
 package cn.ilapage.goauto.agent.persistence
 
 internal object AgentDiagnosticSchema {
-    const val VERSION = 5
+    const val VERSION = 6
+
+    val syncStatements = listOf(
+        """CREATE TABLE IF NOT EXISTS sync_round (
+            id INTEGER PRIMARY KEY AUTOINCREMENT, process_id TEXT NOT NULL,
+            started_at INTEGER NOT NULL, ended_at INTEGER, duration_ms INTEGER, start_gap_ms INTEGER,
+            device_id INTEGER, task_id INTEGER, attempt_id TEXT, phase TEXT,
+            validated_network INTEGER, transport TEXT NOT NULL, foreground INTEGER NOT NULL,
+            status TEXT NOT NULL, steps TEXT NOT NULL DEFAULT '[]',
+            failure_at INTEGER, failure_step TEXT, failure_category TEXT, failure_duration_ms INTEGER,
+            http_status INTEGER, api_code TEXT, exception_class TEXT,
+            completion_seq INTEGER, reported INTEGER NOT NULL DEFAULT 0
+        )""".trimIndent(),
+        "CREATE TABLE IF NOT EXISTS sync_meta (id INTEGER PRIMARY KEY CHECK(id=1), sequence INTEGER NOT NULL)",
+        "INSERT OR IGNORE INTO sync_meta(id,sequence) VALUES(1,0)",
+    )
 
     val failureSnapshotStatements = listOf(
         """CREATE TABLE IF NOT EXISTS purchase_failure_snapshot (
@@ -99,5 +114,6 @@ internal object AgentDiagnosticSchema {
             (if (oldVersion < 4 && newVersion >= 4) failureSnapshotStatements else emptyList()) +
             (if (oldVersion < 5 && newVersion >= 5) colorDiscoveryOutcomeColumns.mapNotNull { (name, definition) ->
                 if (name in existingColumns) null else "ALTER TABLE agent_diagnostic ADD COLUMN $name $definition"
-            } else emptyList())
+            } else emptyList()) +
+            (if (oldVersion < 6 && newVersion >= 6) syncStatements else emptyList())
 }

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

@@ -150,6 +150,7 @@ class AgentDiagnosticStore(context: Context) : SQLiteOpenHelper(context, DATABAS
         db.execSQL(AgentDiagnosticSchema.createTableSql)
         db.execSQL("CREATE INDEX idx_agent_diagnostic_task ON agent_diagnostic(task_id, id)")
         AgentDiagnosticSchema.failureSnapshotStatements.forEach(db::execSQL)
+        AgentDiagnosticSchema.syncStatements.forEach(db::execSQL)
     }
 
     override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {

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

@@ -1,15 +1,30 @@
 package cn.ilapage.goauto.agent.persistence
 
+import cn.ilapage.goauto.agent.network.AgentApiException
+
+object PurchaseRejectionPolicy {
+    val codes = setOf("PURCHASE_STATE_CONFLICT", "PURCHASE_LEASE_EXPIRED", "PURCHASE_RESULT_CONFLICT")
+    fun terminalCode(error: Exception): String? = (error as? AgentApiException)
+        ?.takeIf { it.status == 409 && it.code in codes }?.code
+}
+
 /** Uploads already-persisted results only; it never invokes device automation. */
 class PurchaseOutboxUploader(
     private val pending: () -> List<PendingPurchaseOutbox>,
     private val submit: (PendingPurchaseOutbox) -> Unit,
     private val markUploaded: (PendingPurchaseOutbox) -> Unit,
     private val afterUploaded: (PendingPurchaseOutbox) -> Unit = {},
+    private val markRejected: (PendingPurchaseOutbox, String) -> Unit = { _, _ -> error("Rejection persistence not configured") },
 ) {
     fun flush() {
         pending().forEach { item ->
-            submit(item)
+            try {
+                submit(item)
+            } catch (error: Exception) {
+                val code = PurchaseRejectionPolicy.terminalCode(error) ?: throw error
+                markRejected(item, code)
+                return@forEach
+            }
             markUploaded(item)
             afterUploaded(item)
         }

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

@@ -0,0 +1,27 @@
+package cn.ilapage.goauto.agent.persistence
+
+data class RejectedPurchaseResult(
+    val id: Long, val taskId: Long, val attemptId: String, val payloadJson: String,
+    val rejectedAt: Long, val errorCode: String, val acknowledgedAt: Long?,
+)
+
+internal object PurchaseRejectionSql {
+    val migration = listOf(
+        "ALTER TABLE purchase_outbox ADD COLUMN rejected_at INTEGER",
+        "ALTER TABLE purchase_outbox ADD COLUMN rejection_error_code TEXT",
+        "ALTER TABLE purchase_outbox ADD COLUMN acknowledged_at INTEGER",
+    )
+    const val activeTask = "SELECT task_id FROM purchase_task WHERE upload_status != 'rejected' AND (status IN ('running','order_submit_started') OR upload_status='pending') ORDER BY updated_at ASC LIMIT 1"
+    const val acknowledge = "UPDATE purchase_outbox SET acknowledged_at=? WHERE id=? AND upload_status='rejected' AND acknowledged_at IS NULL"
+
+    /** The caller must wrap both writes in one transaction. Zero task rows means a newer attempt replaced it. */
+    fun reject(item: PendingPurchaseOutbox, code: String, now: Long, update: (String, List<Any>) -> Int) {
+        require(code in PurchaseRejectionPolicy.codes)
+        check(update(
+            "UPDATE purchase_outbox SET upload_status='rejected',rejected_at=?,rejection_error_code=?,updated_at=? WHERE id=? AND task_id=? AND attempt_id=? AND upload_status='pending'",
+            listOf(now, code, now, item.id, item.taskId, item.attemptId),
+        ) == 1)
+        update("UPDATE purchase_task SET upload_status='rejected',updated_at=? WHERE task_id=? AND attempt_id=?",
+            listOf(now, item.taskId, item.attemptId))
+    }
+}

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

@@ -66,6 +66,7 @@ class PurchaseTaskStore(context: Context) : SQLiteOpenHelper(context, DATABASE_N
         )
         db.execSQL("CREATE INDEX idx_purchase_outbox_pending ON purchase_outbox(upload_status, id)")
         db.execSQL("CREATE INDEX idx_purchase_attempt_task ON purchase_attempt(task_id, created_at)")
+        PurchaseRejectionSql.migration.forEach(db::execSQL)
     }
 
     override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
@@ -74,6 +75,7 @@ class PurchaseTaskStore(context: Context) : SQLiteOpenHelper(context, DATABASE_N
             db.execSQL("ALTER TABLE purchase_task ADD COLUMN final_confirmation_json TEXT")
             db.execSQL("ALTER TABLE purchase_task ADD COLUMN irreversible_at INTEGER")
         }
+        if (oldVersion < 3 && newVersion >= 3) PurchaseRejectionSql.migration.forEach(db::execSQL)
     }
 
     @Synchronized
@@ -225,8 +227,8 @@ class PurchaseTaskStore(context: Context) : SQLiteOpenHelper(context, DATABASE_N
 
     @Synchronized
     fun activeTaskId(): Long? = readableDatabase.rawQuery(
-        "SELECT task_id FROM purchase_task WHERE status IN (?,?) OR upload_status=? ORDER BY updated_at ASC LIMIT 1",
-        arrayOf(STATUS_RUNNING, STATUS_ORDER_SUBMIT_STARTED, UPLOAD_PENDING),
+        PurchaseRejectionSql.activeTask,
+        null,
     ).use { cursor -> if (cursor.moveToFirst()) cursor.getLong(0) else null }
 
     @Synchronized
@@ -243,9 +245,53 @@ class PurchaseTaskStore(context: Context) : SQLiteOpenHelper(context, DATABASE_N
         }
     }
 
+    @Synchronized
+    fun markRejected(item: PendingPurchaseOutbox, code: String) {
+        val db = writableDatabase
+        db.beginTransaction()
+        try {
+            PurchaseRejectionSql.reject(item, code, System.currentTimeMillis()) { sql, args ->
+                db.compileStatement(sql).use { statement ->
+                    args.forEachIndexed { index, value ->
+                        if (value is Long) statement.bindLong(index + 1, value)
+                        else statement.bindString(index + 1, value.toString())
+                    }
+                    statement.executeUpdateDelete()
+                }
+            }
+            db.setTransactionSuccessful()
+        } finally { db.endTransaction() }
+    }
+
+    @Synchronized
+    fun rejectedResults(): List<RejectedPurchaseResult> = readableDatabase.rawQuery(
+        "SELECT id,task_id,attempt_id,payload_json,rejected_at,rejection_error_code,acknowledged_at FROM purchase_outbox WHERE upload_status='rejected' ORDER BY id DESC", null,
+    ).use { cursor -> buildList {
+        while (cursor.moveToNext()) add(RejectedPurchaseResult(
+            cursor.getLong(0), cursor.getLong(1), cursor.getString(2), cursor.getString(3),
+            cursor.getLong(4), cursor.getString(5), if (cursor.isNull(6)) null else cursor.getLong(6),
+        ))
+    } }
+
+    @Synchronized
+    fun rejectedCount(): Int = readableDatabase.rawQuery(
+        "SELECT COUNT(*) FROM purchase_outbox WHERE upload_status='rejected'", null,
+    ).use { it.moveToFirst(); it.getInt(0) }
+
+    @Synchronized
+    fun isCurrentAttemptRejected(taskId: Long, attemptId: String): Boolean = readableDatabase.rawQuery(
+        "SELECT 1 FROM purchase_task WHERE task_id=? AND attempt_id=? AND upload_status='rejected'",
+        arrayOf(taskId.toString(), attemptId),
+    ).use { it.moveToFirst() }
+
+    @Synchronized
+    fun acknowledgeRejection(outboxId: Long) {
+        writableDatabase.execSQL(PurchaseRejectionSql.acknowledge, arrayOf(System.currentTimeMillis(), outboxId))
+    }
+
     companion object {
         private const val DATABASE_NAME = "goauto_purchase.db"
-        private const val DATABASE_VERSION = 2
+        private const val DATABASE_VERSION = 3
         private const val STATUS_RUNNING = "running"
         const val STATUS_ORDER_SUBMIT_STARTED = "order_submit_started"
         private const val STATUS_COMPLETED = "completed"

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

@@ -0,0 +1,234 @@
+package cn.ilapage.goauto.agent.persistence
+
+import cn.ilapage.goauto.agent.network.AgentApiException
+import cn.ilapage.goauto.agent.network.AgentTransportTimeout
+import cn.ilapage.goauto.agent.network.RequestStage
+import java.util.concurrent.CancellationException
+import org.json.JSONArray
+import org.json.JSONObject
+
+/** Collection and purchase IDs belong to separate domains and can have the same numeric value. */
+internal fun syncTaskIdentity(
+    taskId: Long?,
+    taskType: String?,
+    executionActive: Boolean,
+    live: SyncContext?,
+    recoveredAttempt: () -> String?,
+): SyncContext {
+    if (taskType == "purchase" && live?.taskId == taskId && live != null) return live
+    return SyncContext(
+        taskId = taskId,
+        attemptId = if (!executionActive && taskId != null) recoveredAttempt() else null,
+    )
+}
+
+/** Only fixed classifications enter this store; exception text, URLs and payloads never do. */
+internal fun syncFailure(error: Exception, step: String, at: Long, duration: Long): SyncFailure {
+    val api = error as? AgentApiException
+    val timeout = error as? AgentTransportTimeout
+    val category =
+        when {
+            api != null ->
+                when {
+                    cn.ilapage.goauto.agent.service.isAgentAuthenticationError(api) -> "api_auth"
+                    api.status == 409 -> "api_conflict"
+                    api.status >= 500 -> "api_server"
+                    else -> "api_other"
+                }
+            timeout != null ->
+                when (timeout.stage) {
+                    RequestStage.CONNECT -> "timeout_connect"
+                    RequestStage.RESPONSE -> "timeout_response"
+                    RequestStage.UNKNOWN -> "timeout_unknown"
+                }
+            error is java.net.SocketTimeoutException -> "timeout_unknown"
+            error is java.io.IOException -> "network"
+            else -> "exception"
+        }
+    val code =
+        api?.code?.takeIf {
+            it in
+                setOf(
+                    "DEVICE_TOKEN_INVALID",
+                    "DEVICE_DISABLED",
+                    "DEVICE_INSTALL_ID_CONFLICT",
+                    "DEVICE_TASK_MISMATCH",
+                    "INVALID_REQUEST",
+                    "PURCHASE_STATE_CONFLICT",
+                    "PURCHASE_LEASE_EXPIRED",
+                    "PURCHASE_RESULT_CONFLICT",
+                )
+        }
+    val type =
+        when (error) {
+            is java.net.SocketTimeoutException -> "SocketTimeoutException"
+            is java.net.UnknownHostException -> "UnknownHostException"
+            is java.net.ConnectException -> "ConnectException"
+            is javax.net.ssl.SSLException -> "SSLException"
+            is java.net.SocketException -> "SocketException"
+            is java.io.EOFException -> "EOFException"
+            else -> null
+        }
+    return SyncFailure(
+        step,
+        category,
+        at.coerceAtLeast(1),
+        duration.coerceAtLeast(0),
+        api?.status,
+        code,
+        type,
+    )
+}
+
+internal class SyncDiagnosticRecorder(
+    private val store: SyncDiagnosticStore,
+    private val process: String,
+    private val wall: () -> Long,
+    private val elapsed: () -> Long,
+    private val warning: () -> Unit = {},
+) {
+    private var previousStart: Long? = null
+
+    fun begin(context: SyncContext): Round {
+        val start = elapsed()
+        val at = wall()
+        val gap = previousStart?.let { (start - it).coerceAtLeast(0) }
+        previousStart = start
+        val id = safe { store.start(process, at, gap, context) }
+        val round = Round(id, at, start)
+        round.persistSteps()
+        safe { store.cleanup(at) }
+        return round
+    }
+
+    fun snapshot(): SyncReportSnapshot? = safe { store.snapshot(process, wall()) }
+
+    fun ack(snapshot: SyncReportSnapshot) {
+        safe { store.ack(snapshot) }
+    }
+
+    private fun <T> safe(action: () -> T): T? =
+        try {
+            action()
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Exception) {
+            try {
+                warning()
+            } catch (cancel: CancellationException) {
+                throw cancel
+            } catch (ignored: Exception) {}
+            null
+        }
+
+    inner class Round(private val id: Long?, at: Long, private val start: Long) {
+        private val entries =
+            JSONArray()
+                .put(
+                    JSONObject()
+                        .put("ordinal", 0)
+                        .put("step", "sync")
+                        .put("startedAt", at)
+                        .put("startedOffsetMs", 0)
+                        .put("status", "running")
+                )
+        private var failure: SyncFailure? = null
+        private var persistenceFailed = id == null
+        private var aborted = false
+        private var completed = false
+        private var activeStep: Pair<JSONObject, Long>? = null
+
+        fun <T> step(name: String, action: () -> T): T {
+            require(name in setOf("register", "heartbeat", "recover", "flush", "claim"))
+            val begin = elapsed()
+            val entry =
+                JSONObject()
+                    .put("ordinal", entries.length())
+                    .put("step", name)
+                    .put("startedAt", wall())
+                    .put("startedOffsetMs", (begin - start).coerceAtLeast(0))
+                    .put("status", "running")
+            entries.put(entry)
+            activeStep = entry to begin
+            persistSteps()
+            try {
+                val value = action()
+                if (entry.getString("status") != "failure") entry.put("status", "success")
+                return value
+            } catch (e: CancellationException) {
+                aborted = true
+                throw e
+            } catch (e: Exception) {
+                failure = syncFailure(e, name, wall(), elapsed() - begin)
+                entry.put("status", "failure").put("category", failure!!.category)
+                throw e
+            } catch (e: Error) {
+                aborted = true
+                throw e
+            } finally {
+                if (!aborted) {
+                    entry
+                        .put("endedAt", wall())
+                        .put("endedOffsetMs", (elapsed() - start).coerceAtLeast(0))
+                        .put("durationMs", (elapsed() - begin).coerceAtLeast(0))
+                    persistSteps()
+                }
+                activeStep = null
+            }
+        }
+
+        /**
+         * Observe a business-handled exception without changing that operation's return/throw
+         * policy.
+         */
+        fun handledFailure(error: Exception) {
+            if (error is CancellationException) {
+                aborted = true
+                throw error
+            }
+            val (entry, begin) = activeStep ?: return failed(error)
+            failure = syncFailure(error, entry.getString("step"), wall(), elapsed() - begin)
+            entry.put("status", "failure").put("category", failure!!.category)
+            persistSteps()
+        }
+
+        fun failed(error: Exception) {
+            if (error is CancellationException) {
+                aborted = true
+                throw error
+            }
+            if (failure == null) failure = syncFailure(error, "sync", wall(), elapsed() - start)
+        }
+
+        fun abort() {
+            aborted = true
+        }
+
+        fun finish() {
+            if (completed || aborted) return
+            completed = true
+            entries
+                .getJSONObject(0)
+                .put("endedAt", wall())
+                .put("endedOffsetMs", (elapsed() - start).coerceAtLeast(0))
+                .put("durationMs", (elapsed() - start).coerceAtLeast(0))
+                .put("status", if (failure == null) "success" else "failure")
+            persistSteps()
+            // A failed start/step write must never turn an incomplete durable trace into a fake
+            // success.
+            if (!persistenceFailed && id != null)
+                safe { store.finish(id, wall(), (elapsed() - start).coerceAtLeast(0), failure) }
+        }
+
+        internal fun persistSteps() {
+            if (
+                id != null &&
+                    safe {
+                        store.steps(id, entries.toString())
+                        true
+                    } != true
+            )
+                persistenceFailed = true
+        }
+    }
+}

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

@@ -0,0 +1,218 @@
+package cn.ilapage.goauto.agent.persistence
+
+import android.database.sqlite.SQLiteDatabase
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import java.util.TimeZone
+import org.json.JSONObject
+
+/** Shared SQL is exercised against SQLite JDBC; Android only supplies the driver. */
+internal interface SyncSql {
+    fun execute(sql: String, args: List<Any?> = emptyList())
+
+    fun query(sql: String, args: List<Any?> = emptyList()): List<Map<String, String?>>
+
+    fun <T> transaction(block: () -> T): T
+}
+
+internal class AndroidSyncSql(private val open: () -> SQLiteDatabase) : SyncSql {
+    override fun execute(sql: String, args: List<Any?>) = open().execSQL(sql, args.toTypedArray())
+
+    override fun query(sql: String, args: List<Any?>): List<Map<String, String?>> =
+        open().rawQuery(sql, args.map { it?.toString() }.toTypedArray()).use { c ->
+            buildList {
+                while (c.moveToNext()) add(
+                    c.columnNames.associateWith { name ->
+                        val i = c.getColumnIndexOrThrow(name)
+                        if (c.isNull(i)) null else c.getString(i)
+                    }
+                )
+            }
+        }
+
+    override fun <T> transaction(block: () -> T): T {
+        val db = open()
+        db.beginTransaction()
+        try {
+            val result = block()
+            db.setTransactionSuccessful()
+            return result
+        } finally {
+            db.endTransaction()
+        }
+    }
+}
+
+internal data class SyncContext(
+    val deviceId: Long? = null,
+    val taskId: Long? = null,
+    val attemptId: String? = null,
+    val phase: String? = null,
+    val validatedNetwork: Boolean? = null,
+    val transport: String = "unknown",
+    val foreground: Boolean = true,
+)
+
+internal data class SyncFailure(
+    val step: String,
+    val category: String,
+    val at: Long,
+    val durationMs: Long,
+    val httpStatus: Int? = null,
+    val apiCode: String? = null,
+    val exceptionClass: String? = null,
+)
+
+internal data class SyncReportSnapshot(val report: JSONObject, val boundary: Long)
+
+internal class SyncDiagnosticStore(private val db: SyncSql) {
+    @Synchronized
+    fun start(process: String, at: Long, gap: Long?, context: SyncContext): Long =
+        db.transaction {
+            db.execute(
+                "INSERT INTO sync_round(process_id,started_at,start_gap_ms,device_id,task_id,attempt_id,phase,validated_network,transport,foreground,status) VALUES(?,?,?,?,?,?,?,?,?,?,'running')",
+                listOf(
+                    process,
+                    at,
+                    gap,
+                    context.deviceId?.takeIf { it > 0 },
+                    context.taskId?.takeIf { it > 0 },
+                    context.attemptId?.takeIf { ATTEMPT_UUID.matches(it) },
+                    context.phase?.takeIf { it in setOf("spec_probe", "purchase") },
+                    context.validatedNetwork?.let { if (it) 1 else 0 },
+                    context.transport.takeIf { it in setOf("wifi", "cellular", "none", "unknown") }
+                        ?: "unknown",
+                    if (context.foreground) 1 else 0,
+                ),
+            )
+            db.query("SELECT last_insert_rowid() AS id").single().getValue("id")!!.toLong()
+        }
+
+    @Synchronized
+    fun steps(id: Long, json: String) {
+        db.execute(
+            "UPDATE sync_round SET steps=? WHERE id=? AND status='running'",
+            listOf(json, id),
+        )
+    }
+
+    @Synchronized
+    fun finish(id: Long, at: Long, duration: Long, failure: SyncFailure?) =
+        db.transaction {
+            val sequence = nextSequence()
+            db.execute(
+                "UPDATE sync_round SET ended_at=?,duration_ms=?,status=?,failure_at=?,failure_step=?,failure_category=?,failure_duration_ms=?,http_status=?,api_code=?,exception_class=?,completion_seq=? WHERE id=? AND status='running'",
+                listOf(
+                    at,
+                    duration,
+                    if (failure == null) "success" else "failure",
+                    failure?.at,
+                    failure?.step,
+                    failure?.category,
+                    failure?.durationMs,
+                    failure?.httpStatus,
+                    failure?.apiCode,
+                    failure?.exceptionClass,
+                    sequence,
+                    id,
+                ),
+            )
+        }
+
+    @Synchronized
+    fun cleanup(now: Long) =
+        db.transaction {
+            db.execute("DELETE FROM sync_round WHERE started_at < ?", listOf(now - RETENTION_MS))
+            db.execute(
+                "DELETE FROM sync_round WHERE id NOT IN (SELECT id FROM sync_round ORDER BY id DESC LIMIT 6000)"
+            )
+        }
+
+    @Synchronized
+    fun snapshot(process: String, now: Long): SyncReportSnapshot? =
+        db.transaction {
+            val cutoff = now - RETENTION_MS
+            val boundary =
+                db.query("SELECT sequence FROM sync_meta WHERE id=1")
+                    .single()
+                    .getValue("sequence")!!
+                    .toLong()
+            val failures =
+                db.query(
+                    "SELECT * FROM sync_round WHERE status='failure' AND reported=0 AND completion_seq<=? AND started_at>=? ORDER BY completion_seq DESC",
+                    listOf(boundary, cutoff),
+                )
+            val previous =
+                db.query(
+                        "SELECT duration_ms FROM sync_round WHERE status!='running' AND started_at>=? ORDER BY completion_seq DESC LIMIT 1",
+                        listOf(cutoff),
+                    )
+                    .firstOrNull()
+            val interrupted =
+                db.query(
+                        "SELECT MAX(id) AS id FROM sync_round WHERE status='running' AND process_id!=? AND started_at>=?",
+                        listOf(process, cutoff),
+                    )
+                    .single()["id"]
+                    ?.toLong() ?: 0L
+            val sequence = nextSequence()
+            val latest = failures.firstOrNull()
+            val report =
+                JSONObject()
+                    .put("snapshotSeq", sequence)
+                    .put("failedRounds", failures.size)
+                    .put(
+                        "latestFailureAt",
+                        latest?.get("failure_at")?.toLong()?.let(::isoTime) ?: JSONObject.NULL,
+                    )
+                    .put("latestFailureStep", latest?.get("failure_step") ?: JSONObject.NULL)
+                    .put(
+                        "latestFailureCategory",
+                        latest?.get("failure_category") ?: JSONObject.NULL,
+                    )
+                    .put(
+                        "latestFailureDurationMs",
+                        latest?.get("failure_duration_ms")?.toLong()?.coerceIn(0, RETENTION_MS)
+                            ?: JSONObject.NULL,
+                    )
+                    .put(
+                        "previousSyncDurationMs",
+                        previous?.get("duration_ms")?.toLong()?.coerceIn(0, RETENTION_MS)
+                            ?: JSONObject.NULL,
+                    )
+                    .put("hasInterruptedRound", interrupted > 0)
+            check(
+                sequence in 1..9_007_199_254_740_991L &&
+                    report.toString().toByteArray(Charsets.UTF_8).size <= 2048
+            )
+            SyncReportSnapshot(report, boundary)
+        }
+
+    @Synchronized
+    fun ack(snapshot: SyncReportSnapshot) =
+        db.transaction {
+            db.execute(
+                "UPDATE sync_round SET reported=1 WHERE status!='running' AND completion_seq<=?",
+                listOf(snapshot.boundary),
+            )
+        }
+
+    private fun nextSequence(): Long {
+        db.execute("UPDATE sync_meta SET sequence=sequence+1 WHERE id=1")
+        return db.query("SELECT sequence FROM sync_meta WHERE id=1")
+            .single()
+            .getValue("sequence")!!
+            .toLong()
+    }
+
+    companion object {
+        const val RETENTION_MS = 86_400_000L
+        private val ATTEMPT_UUID = Regex("[0-9a-fA-F]{8}(-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}")
+
+        private fun isoTime(time: Long) =
+            SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.US)
+                .apply { timeZone = TimeZone.getTimeZone("UTC") }
+                .format(Date(time))
+    }
+}

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

@@ -57,6 +57,13 @@ import cn.ilapage.goauto.agent.automation.RuleValidationException
 import cn.ilapage.goauto.agent.identity.SecureDeviceStore
 import cn.ilapage.goauto.agent.network.AgentApiClient
 import cn.ilapage.goauto.agent.network.AgentApiException
+import cn.ilapage.goauto.agent.network.HeartbeatReportNegotiation
+import cn.ilapage.goauto.agent.persistence.AndroidSyncSql
+import cn.ilapage.goauto.agent.persistence.SyncContext
+import cn.ilapage.goauto.agent.persistence.SyncDiagnosticRecorder
+import cn.ilapage.goauto.agent.persistence.SyncDiagnosticStore
+import cn.ilapage.goauto.agent.persistence.SyncReportSnapshot
+import cn.ilapage.goauto.agent.persistence.syncTaskIdentity
 import cn.ilapage.goauto.agent.network.DeviceInfo
 import cn.ilapage.goauto.agent.network.PurchaseAgentTask
 import cn.ilapage.goauto.agent.network.ServerUrlPolicy
@@ -115,6 +122,10 @@ class AgentForegroundService : Service() {
     private lateinit var stateStore: AgentStateStore
     private lateinit var purchaseStore: PurchaseTaskStore
     private lateinit var diagnosticStore: AgentDiagnosticStore
+    private lateinit var syncDiagnostics: SyncDiagnosticRecorder
+    private val heartbeatReports = HeartbeatReportNegotiation()
+    private val syncTaskContext = AtomicReference<SyncContext?>(null)
+    @Volatile private var foregroundStarted = false
     private lateinit var diagnosticRecorder: SafeAgentDiagnosticRecorder
     private lateinit var failureSnapshotStore: PurchaseFailureSnapshotStore
     private lateinit var connectivityManager: ConnectivityManager
@@ -135,6 +146,10 @@ class AgentForegroundService : Service() {
         stateStore.setKeepScreenOn(false)
         purchaseStore = PurchaseTaskStore(this)
         diagnosticStore = AgentDiagnosticStore(this)
+        syncDiagnostics = SyncDiagnosticRecorder(
+            SyncDiagnosticStore(AndroidSyncSql { diagnosticStore.writableDatabase }), UUID.randomUUID().toString(),
+            System::currentTimeMillis, SystemClock::elapsedRealtime,
+        ) { Log.w("GoAutoDiagnostic", "sync_diagnostic_persistence_failed") }
         failureSnapshotStore = PurchaseFailureSnapshotStore(diagnosticStore)
         diagnosticRecorder = SafeAgentDiagnosticRecorder(
             persist = { event ->
@@ -152,6 +167,7 @@ class AgentForegroundService : Service() {
         connectivityManager = getSystemService(ConnectivityManager::class.java)
         createNotificationChannel()
         startForeground(NOTIFICATION_ID, notification("正在启动"))
+        foregroundStarted = true
         registerNetworkCallback()
         resumeCollectionCooldown()
         executor.scheduleWithFixedDelay(::triggerSync, 0, HEARTBEAT_SECONDS, TimeUnit.SECONDS)
@@ -160,6 +176,7 @@ class AgentForegroundService : Service() {
         // Separate, serialized I/O ticks keep history reads and result observation off the
         // heartbeat scheduler and, especially, off the single purchase execution thread.
         repurchaseExecutor.scheduleWithFixedDelay(::tickRepurchase, 2, 2, TimeUnit.SECONDS)
+        repurchaseExecutor.scheduleWithFixedDelay(::refreshDeviceBusy, 1, 2, TimeUnit.SECONDS)
         diagnosticInstance = this
     }
 
@@ -181,6 +198,12 @@ class AgentForegroundService : Service() {
                 return START_STICKY
             }
         }
+        if (intent?.action == ACTION_OPEN_PDD_PRODUCT) {
+            val goodsId = intent.getStringExtra(EXTRA_OPEN_PDD_GOODS_ID)
+            val purchase = intent.getBooleanExtra(EXTRA_OPEN_PDD_PURCHASE, false)
+            runCatching { repurchaseExecutor.execute { openPddProduct(goodsId, purchase) } }
+            return START_STICKY
+        }
         if (intent?.action == ACTION_BACKFILL_STOP) {
             backfillGuard.cancelled.set(true)
             return START_STICKY
@@ -204,12 +227,15 @@ class AgentForegroundService : Service() {
     }
 
     override fun onDestroy() {
+        foregroundStarted = false
+        stateStore.stop()
         probeHandoff.invalidate()
         if (diagnosticInstance === this) diagnosticInstance = null
         repurchaseClosed.set(true)
         repurchase.requestStop(repurchase.state.roundId)
         repurchaseExecutor.shutdownNow()
         repurchaseState = RepurchaseState(message = "服务已停止；不会恢复整轮重购")
+        deviceBusyReason = null
         backfillGuard.cancelled.set(true)
         runCatching { connectivityManager.unregisterNetworkCallback(networkCallback) }
         cancelIdleReturn("服务已停止")
@@ -268,15 +294,63 @@ class AgentForegroundService : Service() {
     }
 
     private fun synchronizeAgent(): String {
+        val round = syncDiagnostics.begin(syncDiagnosticContext())
+        try {
+            return synchronizeAgent(round)
+        } catch (error: Error) {
+            round.abort()
+            throw error
+        } catch (error: java.util.concurrent.CancellationException) {
+            round.abort()
+            throw error
+        } finally {
+            round.finish()
+        }
+    }
+
+    private fun syncDiagnosticContext(): SyncContext = try {
+        val taskId = runningTaskId.get() ?: purchaseStore.activeTaskId()
+        val state = stateStore.read()
+        val taskContext = syncTaskIdentity(
+            taskId, state.currentTaskType.takeIf { state.currentTaskId == taskId },
+            taskMutex.currentTaskId() != null, syncTaskContext.get(),
+        ) {
+            purchaseStore.interruptedAttempts().firstOrNull { it.taskId == taskId }?.attemptId
+        }
+        val network = connectivityManager.activeNetwork
+        val capabilities = network?.let(connectivityManager::getNetworkCapabilities)
+        SyncContext(
+            deviceId = identityStore.credentials()?.deviceId,
+            taskId = taskId,
+            attemptId = taskContext.attemptId,
+            phase = taskContext.phase,
+            validatedNetwork = capabilities?.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED),
+            transport = when {
+                network == null -> "none"
+                capabilities?.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) == true -> "wifi"
+                capabilities?.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) == true -> "cellular"
+                else -> "unknown"
+            },
+            foreground = foregroundStarted,
+        )
+    } catch (error: java.util.concurrent.CancellationException) {
+        throw error
+    } catch (error: Exception) {
+        Log.w("GoAutoDiagnostic", "sync_diagnostic_context_failed")
+        SyncContext(foreground = foregroundStarted)
+    }
+
+    private fun synchronizeAgent(round: SyncDiagnosticRecorder.Round): String {
+        var heartbeatSucceeded = false
         return try {
             val serverUrl = ServerUrlPolicy.normalize(settingsStore.serverUrl())
             val api = AgentApiClient(serverUrl)
             var credentials = identityStore.credentials()
-            stateStore.update("CONNECTING", "正在连接并校验设备身份", credentials?.deviceId ?: 0L, credentials != null)
-            updateNotification("正在连接")
+            stateStore.update("CONNECTING", "正在同步", credentials?.deviceId ?: 0L, credentials != null, connection = true)
+            updateNotification("正在同步")
 
             if (!registeredThisProcess.get()) {
-                val registration = api.register(deviceInfo(), credentials?.token)
+                val registration = round.step("register") { api.register(deviceInfo(), credentials?.token) }
                 if (registration.deviceToken != null) {
                     val issuedToken = registration.deviceToken
                     identityStore.saveCredentials(registration.deviceId, issuedToken)
@@ -290,17 +364,41 @@ class AgentForegroundService : Service() {
             }
 
             val activeCredentials = credentials ?: error("设备尚未取得认证凭据")
-            if (taskMutex.currentTaskId() == null) {
-                recoverInterruptedPurchases(api, activeCredentials.token)
-                flushPurchaseOutbox(api, activeCredentials.token)
-                runningTaskId.set(purchaseStore.activeTaskId())
+            val sync = AgentSyncCycle(
+                heartbeat = { currentTaskId ->
+                    round.step("heartbeat") {
+                        var snapshot: SyncReportSnapshot? = null
+                        heartbeatReports.heartbeat(
+                            api, activeCredentials.token, currentTaskId, AgentCapabilities.supported,
+                            report = { syncDiagnostics.snapshot().also { snapshot = it }?.report },
+                            ack = { snapshot?.let(syncDiagnostics::ack) },
+                            validate = { check(it.deviceId == activeCredentials.deviceId) { "心跳设备身份不一致" } },
+                        )
+                    }
+                },
+                activeTaskId = {
+                    if (taskMutex.currentTaskId() != null) runningTaskId.get()
+                    else purchaseStore.activeTaskId().also(runningTaskId::set)
+                },
+                executionActive = { taskMutex.currentTaskId() != null },
+                recover = {
+                    round.step("recover") {
+                        recoverInterruptedPurchases(api, activeCredentials.token, round::handledFailure)
+                    }
+                },
+                flush = { round.step("flush") { flushPurchaseOutbox(api, activeCredentials.token) } },
+                hasPending = { purchaseStore.pendingOutbox().isNotEmpty() },
+            ).run()
+            sync.failure?.let(round::failed)
+            if (sync.failureCode != null) {
+                cancelIdleReturn("同步未完成")
+                val message = cn.ilapage.goauto.agent.ui.PurchaseRejectionPresentation.connection(sync.failureCode, 0)
+                stateStore.update(sync.failureCode, message, activeCredentials.deviceId, true, connection = true)
+                updateNotification(message)
+                return if (sync.failureCode == "AUTH_ERROR") MANUAL_AUTH_ERROR else MANUAL_NETWORK_ERROR
             }
-            val heartbeat = api.heartbeat(
-                activeCredentials.token,
-                currentTaskId = runningTaskId.get(),
-                capabilities = AgentCapabilities.supported,
-            )
-            check(heartbeat.deviceId == activeCredentials.deviceId) { "心跳返回了不同的设备身份" }
+            val heartbeat = requireNotNull(sync.heartbeat)
+            heartbeatSucceeded = true
             stateStore.update(
                 code = if (heartbeat.busy) "BUSY" else "ONLINE",
                 message = if (heartbeat.busy) "设备在线，正在执行任务" else "设备在线空闲",
@@ -309,30 +407,34 @@ class AgentForegroundService : Service() {
                 heartbeat = true,
             )
             updateNotification(if (heartbeat.busy) "在线 · 执行中" else "在线 · 空闲")
-            scheduleTask(api, activeCredentials.token)
+            if (sync.canClaim) round.step("claim") { scheduleTask(api, activeCredentials.token) } else MANUAL_BUSY
         } catch (error: AgentApiException) {
+            round.failed(error)
             cancelIdleReturn("网络或服务端请求失败")
-            val authenticationError = error.code in setOf(
-                "DEVICE_TOKEN_INVALID", "DEVICE_INSTALL_ID_CONFLICT", "DEVICE_DISABLED",
-            )
+            val authenticationError = isAgentAuthenticationError(error)
+            val connectionFailure = syncConnectionFailureCode(error, heartbeatSucceeded)
+            val code = connectionFailure ?: "TASK_ERROR"
             val storedCredentials = runCatching { identityStore.credentials() }.getOrNull()
             stateStore.update(
-                code = if (authenticationError) "AUTH_ERROR" else "NETWORK_ERROR",
-                message = "${error.code}：${error.message}",
+                code = code,
+                message = if (connectionFailure == null) "任务同步暂未完成，请稍后重试" else cn.ilapage.goauto.agent.ui.PurchaseRejectionPresentation.connection(code, 0),
                 deviceId = storedCredentials?.deviceId ?: 0L,
                 tokenStored = storedCredentials != null,
+                connection = connectionFailure != null,
             )
-            updateNotification(if (authenticationError) "设备认证失败" else "连接失败，等待网络恢复")
+            updateNotification(if (authenticationError) "设备认证失败" else if (heartbeatSucceeded) "任务同步暂未完成" else "连接失败，等待恢复")
             if (authenticationError) MANUAL_AUTH_ERROR else MANUAL_NETWORK_ERROR
         } catch (error: Exception) {
+            round.failed(error)
             cancelIdleReturn("Agent 运行异常")
             val configured = settingsStore.serverUrl().isNotBlank()
             val storedCredentials = runCatching { identityStore.credentials() }.getOrNull()
             stateStore.update(
-                code = if (configured) "ERROR" else "CONFIG_REQUIRED",
-                message = error.message ?: "Agent 运行失败",
+                code = if (heartbeatSucceeded) "TASK_ERROR" else if (configured) "ERROR" else "CONFIG_REQUIRED",
+                message = if (configured) "同步暂未完成，请稍后重试" else "请配置服务端",
                 deviceId = storedCredentials?.deviceId ?: 0L,
                 tokenStored = storedCredentials != null,
+                connection = !heartbeatSucceeded,
             )
             updateNotification(if (configured) "运行异常" else "等待配置服务端")
             if (configured) MANUAL_ERROR else MANUAL_CONFIG_REQUIRED
@@ -341,8 +443,6 @@ class AgentForegroundService : Service() {
 
     private fun scheduleTask(api: AgentApiClient, token: String): String {
         if (taskMutex.currentTaskId() != null) return MANUAL_BUSY
-        recoverInterruptedPurchases(api, token)
-        flushPurchaseOutbox(api, token)
         val collectionCooldown = activeCollectionCooldown()
         val purchaseTask = api.nextPurchaseTask(token)
         when (TaskDispatchPolicy.decide(purchaseTask?.status, collectionCooldown != null)) {
@@ -405,9 +505,47 @@ class AgentForegroundService : Service() {
         updateNotification(state.message, force = true)
     }
 
-    private fun repurchaseLocalIdle(): Boolean = !working.get() && taskMutex.currentTaskId() == null &&
-        purchaseStore.activeTaskId() == null && purchaseStore.pendingOutbox().isEmpty() &&
-        stateStore.read().currentTaskId == null && !backfillState.running
+    private fun deviceBusyInputs(includeRepurchase: Boolean): DeviceBusyPolicy.Inputs {
+        val mutexTaskId = taskMutex.currentTaskId()
+        return DeviceBusyPolicy.Inputs(
+            repurchaseBusy = includeRepurchase && repurchaseState.busy,
+            backfillRunning = backfillState.running,
+            currentPageCollecting = mutexTaskId == CURRENT_PAGE_RESERVATION_ID,
+            taskActive = working.get() || mutexTaskId != null || purchaseStore.activeTaskId() != null ||
+                stateStore.read().currentTaskId != null,
+            unuploadedPurchase = purchaseStore.pendingOutbox().isNotEmpty(),
+        )
+    }
+
+    // The repurchase round itself asks this question between its tasks, so it must not count its own busy flag.
+    private fun repurchaseLocalIdle(): Boolean = DeviceBusyPolicy.reason(deviceBusyInputs(includeRepurchase = false)) == null
+
+    /** Publishes the read-only busy reason for the history detail buttons; click time re-checks. */
+    private fun refreshDeviceBusy() {
+        runCatching {
+            val reason = if (repurchaseClosed.get()) null else DeviceBusyPolicy.reason(deviceBusyInputs(includeRepurchase = true))
+            if (reason != deviceBusyReason) {
+                deviceBusyReason = reason
+                sendBroadcast(Intent(ACTION_DEVICE_BUSY_STATE).setPackage(packageName))
+            }
+        }
+    }
+
+    private fun openPddProduct(goodsId: String?, purchase: Boolean) {
+        val result = runCatching {
+            PddManualOpenCoordinator(
+                busyReason = { synchronized(taskMutex) { DeviceBusyPolicy.reason(deviceBusyInputs(includeRepurchase = true)) } },
+                invalidateHandoff = probeHandoff::invalidate,
+                launch = { url, preferDirect, diagnostic ->
+                    cn.ilapage.goauto.agent.automation.PddLinkLauncher(this).open(url, preferDirect, diagnostic)
+                },
+            ).run(goodsId, purchase)
+        }.getOrDefault(PddManualOpenResult.Failed)
+        sendBroadcast(Intent(ACTION_OPEN_PDD_RESULT).apply {
+            setPackage(packageName)
+            putExtra(EXTRA_OPEN_PDD_MESSAGE, PddManualOpenCoordinator.message(result))
+        })
+    }
 
     private fun repurchaseEnvironment(session: RepurchaseSession): String? {
         if (repurchaseClosed.get()) return "服务已经停止"
@@ -607,7 +745,7 @@ class AgentForegroundService : Service() {
             publishCurrentPageResult(0L, "采集间隔中，还需 $remaining 秒。", replacementOriginType, replacementOriginTaskId)
             return
         }
-        if (!taskMutex.tryAcquire(CURRENT_PAGE_RESERVATION_ID)) {
+        if (!tryAcquireCurrentPage(taskMutex, working, CURRENT_PAGE_RESERVATION_ID)) {
             publishCurrentPageResult(0L, "设备正在执行任务，请稍后再试。", replacementOriginType, replacementOriginTaskId)
             return
         }
@@ -765,6 +903,7 @@ class AgentForegroundService : Service() {
         var resultSafelyStored = false
         var knownResultType: String? = null
         var snapshotContext: SnapshotContext? = null
+        var observedSyncTaskContext: SyncContext? = null
         var executionEntered = false
         var snapshotAttempted = false
         var probeDiagnosticEvents = 0
@@ -782,6 +921,8 @@ class AgentForegroundService : Service() {
                 api.startPurchaseTask(claimed.taskId, UUID.randomUUID().toString(), token)
             } else claimed
             check(task.status == "running" && task.taskAttemptId.isNotBlank()) { "采购任务没有有效 attempt" }
+            observedSyncTaskContext = SyncContext(taskId = task.taskId, attemptId = task.taskAttemptId, phase = task.phase)
+            syncTaskContext.set(observedSyncTaskContext)
             recordRepurchaseExecution(task, null)
             val diagnosticDeviceId = runCatching { identityStore.credentials()?.takeIf { it.token == token }?.deviceId }.getOrNull()
             if (task.taskAttemptId.matches(Regex("[0-9a-fA-F]{8}(-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}")) &&
@@ -864,7 +1005,15 @@ class AgentForegroundService : Service() {
                             panelDiagnostic = { evidence -> Log.i("GoAutoPurchasePanel", "task=${task.taskId};$evidence") },
                             beforeOrderSubmit = { evidence ->
                                 val boundaryRequestId = UUID.randomUUID().toString()
-                                val finalEvidence = evidence.toLocalJson()
+                                val finalEvidence = JSONObject()
+                                    .put("goodsId", evidence.goodsId)
+                                    .put("mappedColor", evidence.mappedColor)
+                                    .put("mappedSize", evidence.mappedSize)
+                                    .put("quantity", evidence.quantity)
+                                    .put("unitPriceCent", evidence.unitPriceCent)
+                                    .put("addressSuffix", evidence.addressSuffix)
+                                    .put("activityName", evidence.activityName)
+                                    .toString()
                                 purchaseStore.markOrderSubmitStarted(task.taskId, task.taskAttemptId, boundaryRequestId, finalEvidence)
                                 api.markPurchaseOrderSubmitStarted(task.taskId, boundaryRequestId, token)
                             },
@@ -929,9 +1078,10 @@ class AgentForegroundService : Service() {
                     )
                 }
             }
-            val message = if (outcome.resultType == "failed") "${outcome.errorCode}：${outcome.message}" else outcome.message
+            val rejected = purchaseStore.rejectedResults().any { it.taskId == task.taskId && it.attemptId == task.taskAttemptId }
+            val message = if (rejected) "采购结果被服务端拒收，请在采购页或设置中查看" else if (outcome.resultType == "failed") "${outcome.errorCode}：${outcome.message}" else outcome.message
             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} 已提交")
+            updateNotification(if (rejected) "$taskLabel #${task.taskId} 结果被拒收" else if (outcome.resultType == "failed") "$taskLabel #${task.taskId} 失败" else "$taskLabel #${task.taskId} 已提交")
         } catch (error: AgentApiException) {
             failureSnapshot("failed", error.code.takeIf { it.matches(Regex("[A-Z][A-Z0-9_]{0,63}")) } ?: "PURCHASE_API_FAILED")
             stateStore.update("TASK_ERROR", "${error.code}：${error.message}", tokenStored = true)
@@ -940,6 +1090,7 @@ class AgentForegroundService : Service() {
             stateStore.update("TASK_ERROR", error.message ?: "采购演练执行异常", tokenStored = true)
         } finally {
             if (snapshotContext?.phase == "spec_probe" && probeDiagnosticEvents == 0) Log.i("GoAutoDiagnostic", "purchase_diagnostic_no_event")
+            observedSyncTaskContext?.let { syncTaskContext.compareAndSet(it, null) }
             if (!resultSafelyStored) cancelIdleReturn("采购结果未安全保存")
             releaseTaskWakeLock()
         }
@@ -990,12 +1141,16 @@ class AgentForegroundService : Service() {
             .toString()
     }
 
-    private fun recoverInterruptedPurchases(api: AgentApiClient, token: String) {
+    private fun recoverInterruptedPurchases(
+        api: AgentApiClient,
+        token: String,
+        onHandledFailure: (AgentApiException) -> Unit,
+    ) {
         purchaseStore.interruptedAttempts().forEach { interrupted ->
             probeHandoff.beginExecution()
             if (interrupted.status == PurchaseTaskStore.STATUS_ORDER_SUBMIT_STARTED) {
                 val boundaryRequestId = interrupted.orderSubmitRequestId ?: return@forEach
-                try {
+                recoverPurchaseBoundary(onHandledFailure) {
                     api.markPurchaseOrderSubmitStarted(interrupted.taskId, boundaryRequestId, token)
                     val automation = GoAutoAccessibilityService.instance?.let(::PurchaseLiveAutomation)
                     val evidence = try { automation?.readOrderResult() } catch (error: Exception) {
@@ -1021,9 +1176,6 @@ class AgentForegroundService : Service() {
                     }
                     val requestId = UUID.randomUUID().toString()
                     purchaseStore.completeAndEnqueue(interrupted.taskId, interrupted.attemptId, requestId, purchaseResultPayload(requestId, interrupted.attemptId, outcome))
-                } catch (_: AgentApiException) {
-                    // Keep the local irreversible marker. The same server request ID
-                    // is replayed after connectivity returns; the order click is never repeated.
                 }
                 return@forEach
             }
@@ -1058,6 +1210,18 @@ class AgentForegroundService : Service() {
                 runCatching { onFirstSubmitted(item, requireNotNull(acknowledgement)) }
                     .onFailure { probeHandoff.invalidate(); logDiagnosticPersistenceFailure(it) }
             },
+            markRejected = { item, code ->
+                probeHandoff.invalidate()
+                purchaseStore.markRejected(item, code)
+                synchronized(taskMutex) {
+                    val runtime = stateStore.read()
+                    if (shouldClearRejectedPurchase(item.taskId, runtime.currentTaskId, runtime.currentTaskType,
+                            taskMutex.currentTaskId(), purchaseStore.isCurrentAttemptRejected(item.taskId, item.attemptId))) {
+                        stateStore.clearActiveTask(item.taskId)
+                    }
+                }
+                sendBroadcast(Intent(ACTION_PURCHASE_REJECTIONS_CHANGED).setPackage(packageName))
+            },
         ).flush()
         runningTaskId.set(purchaseStore.activeTaskId())
     }
@@ -1685,6 +1849,7 @@ class AgentForegroundService : Service() {
         const val ACTION_REPURCHASE_CONFIRM = "cn.ilapage.goauto.agent.REPURCHASE_CONFIRM"
         const val ACTION_REPURCHASE_STOP = "cn.ilapage.goauto.agent.REPURCHASE_STOP"
         const val ACTION_REPURCHASE_STATE = "cn.ilapage.goauto.agent.REPURCHASE_STATE"
+        const val ACTION_PURCHASE_REJECTIONS_CHANGED = "cn.ilapage.goauto.agent.PURCHASE_REJECTIONS_CHANGED"
         @Volatile var repurchaseState = RepurchaseState()
             private set
         const val ACTION_BACKFILL_START = "cn.ilapage.goauto.agent.BACKFILL_START"
@@ -1692,6 +1857,15 @@ class AgentForegroundService : Service() {
         const val ACTION_BACKFILL_STATE = "cn.ilapage.goauto.agent.BACKFILL_STATE"
         @Volatile var backfillState = OrderBackfillState()
             private set
+        const val ACTION_OPEN_PDD_PRODUCT = "cn.ilapage.goauto.agent.OPEN_PDD_PRODUCT"
+        const val ACTION_OPEN_PDD_RESULT = "cn.ilapage.goauto.agent.OPEN_PDD_RESULT"
+        const val ACTION_DEVICE_BUSY_STATE = "cn.ilapage.goauto.agent.DEVICE_BUSY_STATE"
+        const val EXTRA_OPEN_PDD_GOODS_ID = "open_pdd_goods_id"
+        const val EXTRA_OPEN_PDD_PURCHASE = "open_pdd_purchase"
+        const val EXTRA_OPEN_PDD_MESSAGE = "open_pdd_message"
+        /** Null when idle; otherwise the user-facing reason. Updated about every two seconds. */
+        @Volatile var deviceBusyReason: String? = null
+            private set
         const val ACTION_RECONNECT = "cn.ilapage.goauto.agent.RECONNECT"
         const val ACTION_CHECK_NOW = "cn.ilapage.goauto.agent.CHECK_NOW"
         const val ACTION_CHECK_RESULT = "cn.ilapage.goauto.agent.CHECK_RESULT"
@@ -1748,6 +1922,15 @@ class AgentForegroundService : Service() {
             }
         }
 
+        fun openPddProduct(context: Context, goodsId: String, purchase: Boolean) {
+            val intent = Intent(context, AgentForegroundService::class.java).apply {
+                action = ACTION_OPEN_PDD_PRODUCT
+                putExtra(EXTRA_OPEN_PDD_GOODS_ID, goodsId)
+                putExtra(EXTRA_OPEN_PDD_PURCHASE, purchase)
+            }
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) context.startForegroundService(intent) else context.startService(intent)
+        }
+
         fun collectCurrentPage(
             context: Context,
             requestId: String,

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

@@ -191,17 +191,27 @@ class AgentSettingsStore(context: Context) {
 
 class AgentStateStore(context: Context) {
     private val preferences = context.getSharedPreferences(PREFERENCES, Context.MODE_PRIVATE)
+    private val publicationGate = AgentStatePublicationGate()
 
-    fun update(code: String, message: String, deviceId: Long? = null, tokenStored: Boolean? = null, heartbeat: Boolean = false) {
+    fun update(code: String, message: String, deviceId: Long? = null, tokenStored: Boolean? = null, heartbeat: Boolean = false, connection: Boolean = false) = publicationGate.publish {
         val editor = preferences.edit()
             .putString(STATE_CODE, code)
             .putString(STATE_MESSAGE, message)
         deviceId?.let { editor.putLong(DEVICE_ID, it) }
         tokenStored?.let { editor.putBoolean(TOKEN_STORED, it) }
         if (heartbeat) editor.putLong(LAST_HEARTBEAT, System.currentTimeMillis())
+        if (heartbeat || connection) editor.putString(CONNECTION_CODE, code)
         editor.apply()
     }
 
+    /** This service instance cannot publish a late heartbeat over STOPPED or a restarted service. */
+    fun stop() = publicationGate.stop {
+        preferences.edit().putString(STATE_CODE, "STOPPED").putString(CONNECTION_CODE, "STOPPED")
+            .putString(STATE_MESSAGE, "前台服务已停止").apply()
+    }
+
+    fun connectionCode(): String = preferences.getString(CONNECTION_CODE, "STOPPED") ?: "STOPPED"
+
     fun read(): AgentState = AgentState(
         code = preferences.getString(STATE_CODE, "STOPPED") ?: "STOPPED",
         message = preferences.getString(STATE_MESSAGE, "前台服务尚未启动") ?: "前台服务尚未启动",
@@ -279,6 +289,7 @@ class AgentStateStore(context: Context) {
     private companion object {
         const val PREFERENCES = "goauto_agent_runtime"
         const val STATE_CODE = "state_code"
+        const val CONNECTION_CODE = "connection_code"
         const val STATE_MESSAGE = "state_message"
         const val DEVICE_ID = "device_id"
         const val LAST_HEARTBEAT = "last_heartbeat"

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

@@ -0,0 +1,87 @@
+package cn.ilapage.goauto.agent.service
+
+import cn.ilapage.goauto.agent.network.AgentApiException
+import cn.ilapage.goauto.agent.network.HeartbeatResult
+
+internal fun isAgentAuthenticationError(error: Throwable?): Boolean = error is AgentApiException &&
+    (error.status in setOf(401, 403) || error.code in setOf("DEVICE_TOKEN_INVALID", "DEVICE_INSTALL_ID_CONFLICT", "DEVICE_DISABLED"))
+
+internal fun syncConnectionFailureCode(error: Throwable, heartbeatSucceeded: Boolean): String? = when {
+    isAgentAuthenticationError(error) -> "AUTH_ERROR"
+    heartbeatSucceeded -> null
+    error is AgentApiException && error.code == "DEVICE_TASK_MISMATCH" -> "TASK_MISMATCH"
+    error is AgentApiException && error.status >= 500 -> "SERVER_ERROR"
+    else -> "NETWORK_ERROR"
+}
+
+internal data class AgentSyncResult(
+    val heartbeat: HeartbeatResult?,
+    val failureCode: String?,
+    val canClaim: Boolean,
+    val failure: Exception? = null,
+)
+
+/** Run under the service's existing sync exclusion; device execution keeps its task mutex. */
+internal class AgentSyncCycle(
+    private val heartbeat: (Long?) -> HeartbeatResult,
+    private val activeTaskId: () -> Long?,
+    private val executionActive: () -> Boolean,
+    private val recover: () -> Unit,
+    private val flush: () -> Unit,
+    private val hasPending: () -> Boolean,
+) {
+    fun run(): AgentSyncResult {
+        var pulse = captureSync { heartbeat(activeTaskId()) }
+        var authFailure = isAgentAuthenticationError(pulse.exceptionOrNull())
+        var recovered = false
+        var flushed = false
+        if (!authFailure && !executionActive()) {
+            val recovery = captureSync(recover)
+            recovered = recovery.isSuccess
+            authFailure = isAgentAuthenticationError(recovery.exceptionOrNull())
+            if (!authFailure) {
+                val upload = captureSync(flush)
+                flushed = upload.isSuccess
+                authFailure = isAgentAuthenticationError(upload.exceptionOrNull())
+            }
+            if (!authFailure && (pulse.exceptionOrNull() as? AgentApiException)?.code == "DEVICE_TASK_MISMATCH") {
+                pulse = captureSync { heartbeat(activeTaskId()) }
+            }
+        }
+        val failure = pulse.exceptionOrNull()
+        return AgentSyncResult(
+            pulse.getOrNull(),
+            when {
+                authFailure -> "AUTH_ERROR"
+                failure == null -> null
+                isAgentAuthenticationError(failure) -> "AUTH_ERROR"
+                (failure as? AgentApiException)?.code == "DEVICE_TASK_MISMATCH" -> "TASK_MISMATCH"
+                failure is AgentApiException && failure.status >= 500 -> "SERVER_ERROR"
+                else -> "NETWORK_ERROR"
+            },
+            pulse.isSuccess && !authFailure && recovered && flushed && !executionActive() && !hasPending() && activeTaskId() == null,
+            failure as? Exception,
+        )
+    }
+}
+
+private fun <T> captureSync(action: () -> T): Result<T> = try {
+    Result.success(action())
+} catch (error: java.util.concurrent.CancellationException) {
+    throw error
+} catch (error: Exception) {
+    Result.failure(error)
+}
+
+/** Preserve the local irreversible marker when replay fails; the original request ID is reused. */
+internal fun recoverPurchaseBoundary(
+    onHandledFailure: (AgentApiException) -> Unit,
+    recover: () -> Unit,
+) {
+    try {
+        recover()
+    } catch (error: AgentApiException) {
+        if (isAgentAuthenticationError(error)) throw error
+        onHandledFailure(error)
+    }
+}

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

@@ -0,0 +1,85 @@
+package cn.ilapage.goauto.agent.service
+
+import cn.ilapage.goauto.agent.automation.PddLaunchEvent
+import cn.ilapage.goauto.agent.automation.PddLaunchPath
+import cn.ilapage.goauto.agent.automation.PddLaunchStatus
+
+/** Single source of truth for "the device is busy"; the service and the UI both consume its result. */
+internal object DeviceBusyPolicy {
+    data class Inputs(
+        val repurchaseBusy: Boolean = false,
+        val backfillRunning: Boolean = false,
+        /** The manual current-page collection holds the task mutex with its own reservation. */
+        val currentPageCollecting: Boolean = false,
+        /** A collection/purchase/image-search task is claimed, running or restored. */
+        val taskActive: Boolean = false,
+        /** Unuploaded purchase results or a purchase waiting for recovery. */
+        val unuploadedPurchase: Boolean = false,
+    )
+
+    const val REPURCHASE = "重购进行中"
+    const val BACKFILL = "订单回填中"
+    const val CURRENT_PAGE = "当前页采集进行中"
+    const val TASK = "设备正在执行任务"
+    const val UNUPLOADED = "有未上传的采购结果"
+
+    /** Null means idle. A collection cooldown is intentionally not an input. */
+    fun reason(inputs: Inputs): String? = when {
+        inputs.repurchaseBusy -> REPURCHASE
+        inputs.backfillRunning -> BACKFILL
+        inputs.currentPageCollecting -> CURRENT_PAGE
+        inputs.taskActive -> TASK
+        inputs.unuploadedPurchase -> UNUPLOADED
+        else -> null
+    }
+}
+
+internal sealed class PddManualOpenResult {
+    object InvalidGoodsId : PddManualOpenResult()
+    data class Busy(val reason: String) : PddManualOpenResult()
+    data class Opened(val fallbackNotice: String?) : PddManualOpenResult()
+    object Failed : PddManualOpenResult()
+}
+
+/** Manual "open in PDD" entry. Only opens the product link; it never clicks anything inside PDD. */
+internal class PddManualOpenCoordinator(
+    private val busyReason: () -> String?,
+    private val invalidateHandoff: () -> Unit,
+    private val launch: (url: String, preferDirect: Boolean, diagnostic: (PddLaunchEvent) -> Unit) -> Boolean,
+) {
+    fun run(goodsId: String?, purchase: Boolean): PddManualOpenResult {
+        val url = link(goodsId) ?: return PddManualOpenResult.InvalidGoodsId
+        busyReason()?.let { return PddManualOpenResult.Busy(it) }
+        // The opened page is no longer the product a previous probe prepared.
+        invalidateHandoff()
+        val events = mutableListOf<PddLaunchEvent>()
+        val opened = launch(url, purchase) { events += it }
+        return if (opened) PddManualOpenResult.Opened(fallbackNotice(events)) else PddManualOpenResult.Failed
+    }
+
+    companion object {
+        const val OPENED_HINT = "打开期间如有新任务，Agent 会接管屏幕"
+        const val FAILED = "无法打开拼多多链接"
+        const val INVALID = "商品编号无效，无法打开"
+
+        fun link(goodsId: String?): String? =
+            goodsId?.takeIf { it.isNotEmpty() && it.all { c -> c in '0'..'9' } }
+                ?.let { "https://mobile.yangkeduo.com/goods.html?goods_id=$it" }
+
+        /** Never contains the URL or an exception message; only the simple exception class name. */
+        fun fallbackNotice(events: List<PddLaunchEvent>): String? {
+            val direct = events.firstOrNull { it.path == PddLaunchPath.DIRECT && it.status != PddLaunchStatus.ACCEPTED }
+                ?: return null
+            if (events.none { it.path == PddLaunchPath.BROWSER && it.status == PddLaunchStatus.ACCEPTED }) return null
+            val name = direct.exceptionClass?.substringAfterLast('.')?.takeIf(String::isNotBlank)
+            return "拼多多直接打开失败，已改用浏览器" + (name?.let { "（$it）" } ?: "")
+        }
+
+        fun message(result: PddManualOpenResult): String = when (result) {
+            PddManualOpenResult.InvalidGoodsId -> INVALID
+            is PddManualOpenResult.Busy -> "${result.reason}，暂不能打开拼多多"
+            is PddManualOpenResult.Opened -> listOfNotNull(result.fallbackNotice, OPENED_HINT).joinToString("\n")
+            PddManualOpenResult.Failed -> FAILED
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+package cn.ilapage.goauto.agent.service
+
+internal fun shouldClearRejectedPurchase(
+    rejectedTaskId: Long, runtimeTaskId: Long?, runtimeTaskType: String?,
+    executingTaskId: Long?, currentAttemptRejected: Boolean,
+): Boolean = executingTaskId == null && runtimeTaskId == rejectedTaskId &&
+    runtimeTaskType == "purchase" && currentAttemptRejected
+
+internal class AgentStatePublicationGate {
+    private var stopped = false
+    @Synchronized fun publish(write: () -> Unit) { if (!stopped) write() }
+    @Synchronized fun stop(write: () -> Unit) { stopped = true; write() }
+}
+
+internal fun tryAcquireCurrentPage(mutex: TaskExecutionMutex, syncing: java.util.concurrent.atomic.AtomicBoolean, reservation: Long): Boolean =
+    synchronized(mutex) { !syncing.get() && mutex.tryAcquire(reservation) }

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

@@ -24,6 +24,7 @@ import cn.ilapage.goauto.agent.network.CollectionHistoryItem
 import cn.ilapage.goauto.agent.network.PurchaseHistoryItem
 import cn.ilapage.goauto.agent.network.ServerUrlPolicy
 import cn.ilapage.goauto.agent.persistence.TaskHistoryCache
+import cn.ilapage.goauto.agent.persistence.PurchaseTaskStore
 import cn.ilapage.goauto.agent.service.AgentForegroundService
 import cn.ilapage.goauto.agent.service.AgentSettingsStore
 import cn.ilapage.goauto.agent.service.AgentStateStore
@@ -58,6 +59,7 @@ class AgentSettingsFragment : Fragment() {
     private lateinit var connectionFeedback: TextView
     private lateinit var disabledReason: TextView
     private lateinit var diagnostics: TextView
+    private lateinit var rejectedResultsButton: MaterialButton
     private lateinit var accessibilityText: TextView
     private lateinit var collectionIntervalStartLayout: TextInputLayout
     private lateinit var collectionIntervalStartInput: TextInputEditText
@@ -326,6 +328,20 @@ class AgentSettingsFragment : Fragment() {
                 diagnostics = context.label("—", 14f, context.getColor(R.color.agent_text))
                 diagnostics.setPadding(0, context.dp(10), 0, 0)
                 addView(diagnostics)
+                rejectedResultsButton = MaterialButton(context).apply {
+                    text = "查看拒收结果"
+                    minHeight = context.dp(48)
+                    setOnClickListener {
+                        val records = PurchaseTaskStore(context).use { it.rejectedResults() }
+                        MaterialAlertDialogBuilder(context).setTitle("采购结果被服务端拒收")
+                            .setMessage(records.joinToString("\n\n") {
+                                PurchaseRejectionPresentation.notice(it) + "\n${it.errorCode}" +
+                                    if (it.acknowledgedAt != null) "\n已核对（仅本机记录）" else ""
+                            }.ifBlank { "暂无拒收结果" })
+                            .setPositiveButton("知道了", null).show()
+                    }
+                }
+                addView(rejectedResultsButton, fullWidth(8))
             }))
         }
         return context.page(content)
@@ -669,12 +685,14 @@ class AgentSettingsFragment : Fragment() {
         disabledReason.text = if (busy) "任务执行中，暂时不能修改服务器或设备名称。" else ""
 
         val installId = runCatching { identityStore.installId() }.getOrElse { "读取失败" }
+        val rejectedCount = PurchaseTaskStore(context).use { it.rejectedCount() }
+        rejectedResultsButton.visibility = if (rejectedCount > 0) View.VISIBLE else View.GONE
         diagnostics.text = buildString {
             append("installId：$installId\n")
             append("Device Token：${if (state.tokenStored) "已配置" else "未配置"}\n")
             append("注册状态：${if (state.deviceId > 0) "已注册（设备 ${state.deviceId}）" else "未注册"}\n")
             append("Agent 版本：${BuildConfig.VERSION_NAME}\n")
-            append("服务端连接：${if (state.code in setOf("ONLINE", "BUSY", "COLLECTION_COOLDOWN")) "已连接" else "未连接"}\n")
+            append("服务端连接：${PurchaseRejectionPresentation.connection(stateStore.connectionCode(), rejectedCount)}\n")
             append("保持屏幕常亮：${if (state.keepScreenOn) "已开启" else "仅在任务执行或采集间隔时开启"}")
         }
         accessibilityText.text = when (AccessibilityReadinessDetector.current(context)) {

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

@@ -74,6 +74,8 @@ class AgentStatusFragment : Fragment() {
     private lateinit var mediaPermissionDetail: TextView
     private lateinit var mediaPermissionAction: android.widget.Button
     private lateinit var deviceText: TextView
+    private lateinit var deviceWifiText: TextView
+    private lateinit var deviceDebugText: TextView
     private val mediaPermissionRequestLauncher by lazy {
         registerForActivityResult(androidx.activity.result.contract.ActivityResultContracts.RequestPermission()) {
             refreshStatus()
@@ -168,6 +170,20 @@ class AgentStatusFragment : Fragment() {
                 }
                 addView(mediaPermissionAction)
             }))
+            addView(context.card(context.cardColumn().apply {
+                addView(context.label("设备连接", 14f, context.getColor(R.color.agent_text_muted)))
+                deviceWifiText = context.label("Wi-Fi IP：—", 18f, context.getColor(R.color.agent_text), true).apply {
+                    setPadding(0, context.dp(6), 0, 0)
+                }
+                deviceDebugText = context.label("无线调试：—", 18f, context.getColor(R.color.agent_text_muted), true).apply {
+                    setPadding(0, context.dp(6), 0, 0)
+                }
+                addView(deviceWifiText)
+                addView(deviceDebugText)
+                addView(context.label(DeviceConnectionPolicy.PORT_HINT, 14f, context.getColor(R.color.agent_text_muted)).apply {
+                    setPadding(0, context.dp(6), 0, 0)
+                })
+            }))
         }
         refreshLayout = SwipeRefreshLayout(context).apply {
             setColorSchemeResources(R.color.agent_primary_light)
@@ -245,6 +261,10 @@ class AgentStatusFragment : Fragment() {
     private fun refreshStatus() {
         if (!isAdded || view == null) return
         val context = requireContext()
+        val deviceConnection = DeviceConnectionPolicy.display(DeviceConnectionReader.read(context))
+        deviceWifiText.text = deviceConnection.wifiText
+        deviceDebugText.text = deviceConnection.debugText
+        deviceDebugText.setTextColor(context.getColor(deviceConnection.debugColor))
         val state = stateStore.read()
         val connected = state.code in setOf("ONLINE", "BUSY", "COLLECTION_COOLDOWN")
         connectionTitle.text = when (state.code) {

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

@@ -0,0 +1,85 @@
+package cn.ilapage.goauto.agent.ui
+
+import android.content.Context
+import android.net.ConnectivityManager
+import android.net.NetworkCapabilities
+import android.provider.Settings
+import androidx.annotation.ColorRes
+import cn.ilapage.goauto.agent.R
+import java.net.Inet4Address
+import java.net.InetAddress
+
+/** 无线调试开关的读取结果；读取失败为 [UNKNOWN]。 */
+internal enum class WirelessDebugState { ENABLED, DISABLED, UNKNOWN }
+
+internal data class DeviceConnectionReading(
+    val wifiIpv4: String?,
+    val wirelessDebug: WirelessDebugState,
+)
+
+internal data class DeviceConnectionDisplay(
+    val wifiText: String,
+    val debugText: String,
+    @ColorRes val debugColor: Int,
+)
+
+/** 原始读数到显示文案/颜色的纯函数策略，不依赖 Android 系统服务。 */
+internal object DeviceConnectionPolicy {
+    const val PORT_HINT = "端口请在 开发者选项 → 无线调试 中查看"
+    const val NO_WIFI_TEXT = "未连接 Wi-Fi"
+
+    /** 仅当前网络为 Wi-Fi 时，从地址列表中取第一个非回环 IPv4；否则返回 null。 */
+    fun selectWifiIpv4(isWifi: Boolean, addresses: List<InetAddress>): String? {
+        if (!isWifi) return null
+        return addresses.firstOrNull { it is Inet4Address && !it.isLoopbackAddress }?.hostAddress
+    }
+
+    /** adb_wifi_enabled 原始值：1 开启，0 未开启，其他值或读取失败（null）为未知。 */
+    fun debugState(raw: Int?): WirelessDebugState = when (raw) {
+        1 -> WirelessDebugState.ENABLED
+        0 -> WirelessDebugState.DISABLED
+        else -> WirelessDebugState.UNKNOWN
+    }
+
+    fun display(reading: DeviceConnectionReading): DeviceConnectionDisplay {
+        val (text, color) = when (reading.wirelessDebug) {
+            WirelessDebugState.ENABLED -> "已开启" to R.color.agent_primary_light
+            WirelessDebugState.DISABLED -> "未开启" to R.color.agent_warning
+            WirelessDebugState.UNKNOWN -> "无法读取" to R.color.agent_text_muted
+        }
+        return DeviceConnectionDisplay(
+            wifiText = "Wi-Fi IP：${reading.wifiIpv4 ?: NO_WIFI_TEXT}",
+            debugText = "无线调试：$text",
+            debugColor = color,
+        )
+    }
+}
+
+/** 系统读取的薄封装；任何异常都降级为「未知」，不记录日志、不持久化。 */
+internal object DeviceConnectionReader {
+    fun read(context: Context): DeviceConnectionReading = DeviceConnectionReading(
+        wifiIpv4 = readWifiIpv4(context),
+        wirelessDebug = DeviceConnectionPolicy.debugState(readDebugRaw(context)),
+    )
+
+    private fun readWifiIpv4(context: Context): String? = try {
+        val manager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as? ConnectivityManager
+        val network = manager?.activeNetwork
+        val isWifi = network?.let { manager.getNetworkCapabilities(it) }
+            ?.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) == true
+        val addresses = if (isWifi && manager != null && network != null) {
+            manager.getLinkProperties(network)?.linkAddresses?.map { it.address }.orEmpty()
+        } else {
+            emptyList()
+        }
+        DeviceConnectionPolicy.selectWifiIpv4(isWifi, addresses)
+    } catch (_: Exception) {
+        null
+    }
+
+    private fun readDebugRaw(context: Context): Int? = try {
+        Settings.Global.getInt(context.contentResolver, "adb_wifi_enabled", 0)
+    } catch (_: Exception) {
+        null
+    }
+}

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

@@ -0,0 +1,28 @@
+package cn.ilapage.goauto.agent.ui
+
+import cn.ilapage.goauto.agent.persistence.RejectedPurchaseResult
+import org.json.JSONObject
+
+internal object PurchaseRejectionPresentation {
+    private fun payload(item: RejectedPurchaseResult) = runCatching { JSONObject(item.payloadJson) }.getOrNull()
+    private fun orderNo(item: RejectedPurchaseResult): String? = payload(item)?.optString("pddOrderNo")
+        ?.takeIf { it.matches(Regex("[0-9A-Za-z-]{1,80}")) }
+    fun showBanner(item: RejectedPurchaseResult): Boolean = item.acknowledgedAt == null &&
+        (payload(item)?.optString("resultType") in setOf("order_created", "order_result_unknown") ||
+            !payload(item)?.optString("pddOrderNo").isNullOrBlank())
+    fun notice(item: RejectedPurchaseResult): String = buildString {
+        append("采购任务 #${item.taskId} 的结果被服务端拒收")
+        orderNo(item)?.let { append("\n拼多多订单号：$it") }
+        append("\n请人工核对拼多多订单及后台任务，避免重复采购")
+    }
+    fun connection(code: String, rejected: Int): String = when (code) {
+        "CONNECTING" -> "正在同步"
+        "ONLINE", "BUSY", "COLLECTION_COOLDOWN", "TASK_ERROR" -> if (rejected > 0) "已连接 · 有 $rejected 条采购结果被服务端拒收" else "已连接"
+        "AUTH_ERROR" -> "未连接 · 设备认证失败"
+        "TASK_MISMATCH" -> "未连接 · 设备任务状态不一致"
+        "NETWORK_ERROR" -> "未连接 · 网络暂不可用"
+        "SERVER_ERROR" -> "未连接 · 服务端暂不可用"
+        "CONFIG_REQUIRED" -> "未连接 · 请配置服务端"
+        else -> "未连接 · 同步暂未完成"
+    }
+}

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

@@ -22,6 +22,7 @@ import android.widget.HorizontalScrollView
 import android.widget.ImageView
 import android.widget.LinearLayout
 import android.widget.ProgressBar
+import android.widget.TextView
 import android.widget.Toast
 import androidx.fragment.app.Fragment
 import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
@@ -37,10 +38,13 @@ import cn.ilapage.goauto.agent.network.HistoryColorImage
 import cn.ilapage.goauto.agent.network.PurchaseHistoryDetail
 import cn.ilapage.goauto.agent.network.PurchaseHistoryItem
 import cn.ilapage.goauto.agent.persistence.TaskHistoryCache
+import cn.ilapage.goauto.agent.persistence.PurchaseTaskStore
+import cn.ilapage.goauto.agent.persistence.RejectedPurchaseResult
 import cn.ilapage.goauto.agent.service.AgentForegroundService
 import cn.ilapage.goauto.agent.service.AgentSettingsStore
 import cn.ilapage.goauto.agent.service.AgentStateStore
 import cn.ilapage.goauto.agent.service.CollectionCooldownPolicy
+import cn.ilapage.goauto.agent.service.PddManualOpenCoordinator
 import com.google.android.material.button.MaterialButton
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import com.google.android.material.textfield.TextInputEditText
@@ -141,13 +145,33 @@ class TaskHistoryFragment : Fragment() {
     private val imageLoader = HistoryImageLoader()
     private val imageRequests = mutableListOf<HistoryImageRequest>()
     private var currentPageReceiverRegistered = false
+    private var openPddButton: MaterialButton? = null
+    private var openPddReason: TextView? = null
+    private var openPddAwaitingResult = false
     private var backfillPanel: LinearLayout? = null
     private var repurchasePanel: LinearLayout? = null
     private var repurchaseButton: MaterialButton? = null
     private var repurchaseDialog: androidx.appcompat.app.AlertDialog? = null
     private var repurchaseDialogRound: String? = null
+    private var rejectionPanel: LinearLayout? = null
+    private var displayedRejections: List<RejectedPurchaseResult>? = null
     private val currentPageReceiver = object : BroadcastReceiver() {
         override fun onReceive(context: Context?, intent: Intent?) {
+            if (intent?.action == AgentForegroundService.ACTION_PURCHASE_REJECTIONS_CHANGED) {
+                renderRejections()
+                return
+            }
+            if (intent?.action == AgentForegroundService.ACTION_DEVICE_BUSY_STATE) {
+                applyOpenPddBusy()
+                return
+            }
+            if (intent?.action == AgentForegroundService.ACTION_OPEN_PDD_RESULT) {
+                if (!openPddAwaitingResult) return
+                openPddAwaitingResult = false
+                val message = intent.getStringExtra(AgentForegroundService.EXTRA_OPEN_PDD_MESSAGE).orEmpty()
+                if (message.isNotBlank() && isAdded) Toast.makeText(requireContext(), message, Toast.LENGTH_LONG).show()
+                return
+            }
             if (intent?.action == AgentForegroundService.ACTION_REPURCHASE_STATE) {
                 renderRepurchase()
                 if (!collection && isResumed && AgentForegroundService.repurchaseState.phase == cn.ilapage.goauto.agent.service.RepurchasePhase.FINISHED) {
@@ -200,6 +224,10 @@ class TaskHistoryFragment : Fragment() {
         val context = requireContext()
         pageColumn = context.column()
         pageColumn.addView(context.screenTitle(if (collection) "采集记录" else "采购记录"))
+        if (!collection) {
+            rejectionPanel = context.column(0)
+            pageColumn.addView(rejectionPanel)
+        }
         pageColumn.addView(buildSearch())
         if (!collection) {
             repurchasePanel = context.column(0)
@@ -228,6 +256,7 @@ class TaskHistoryFragment : Fragment() {
 
     override fun onResume() {
         super.onResume()
+        renderRejections()
         renderRepurchase()
         detailState.taskId?.let { taskId ->
             if (collection) loadCollectionDetail(taskId) else loadPurchaseDetail(taskId)
@@ -235,6 +264,8 @@ class TaskHistoryFragment : Fragment() {
     }
 
     override fun onDestroyView() {
+        rejectionPanel = null
+        displayedRejections = null
         repurchaseDialog?.setOnDismissListener(null)
         repurchaseDialog?.dismiss()
         repurchaseDialog = null
@@ -247,6 +278,29 @@ class TaskHistoryFragment : Fragment() {
         super.onDestroyView()
     }
 
+    private fun renderRejections() {
+        val panel = rejectionPanel ?: return
+        val context = context ?: return
+        val records = PurchaseTaskStore(context).use { it.rejectedResults() }.filter(PurchaseRejectionPresentation::showBanner)
+        if (records == displayedRejections) return
+        displayedRejections = records
+        panel.removeAllViews()
+        records.forEach { record ->
+            panel.addView(context.card(context.cardColumn().apply {
+                addView(context.label(PurchaseRejectionPresentation.notice(record), 14f, context.getColor(R.color.agent_warning), true))
+                addView(MaterialButton(context).apply {
+                    text = "已核对"
+                    minHeight = context.dp(48)
+                    contentDescription = "采购任务 #${record.taskId} 已核对，仅隐藏本机提醒"
+                    setOnClickListener {
+                        val saved = runCatching { PurchaseTaskStore(context).use { it.acknowledgeRejection(record.id) } }.isSuccess
+                        if (saved) renderRejections() else toast("暂时无法保存核对记录，请稍后重试")
+                    }
+                }, fullWidth(8))
+            }))
+        }
+    }
+
     override fun onDestroy() {
         unregisterCurrentPageReceiver()
         imageLoader.close()
@@ -705,6 +759,53 @@ class TaskHistoryFragment : Fragment() {
         }
     }
 
+    /**
+     * Manual "open in PDD" entry. Execution goes through the service so it can re-check busy state and
+     * invalidate the purchase probe handoff; the button never taps anything inside PDD.
+     */
+    private fun openInPddSection(goodsId: String?, purchase: Boolean): View? {
+        openPddButton = null
+        openPddReason = null
+        if (PddManualOpenCoordinator.link(goodsId) == null) return null
+        val context = requireContext()
+        val id = goodsId.orEmpty()
+        val button = MaterialButton(context, null, com.google.android.material.R.attr.materialButtonOutlinedStyle).apply {
+            text = "在拼多多中打开"
+            minimumHeight = context.dp(48)
+            contentDescription = "在拼多多中打开商品 $id"
+            setOnClickListener {
+                val busy = AgentForegroundService.deviceBusyReason
+                if (busy != null) {
+                    applyOpenPddBusy()
+                    toast("$busy，暂不能打开拼多多")
+                } else {
+                    openPddAwaitingResult = true
+                    runCatching { AgentForegroundService.openPddProduct(requireContext(), id, purchase) }
+                        .onFailure { openPddAwaitingResult = false; toast(PddManualOpenCoordinator.FAILED) }
+                }
+            }
+        }
+        val reason = context.label("", 12f, context.getColor(R.color.agent_text_muted)).apply { visibility = View.GONE }
+        openPddButton = button
+        openPddReason = reason
+        applyOpenPddBusy()
+        return LinearLayout(context).apply {
+            orientation = LinearLayout.VERTICAL
+            setPadding(0, context.dp(4), 0, context.dp(8))
+            addView(button)
+            addView(reason)
+        }
+    }
+
+    private fun applyOpenPddBusy() {
+        val button = openPddButton ?: return
+        val reasonView = openPddReason ?: return
+        val busy = AgentForegroundService.deviceBusyReason
+        button.isEnabled = busy == null
+        reasonView.text = busy.orEmpty()
+        reasonView.visibility = if (busy == null) View.GONE else View.VISIBLE
+    }
+
     private fun renderCollectionDetail(detail: CollectionHistoryDetail) {
         val context = requireContext()
         val task = detail.task
@@ -719,6 +820,7 @@ class TaskHistoryFragment : Fragment() {
         }
         val detailCard = context.cardColumn().apply {
             addView(context.label("#${task.taskId} · 第 ${task.attemptNumber} 次 · ${task.goodsId.ifBlank { "未识别商品" }}", 20f, context.getColor(R.color.agent_text), true))
+            openInPddSection(task.goodsId, purchase = false)?.let(::addView)
             if (task.source == "agent_current_page") addView(context.label("来源：Agent 当前页面", 13f, context.getColor(R.color.agent_text_muted)))
             addView(context.label(collectionStatus(task.status), 14f, statusColor(task.status)).apply { setPadding(0, context.dp(4), 0, context.dp(12)) })
             addView(context.label(info, 14f))
@@ -811,6 +913,9 @@ class TaskHistoryFragment : Fragment() {
         val filter = IntentFilter(AgentForegroundService.ACTION_CURRENT_PAGE_RESULT)
         filter.addAction(AgentForegroundService.ACTION_BACKFILL_STATE)
         filter.addAction(AgentForegroundService.ACTION_REPURCHASE_STATE)
+        filter.addAction(AgentForegroundService.ACTION_PURCHASE_REJECTIONS_CHANGED)
+        filter.addAction(AgentForegroundService.ACTION_DEVICE_BUSY_STATE)
+        filter.addAction(AgentForegroundService.ACTION_OPEN_PDD_RESULT)
         if (Build.VERSION.SDK_INT >= 33) {
             requireContext().registerReceiver(currentPageReceiver, filter, Context.RECEIVER_NOT_EXPORTED)
         } else {
@@ -893,9 +998,13 @@ class TaskHistoryFragment : Fragment() {
     private fun renderPurchaseDetail(detail: PurchaseHistoryDetail) {
         val context = requireContext()
         val task = detail.task
+        PurchaseTaskStore(context).use { it.rejectedResults() }.filter { it.taskId == task.taskId }.forEach { record ->
+            resultColumn.addView(context.card(context.cardColumn().apply {
+                addView(context.label(PurchaseRejectionPresentation.notice(record) + "\n${record.errorCode}", 14f, context.getColor(R.color.agent_warning)))
+            }))
+        }
+        val infoHead = "蝦皮订单号：${task.shopeeOrderNo.ifBlank { "—" }}\nPDD 商品：${task.pddGoodsId}"
         val info = buildString {
-            append("蝦皮订单号：${task.shopeeOrderNo.ifBlank { "—" }}\n")
-            append("PDD 商品：${task.pddGoodsId}\n")
             append("商品标题：${task.pddTitle.ifBlank { "—" }}\n")
             append("目标规格：${listOf(task.targetColor, task.targetSize).filter(String::isNotBlank).joinToString(" / ").ifBlank { "—" }}\n")
             append("执行规格：${listOf(task.mappedColor, task.mappedSize).filter(String::isNotBlank).joinToString(" / ").ifBlank { "—" }}\n")
@@ -913,6 +1022,8 @@ class TaskHistoryFragment : Fragment() {
         resultColumn.addView(context.card(context.cardColumn().apply {
             addView(context.label("CG-${task.taskId}", 20f, context.getColor(R.color.agent_text), true))
             addView(context.label(purchaseStatus(task.status), 14f, statusColor(task.status)).apply { setPadding(0, context.dp(4), 0, context.dp(12)) })
+            addView(context.label(infoHead, 14f))
+            openInPddSection(task.pddGoodsId, purchase = true)?.let(::addView)
             addView(context.label(info, 14f))
         }), collectionCardParams())
         val lastFailure = detail.lastFailureMessage?.takeIf(String::isNotBlank)

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

@@ -0,0 +1,76 @@
+package cn.ilapage.goauto.agent
+
+import cn.ilapage.goauto.agent.network.*
+import cn.ilapage.goauto.agent.persistence.syncFailure
+import java.net.HttpURLConnection
+import java.net.SocketTimeoutException
+import java.net.URL
+import org.junit.Assert.*
+import org.junit.Test
+
+class AgentTransportTimeoutTest {
+    @Test
+    fun loopbackPeerThatWithholdsResponseUsesExistingReadTimeoutAndResponseCategory() {
+        val socket = java.net.ServerSocket(0, 1, java.net.InetAddress.getLoopbackAddress())
+        val release = java.util.concurrent.CountDownLatch(1)
+        val accepted = java.util.concurrent.CountDownLatch(1)
+        val worker =
+            kotlin.concurrent.thread(isDaemon = true) {
+                socket.accept().use {
+                    accepted.countDown()
+                    release.await(20, java.util.concurrent.TimeUnit.SECONDS)
+                }
+            }
+        try {
+            val error =
+                assertThrows(AgentTransportTimeout::class.java) {
+                    AgentApiClient("http://127.0.0.1:${socket.localPort}")
+                        .heartbeat("synthetic", null)
+                }
+            assertEquals(0, accepted.count)
+            assertEquals(RequestStage.RESPONSE, error.stage)
+            assertEquals("timeout_response", syncFailure(error, "heartbeat", 1000, 1).category)
+        } finally {
+            release.countDown()
+            socket.close()
+            worker.join(1000)
+        }
+    }
+
+    @Test
+    fun timeoutCategoryComesFromActualConnectionStageNotExceptionMessage() {
+        for (stage in RequestStage.values()) {
+            val connection =
+                object : HttpURLConnection(URL("http://127.0.0.1")) {
+                    override fun connect() {
+                        if (stage == RequestStage.CONNECT)
+                            throw SocketTimeoutException("Read timed out")
+                    }
+
+                    override fun disconnect() {}
+
+                    override fun usingProxy() = false
+
+                    override fun getOutputStream(): java.io.OutputStream {
+                        if (stage == RequestStage.UNKNOWN)
+                            throw SocketTimeoutException("connect timed out")
+                        return java.io.ByteArrayOutputStream()
+                    }
+
+                    override fun getResponseCode(): Int {
+                        throw SocketTimeoutException("connect timed out")
+                    }
+                }
+            val api = AgentApiClient("http://127.0.0.1", connectionFactory = { connection })
+            val error =
+                assertThrows(AgentTransportTimeout::class.java) { api.heartbeat("synthetic", null) }
+            assertEquals(stage, error.stage)
+            assertEquals(
+                "timeout_${stage.name.lowercase()}",
+                syncFailure(error, "heartbeat", 1000, 1).category,
+            )
+            assertEquals(10_000, connection.connectTimeout)
+            assertEquals(15_000, connection.readTimeout)
+        }
+    }
+}

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

@@ -0,0 +1,63 @@
+package cn.ilapage.goauto.agent
+
+import cn.ilapage.goauto.agent.ui.DeviceConnectionPolicy
+import cn.ilapage.goauto.agent.ui.DeviceConnectionReading
+import cn.ilapage.goauto.agent.ui.WirelessDebugState
+import java.net.InetAddress
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class DeviceConnectionPolicyTest {
+    private fun ip(text: String) = InetAddress.getByName(text)
+
+    @Test fun wifiWithIpv4ReturnsAddress() {
+        assertEquals("192.168.0.93", DeviceConnectionPolicy.selectWifiIpv4(true, listOf(ip("192.168.0.93"))))
+    }
+
+    @Test fun nonWifiReturnsNull() {
+        assertNull(DeviceConnectionPolicy.selectWifiIpv4(false, listOf(ip("10.0.0.2"))))
+    }
+
+    @Test fun wifiWithOnlyIpv6ReturnsNull() {
+        assertNull(DeviceConnectionPolicy.selectWifiIpv4(true, listOf(ip("2001:db8::1"))))
+    }
+
+    @Test fun wifiWithMultipleAddressesPicksIpv4() {
+        assertEquals(
+            "172.16.1.5",
+            DeviceConnectionPolicy.selectWifiIpv4(true, listOf(ip("2001:db8::1"), ip("172.16.1.5"))),
+        )
+    }
+
+    @Test fun loopbackIpv4IsSkipped() {
+        assertNull(DeviceConnectionPolicy.selectWifiIpv4(true, listOf(ip("127.0.0.1"))))
+    }
+
+    @Test fun debugRawValuesMapToState() {
+        assertEquals(WirelessDebugState.ENABLED, DeviceConnectionPolicy.debugState(1))
+        assertEquals(WirelessDebugState.DISABLED, DeviceConnectionPolicy.debugState(0))
+        assertEquals(WirelessDebugState.UNKNOWN, DeviceConnectionPolicy.debugState(2))
+        assertEquals(WirelessDebugState.UNKNOWN, DeviceConnectionPolicy.debugState(null))
+    }
+
+    @Test fun displayEnabledUsesPrimaryColor() {
+        val d = DeviceConnectionPolicy.display(DeviceConnectionReading("192.168.0.93", WirelessDebugState.ENABLED))
+        assertEquals("Wi-Fi IP：192.168.0.93", d.wifiText)
+        assertEquals("无线调试：已开启", d.debugText)
+        assertEquals(R.color.agent_primary_light, d.debugColor)
+    }
+
+    @Test fun displayDisabledUsesWarningColorAndNoWifiText() {
+        val d = DeviceConnectionPolicy.display(DeviceConnectionReading(null, WirelessDebugState.DISABLED))
+        assertEquals("Wi-Fi IP：未连接 Wi-Fi", d.wifiText)
+        assertEquals("无线调试：未开启", d.debugText)
+        assertEquals(R.color.agent_warning, d.debugColor)
+    }
+
+    @Test fun displayUnknownUsesMutedColor() {
+        val d = DeviceConnectionPolicy.display(DeviceConnectionReading(null, WirelessDebugState.UNKNOWN))
+        assertEquals("无线调试：无法读取", d.debugText)
+        assertEquals(R.color.agent_text_muted, d.debugColor)
+    }
+}

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

@@ -0,0 +1,315 @@
+package cn.ilapage.goauto.agent
+
+import cn.ilapage.goauto.agent.network.*
+import cn.ilapage.goauto.agent.persistence.*
+import java.net.InetAddress
+import java.net.ServerSocket
+import java.sql.DriverManager
+import java.util.concurrent.CopyOnWriteArrayList
+import kotlin.concurrent.thread
+import org.json.JSONArray
+import org.json.JSONObject
+import org.junit.Assert.*
+import org.junit.Test
+
+class HeartbeatReportCompatibilityTest {
+    @Test
+    fun trueFalseMissingFreshProcessAndTokenChangeControlNextRequest() {
+        val responses =
+            listOf(
+                success(true),
+                success(false),
+                success(true),
+                success(null),
+                success(true),
+                success(true),
+                success(true),
+            )
+        HttpFixture(responses).use { http ->
+            val negotiation = HeartbeatReportNegotiation()
+            var ack = 0
+            repeat(5) {
+                negotiation.heartbeat(
+                    AgentApiClient(http.origin),
+                    "token",
+                    null,
+                    emptyList(),
+                    { report() },
+                    { ack++ },
+                )
+            }
+            negotiation.heartbeat(
+                AgentApiClient(http.origin),
+                "changed",
+                null,
+                emptyList(),
+                { report() },
+                { ack++ },
+            )
+            HeartbeatReportNegotiation()
+                .heartbeat(
+                    AgentApiClient(http.origin),
+                    "changed",
+                    null,
+                    emptyList(),
+                    { report() },
+                    { ack++ },
+                )
+            assertEquals(
+                listOf(false, true, false, true, false, false, false),
+                http.requests.map { it.has("clientReport") },
+            )
+            assertEquals(2, ack)
+        }
+    }
+
+    @Test
+    fun originChangeRenegotiatesEvenWhenTokenUnchanged() {
+        HttpFixture(listOf(success(true))).use { first ->
+            HttpFixture(listOf(success(true))).use { second ->
+                val negotiation = HeartbeatReportNegotiation()
+                for (http in listOf(first, second)) negotiation.heartbeat(
+                    AgentApiClient(http.origin),
+                    "token",
+                    null,
+                    emptyList(),
+                    { report() },
+                    { fail("new origin cannot acknowledge") },
+                )
+                assertFalse(second.requests.single().has("clientReport"))
+            }
+        }
+    }
+
+    @Test
+    fun onlyExactOldServerRejectionCanDowngradeAndFallbackIsAtMostOnce() {
+        for ((status, code, message) in
+            listOf(
+                    401 to "INVALID_REQUEST" to "请求 JSON 无效",
+                    403 to "INVALID_REQUEST" to "请求 JSON 无效",
+                    409 to "DEVICE_TASK_MISMATCH" to "请求 JSON 无效",
+                    500 to "INVALID_REQUEST" to "请求 JSON 无效",
+                    422 to "INVALID_REQUEST" to "different",
+                    422 to "OTHER" to "请求 JSON 无效",
+                )
+                .map { Triple(it.first.first, it.first.second, it.second) }) {
+            HttpFixture(listOf(success(true), failure(status, code, message))).use { http ->
+                val negotiation = HeartbeatReportNegotiation()
+                val api = AgentApiClient(http.origin)
+                negotiation.heartbeat(
+                    api,
+                    "token",
+                    null,
+                    emptyList(),
+                    { report() },
+                    { fail("ack") },
+                )
+                assertThrows(AgentApiException::class.java) {
+                    negotiation.heartbeat(
+                        api,
+                        "token",
+                        null,
+                        emptyList(),
+                        { report() },
+                        { fail("ack") },
+                    )
+                }
+                assertEquals(2, http.requests.size)
+            }
+        }
+        HttpFixture(
+                listOf(
+                    success(true),
+                    failure(422, "INVALID_REQUEST", "请求 JSON 无效"),
+                    failure(422, "INVALID_REQUEST", "请求 JSON 无效"),
+                )
+            )
+            .use { http ->
+                val negotiation = HeartbeatReportNegotiation()
+                val api = AgentApiClient(http.origin)
+                negotiation.heartbeat(
+                    api,
+                    "token",
+                    null,
+                    emptyList(),
+                    { report() },
+                    { fail("ack") },
+                )
+                assertThrows(AgentApiException::class.java) {
+                    negotiation.heartbeat(
+                        api,
+                        "token",
+                        null,
+                        emptyList(),
+                        { report() },
+                        { fail("ack") },
+                    )
+                }
+                assertEquals(3, http.requests.size)
+            }
+    }
+
+    @Test
+    fun missingReportDoesNotFallbackAndInvalidIdentityCannotAcknowledge() {
+        HttpFixture(listOf(failure(422, "INVALID_REQUEST", "请求 JSON 无效"))).use { http ->
+            assertThrows(AgentApiException::class.java) {
+                HeartbeatReportNegotiation()
+                    .heartbeat(
+                        AgentApiClient(http.origin),
+                        "t",
+                        null,
+                        emptyList(),
+                        { report() },
+                        { fail("ack") },
+                    )
+            }
+            assertEquals(1, http.requests.size)
+        }
+        HttpFixture(listOf(success(true), success(false))).use { http ->
+            val negotiation = HeartbeatReportNegotiation()
+            val api = AgentApiClient(http.origin)
+            negotiation.heartbeat(api, "token", null, emptyList(), { report() }, { fail("ack") })
+            assertThrows(IllegalStateException::class.java) {
+                negotiation.heartbeat(
+                    api,
+                    "token",
+                    null,
+                    emptyList(),
+                    { report() },
+                    { fail("ack") },
+                ) {
+                    check(it.deviceId == 2L)
+                }
+            }
+        }
+    }
+
+    @Test
+    fun lostResponseDoesNotAcknowledgeOrResend() {
+        HttpFixture(listOf(success(true), null)).use { http ->
+            val negotiation = HeartbeatReportNegotiation()
+            val api = AgentApiClient(http.origin)
+            negotiation.heartbeat(api, "t", null, emptyList(), { report() }, { fail("ack") })
+            assertThrows(java.io.IOException::class.java) {
+                negotiation.heartbeat(api, "t", null, emptyList(), { report() }, { fail("ack") })
+            }
+            assertEquals(2, http.requests.size)
+        }
+    }
+
+    @Test
+    fun actualSerializedReportsFromSqliteReachHttpAndExportCrossLanguageFixtures() {
+        DriverManager.getConnection("jdbc:sqlite::memory:").use { db ->
+            AgentDiagnosticSchema.syncStatements.forEach {
+                db.createStatement().use { s -> s.execute(it) }
+            }
+            val store = SyncDiagnosticStore(JdbcSyncSql(db))
+            val at = 1_700_000_000_000L
+            val zero = store.snapshot("p", at)!!
+            val id = store.start("p", at, null, SyncContext())
+            store.finish(id, at + 100, 100, SyncFailure("heartbeat", "network", at + 100, 100))
+            val failed = store.snapshot("p", at + 200)!!
+            store.ack(failed)
+            store.start("old", at + 300, null, SyncContext())
+            val interrupted = store.snapshot("p", at + 400)!!
+            HttpFixture(List(4) { success(true) }).use { http ->
+                val negotiation = HeartbeatReportNegotiation()
+                val api = AgentApiClient(http.origin)
+                negotiation.heartbeat(api, "synthetic", null, emptyList(), { null }, {})
+                for (snapshot in listOf(zero, failed, interrupted)) negotiation.heartbeat(
+                    api,
+                    "synthetic",
+                    null,
+                    emptyList(),
+                    { snapshot.report },
+                    {},
+                )
+                val reports =
+                    JSONArray(http.requests.drop(1).map { it.getJSONObject("clientReport") })
+                assertEquals(3, reports.length())
+                for (i in 0..2) {
+                    assertEquals(8, reports.getJSONObject(i).length())
+                    assertTrue(reports.getJSONObject(i).toString().toByteArray().size <= 2048)
+                }
+                val file = java.io.File("../build/diagnostics378-client-reports.json")
+                requireNotNull(file.parentFile).mkdirs()
+                file.writeText(reports.toString(2), Charsets.UTF_8)
+            }
+        }
+    }
+
+    private fun report() =
+        JSONObject()
+            .put("snapshotSeq", 1)
+            .put("failedRounds", 0)
+            .put("latestFailureAt", JSONObject.NULL)
+            .put("latestFailureStep", JSONObject.NULL)
+            .put("latestFailureCategory", JSONObject.NULL)
+            .put("latestFailureDurationMs", JSONObject.NULL)
+            .put("previousSyncDurationMs", JSONObject.NULL)
+            .put("hasInterruptedRound", false)
+
+    private fun success(capability: Boolean?): Pair<Int, String> =
+        200 to
+            JSONObject()
+                .put(
+                    "data",
+                    JSONObject().put("deviceId", 1).put("online", true).put("busy", false).apply {
+                        capability?.let { put("acceptsClientReport", it) }
+                    },
+                )
+                .toString()
+
+    private fun failure(status: Int, code: String, message: String) =
+        status to JSONObject().put("code", code).put("message", message).toString()
+}
+
+private class HttpFixture(responses: List<Pair<Int, String>?>) : AutoCloseable {
+    private val socket =
+        ServerSocket(0, 10, InetAddress.getLoopbackAddress()).apply { soTimeout = 5000 }
+    val origin = "http://127.0.0.1:${socket.localPort}"
+    val requests = CopyOnWriteArrayList<JSONObject>()
+    private var error: Throwable? = null
+    private val worker =
+        thread(isDaemon = true) {
+            try {
+                for (response in responses) socket.accept().use { client ->
+                    client.soTimeout = 5000
+                    val input = client.getInputStream().bufferedReader()
+                    var length = 0
+                    while (true) {
+                        val line = input.readLine() ?: error("missing headers")
+                        if (line.isEmpty()) break
+                        if (line.startsWith("Content-Length:", true))
+                            length = line.substringAfter(':').trim().toInt()
+                    }
+                    check(length in 1..4096)
+                    val body = CharArray(length)
+                    var read = 0
+                    while (read < length) {
+                        val count = input.read(body, read, length - read)
+                        check(count > 0)
+                        read += count
+                    }
+                    requests.add(JSONObject(String(body)))
+                    if (response != null) {
+                        val bytes = response.second.toByteArray(Charsets.UTF_8)
+                        client
+                            .getOutputStream()
+                            .write(
+                                ("HTTP/1.1 ${response.first} OK\r\nContent-Length: ${bytes.size}\r\nConnection: close\r\n\r\n")
+                                    .toByteArray() + bytes
+                            )
+                    }
+                }
+            } catch (e: Throwable) {
+                if (!socket.isClosed) error = e
+            }
+        }
+
+    override fun close() {
+        socket.close()
+        worker.join(1000)
+        error?.let { throw AssertionError("HTTP fixture failed", it) }
+    }
+}

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

@@ -0,0 +1,86 @@
+package cn.ilapage.goauto.agent
+
+import cn.ilapage.goauto.agent.network.*
+import java.net.ServerSocket
+import kotlin.concurrent.thread
+import org.json.JSONObject
+import org.junit.Assert.*
+import org.junit.Test
+
+class HeartbeatReportProtocolTest {
+    @Test
+    fun negotiatesThenDowngradesOnceWithSameRequestIdAndNoAck() {
+        val requests = mutableListOf<JSONObject>()
+        val server =
+            ServerSocket(0, 3, java.net.InetAddress.getLoopbackAddress()).apply { soTimeout = 5000 }
+        val worker =
+            thread(isDaemon = true) {
+                repeat(3) {
+                    server.accept().use { socket ->
+                        socket.soTimeout = 5000
+                        val input = socket.getInputStream().bufferedReader()
+                        var length = 0
+                        while (true) {
+                            val line = input.readLine() ?: error("missing header")
+                            if (line.isEmpty()) break
+                            if (line.startsWith("Content-Length:", true))
+                                length = line.substringAfter(':').trim().toInt()
+                        }
+                        check(length in 1..4096)
+                        val chars = CharArray(length)
+                        var read = 0
+                        while (read < length) {
+                            val count = input.read(chars, read, length - read)
+                            check(count > 0)
+                            read += count
+                        }
+                        val request = JSONObject(String(chars))
+                        requests.add(request)
+                        val reject = request.has("clientReport")
+                        val response =
+                            if (reject) """{"code":"INVALID_REQUEST","message":"请求 JSON 无效"}"""
+                            else
+                                """{"data":{"deviceId":1,"online":true,"busy":false,"acceptsClientReport":true}}"""
+                        val bytes = response.toByteArray()
+                        socket
+                            .getOutputStream()
+                            .write(
+                                ("HTTP/1.1 ${if(reject) 422 else 200} OK\r\nContent-Length: ${bytes.size}\r\nConnection: close\r\n\r\n")
+                                    .toByteArray() + bytes
+                            )
+                    }
+                }
+            }
+        try {
+            val negotiation = HeartbeatReportNegotiation()
+            var ack = 0
+            val api = AgentApiClient("http://127.0.0.1:${server.localPort}")
+            negotiation.heartbeat(
+                api,
+                "token",
+                null,
+                emptyList(),
+                { JSONObject().put("snapshotSeq", 1) },
+                { ack++ },
+            )
+            negotiation.heartbeat(
+                api,
+                "token",
+                null,
+                emptyList(),
+                { JSONObject().put("snapshotSeq", 1) },
+                { ack++ },
+            )
+            assertEquals(3, requests.size)
+            assertFalse(requests[0].has("clientReport"))
+            assertTrue(requests[1].has("clientReport"))
+            assertFalse(requests[2].has("clientReport"))
+            assertEquals(requests[1].getString("requestId"), requests[2].getString("requestId"))
+            assertEquals(0, ack)
+            assertFalse(negotiation.acceptsReport)
+        } finally {
+            server.close()
+            worker.join(1000)
+        }
+    }
+}

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

@@ -9,6 +9,7 @@ import cn.ilapage.goauto.agent.automation.NodeSelector
 import cn.ilapage.goauto.agent.automation.PageEvidence
 import cn.ilapage.goauto.agent.automation.PddCollectorConfig
 import cn.ilapage.goauto.agent.automation.PddCollectorDriver
+import cn.ilapage.goauto.agent.automation.PddCollectorResult
 import cn.ilapage.goauto.agent.automation.PddProductDetailCollector
 import cn.ilapage.goauto.agent.automation.PddScreenParser
 import cn.ilapage.goauto.agent.automation.PurchasePanelContext
@@ -1105,10 +1106,50 @@ class PddProductDetailCollectorTest {
     }
 
     @Test
-    fun `duplicate sizes after price cleanup reject the whole size dimension`() {
+    fun `same-frame sizes with one normalized name keep a single value and mark conflict`() {
         val driver = FakeCollectorDriver(
             colors = listOf("黑色"),
-            sizePages = listOf(listOf("XL ¥10", "XL ￥12")),
+            sizePages = listOf(listOf("XL ¥10", "XL ￥12", "S")),
+            prices = mapOf("黑色" to 1000L),
+        )
+        var clock = 0L
+
+        val result = PddProductDetailCollector(driver, { clock }, { clock += it }).collect(GOODS_ID, rule())
+
+        assertTrue(result.successful)
+        val payload = requireNotNull(result.payload)
+        assertEquals("completed_partial", payload.status)
+        assertEquals(listOf("XL", "S"), payload.dimensions.first { it.key == "size" }.values)
+        assertEquals(1, payload.missing.count { it == "spec_dimension_conflict:size" })
+        assertFalse(payload.missing.contains("spec_dimension_invalid:size"))
+        assertFalse(payload.missing.contains("size"))
+        assertEquals(listOf("XL", "S"), payload.skus.map { it.specs.getValue("size") })
+    }
+
+    @Test
+    fun `size price appearing between passes keeps the dimension and marks conflict once`() {
+        val driver = FakeCollectorDriver(
+            colors = listOf("黑色"),
+            sizePages = listOf(listOf("XL", "S"), listOf("XL ¥29.9", "M")),
+            prices = mapOf("黑色" to 1000L),
+        )
+        var clock = 0L
+
+        val result = PddProductDetailCollector(driver, { clock }, { clock += it }).collect(GOODS_ID, rule())
+
+        assertTrue(result.successful)
+        val payload = requireNotNull(result.payload)
+        assertEquals("completed_partial", payload.status)
+        assertEquals(listOf("XL", "S", "M"), payload.dimensions.first { it.key == "size" }.values)
+        assertEquals(1, payload.missing.count { it == "spec_dimension_conflict:size" })
+        assertFalse(payload.missing.contains("spec_dimension_invalid:size"))
+    }
+
+    @Test
+    fun `residual currency in a size still rejects the whole size dimension`() {
+        val driver = FakeCollectorDriver(
+            colors = listOf("黑色"),
+            sizePages = listOf(listOf("XL ¥10 热卖", "S")),
             prices = mapOf("黑色" to 1000L),
         )
         var clock = 0L
@@ -1120,9 +1161,151 @@ class PddProductDetailCollectorTest {
         assertEquals("completed_partial", payload.status)
         assertTrue(payload.dimensions.none { it.key == "size" })
         assertTrue(payload.missing.contains("spec_dimension_invalid:size"))
+        assertFalse(payload.missing.contains("spec_dimension_conflict:size"))
         assertTrue(payload.skus.all { "size" !in it.specs })
     }
 
+    @Test
+    fun `an empty normalized size still rejects the whole size dimension`() {
+        val driver = FakeCollectorDriver(
+            colors = listOf("黑色"),
+            sizePages = listOf(listOf("¥10", "S")),
+            prices = mapOf("黑色" to 1000L),
+        )
+        var clock = 0L
+
+        val payload = requireNotNull(
+            PddProductDetailCollector(driver, { clock }, { clock += it }).collect(GOODS_ID, rule()).payload,
+        )
+
+        assertTrue(payload.dimensions.none { it.key == "size" })
+        assertTrue(payload.missing.contains("spec_dimension_invalid:size"))
+    }
+
+    @Test
+    fun `continuation sizes drop the trailing price like the parsed path`() {
+        val driver = FakeCollectorDriver(
+            colors = listOf("红色"),
+            sizePages = listOf(listOf("S", "M"), listOf("L ¥10", "XL")),
+            hideDimensionHeadingsAfterFirstVerticalPage = true,
+        )
+        var clock = 0L
+
+        val result = PddProductDetailCollector(driver, { clock }, { clock += it }).collect(GOODS_ID, rule())
+
+        assertTrue(result.successful)
+        val payload = requireNotNull(result.payload)
+        assertEquals(listOf("S", "M", "L", "XL"), payload.dimensions.first { it.key == "size" }.values)
+        assertTrue(payload.missing.none { it.startsWith("spec_dimension_") })
+    }
+
+    @Test
+    fun `continuation conflict is seen before de-duplication and keeps one value`() {
+        val driver = FakeCollectorDriver(
+            colors = listOf("红色"),
+            sizePages = listOf(listOf("S", "M"), listOf("XL ¥10", "XL", "L")),
+            hideDimensionHeadingsAfterFirstVerticalPage = true,
+        )
+        var clock = 0L
+
+        val result = PddProductDetailCollector(driver, { clock }, { clock += it }).collect(GOODS_ID, rule())
+
+        assertTrue(result.successful)
+        val payload = requireNotNull(result.payload)
+        assertEquals(listOf("S", "M", "XL", "L"), payload.dimensions.first { it.key == "size" }.values)
+        assertEquals(1, payload.missing.count { it == "spec_dimension_conflict:size" })
+        assertFalse(payload.missing.contains("spec_dimension_invalid:size"))
+    }
+
+    @Test
+    fun `continuation size with residual currency rejects the whole size dimension`() {
+        val driver = FakeCollectorDriver(
+            colors = listOf("红色"),
+            sizePages = listOf(listOf("S", "M"), listOf("L ¥10 热卖", "XL")),
+            hideDimensionHeadingsAfterFirstVerticalPage = true,
+        )
+        var clock = 0L
+
+        val payload = requireNotNull(
+            PddProductDetailCollector(driver, { clock }, { clock += it }).collect(GOODS_ID, rule()).payload,
+        )
+
+        assertTrue(payload.dimensions.none { it.key == "size" })
+        assertTrue(payload.missing.contains("spec_dimension_invalid:size"))
+    }
+
+    @Test
+    fun `normalization conflict trace carries only counts and enum values`() {
+        val traces = mutableListOf<String>()
+        val driver = FakeCollectorDriver(
+            colors = listOf("黑色"),
+            sizePages = listOf(listOf("XL", "S"), listOf("XL ¥29.9", "M")),
+            prices = mapOf("黑色" to 1000L),
+        )
+        var clock = 0L
+
+        PddProductDetailCollector(driver, { clock }, { clock += it }, trace = traces::add).collect(GOODS_ID, rule())
+
+        val lines = traces.filter { it.startsWith("spec-normalize ") }
+        assertEquals(1, lines.size)
+        assertEquals(
+            "spec-normalize dim=size outcome=conflict_kept reason=normalized_conflict path=parsed pass=1 sameFrame=false " +
+                "onlyTrailingPriceDiff=true rawVariants=2 candidates=2 badgeCaptionMerged=0",
+            lines.single(),
+        )
+        assertTrue(lines.none { it.contains("XL") || it.contains("¥") })
+    }
+
+    @Test
+    fun `normalization invalid trace reports reason without node text`() {
+        val traces = mutableListOf<String>()
+        val driver = FakeCollectorDriver(
+            colors = listOf("黑色"),
+            sizePages = listOf(listOf("XL ¥10 热卖", "S")),
+            prices = mapOf("黑色" to 1000L),
+        )
+        var clock = 0L
+
+        PddProductDetailCollector(driver, { clock }, { clock += it }, trace = traces::add).collect(GOODS_ID, rule())
+
+        val line = traces.single { it.startsWith("spec-normalize ") }
+        assertTrue(line.contains("dim=size outcome=invalid_rejected reason=unsafe_currency path=parsed"))
+        assertTrue(line.contains("candidates=2"))
+        assertTrue(!line.contains("热卖") && !line.contains("XL"))
+    }
+
+    @Test
+    fun `same-frame color conflict trace flags sameFrame and badge count`() {
+        val traces = mutableListOf<String>()
+        val driver = FakeCollectorDriver(
+            colors = listOf("红色 ¥10", "红色 ￥12"),
+            prices = mapOf("红色 ¥10" to 1000L),
+            imageColorCards = true,
+        )
+        var clock = 0L
+
+        PddProductDetailCollector(driver, { clock }, { clock += it }, trace = traces::add).collect(GOODS_ID, rule())
+
+        val line = traces.first { it.startsWith("spec-normalize dim=color") }
+        assertTrue(line.contains("outcome=conflict_kept"))
+        assertTrue(line.contains("sameFrame=true"))
+        assertTrue(line.contains("onlyTrailingPriceDiff=true"))
+        assertTrue(line.contains("rawVariants=2"))
+        assertTrue(line.endsWith("badgeCaptionMerged=0"))
+    }
+
+    @Test
+    fun `parser counts merged badge captions without exposing text`() {
+        val parsed = PddScreenParser.parse(badgeCardsSnapshot(purchase1Cards()), config(), GOODS_ID, evidence())
+        assertEquals(2, parsed.badgeCaptionMerged)
+
+        val plain = PddScreenParser.parse(
+            badgeCardsSnapshot(listOf(badgeCard(3, 36, "黑色 微喇夏天薄款长裤 ¥9.8", "黑色 微喇夏天薄款长裤 ¥9.8"))),
+            config(), GOODS_ID, evidence(),
+        )
+        assertEquals(0, plain.badgeCaptionMerged)
+    }
+
     @Test
     fun `trailing color prices are normalized across dimension price and sku`() {
         val driver = FakeCollectorDriver(
@@ -1143,10 +1326,32 @@ class PddProductDetailCollectorTest {
     }
 
     @Test
-    fun `duplicate colors after price cleanup reject color dependents`() {
+    fun `duplicate colors after price cleanup keep one value and mark conflict`() {
         val driver = FakeCollectorDriver(
-            colors = listOf("红色 ¥10", "红色 ￥12"),
-            prices = mapOf("红色 ¥10" to 1000L, "红色 ￥12" to 1200L),
+            colors = listOf("红色 ¥10", "红色 ￥12", "蓝色"),
+            prices = mapOf("红色 ¥10" to 1000L, "红色 ￥12" to 1200L, "蓝色" to 1500L),
+            imageColorCards = true,
+        )
+        var clock = 0L
+
+        val result = PddProductDetailCollector(driver, { clock }, { clock += it }).collect(GOODS_ID, rule())
+
+        assertTrue(result.successful)
+        val payload = requireNotNull(result.payload)
+        assertEquals("completed_partial", payload.status)
+        assertEquals(listOf("红色", "蓝色"), payload.dimensions.first { it.key == "color" }.values)
+        assertEquals(listOf("红色", "蓝色"), payload.colorPrices.map { it.color })
+        assertEquals(1000L, payload.colorPrices.first { it.color == "红色" }.priceCent)
+        assertEquals(1, payload.missing.count { it == "spec_dimension_conflict:color" })
+        assertFalse(payload.missing.contains("spec_dimension_invalid:color"))
+        assertEquals(listOf("红色 ¥10", "蓝色"), driver.clickedLabels)
+    }
+
+    @Test
+    fun `residual currency in a color still rejects color dependents`() {
+        val driver = FakeCollectorDriver(
+            colors = listOf("红色 ¥10 热卖", "蓝色"),
+            prices = mapOf("红色 ¥10 热卖" to 1000L, "蓝色" to 1500L),
             imageColorCards = true,
         )
         var clock = 0L
@@ -1160,6 +1365,7 @@ class PddProductDetailCollectorTest {
         assertTrue(payload.colorPrices.isEmpty())
         assertTrue(payload.skus.isEmpty())
         assertTrue(payload.missing.contains("spec_dimension_invalid:color"))
+        assertFalse(payload.missing.contains("spec_dimension_conflict:color"))
         assertTrue(result.colorImages.isEmpty())
     }
 
@@ -1212,7 +1418,7 @@ class PddProductDetailCollectorTest {
         )
         var clock = 0L
 
-        val result = PddProductDetailCollector(driver, { clock }, { clock += it }).collect(GOODS_ID, rule())
+        val result = PddProductDetailCollector(driver, { clock }, { clock += it }).collect(GOODS_ID, rule(config().copy(timeoutsMs = config().timeoutsMs + ("overall" to 60_000))))
 
         assertTrue(result.successful)
         assertEquals(colors, requireNotNull(result.payload).dimensions.first { it.key == "color" }.values)
@@ -2092,6 +2298,325 @@ class PddProductDetailCollectorTest {
         }
     }
 
+    private fun gridColors(count: Int) = (1..count).map { "款%02d色".format(it) }
+
+    private fun gridConfig() = config().copy(
+        timeoutsMs = config().timeoutsMs + ("overall" to 600_000),
+        limits = config().limits + mapOf("specHorizontalSwipes" to 12, "specVerticalSwipes" to 3, "stableEdgeReads" to 2),
+    )
+
+    private fun sharedGridCollects47Colors(step: Int) {
+        // 47 colors in 2 rows x 24 columns sharing one horizontal container.
+        val colors = gridColors(47)
+        val grid = listOf(colors.filterIndexed { i, _ -> i % 2 == 0 }, colors.filterIndexed { i, _ -> i % 2 == 1 })
+        assertEquals(listOf(24, 23), grid.map { it.size })
+        val prices = colors.mapIndexed { i, c -> c to 1000L + i * 10L }.toMap()
+        val events = mutableListOf<AgentDiagnosticEvent>()
+        val driver = FakeCollectorDriver(
+            colors = colors,
+            prices = prices,
+            horizontalGrid = grid,
+            gridVisibleColumns = 4,
+            gridStep = step,
+            sizePages = listOf(listOf("S"), listOf("M")),
+            hideColorHeadingAfterFirstVerticalPage = true,
+        )
+        var clock = 0L
+
+        val result = PddProductDetailCollector(driver, { clock }, { clock += it }, taskId = 370, diagnostic = events::add)
+            .collect(GOODS_ID, rule(gridConfig()))
+
+        assertTrue(result.successful)
+        val payload = requireNotNull(result.payload)
+        assertEquals("completed", payload.status)
+        assertEquals(colors.toSet(), payload.dimensions.first { it.key == "color" }.values.toSet())
+        assertEquals(47, payload.colorPrices.size)
+        assertEquals(prices, payload.colorPrices.associate { it.color to it.priceCent })
+        // 47 colors x 2 sizes, each SKU carrying its own color's price.
+        assertEquals(94, payload.skus.size)
+        assertEquals(setOf("S", "M"), payload.skus.map { it.specs.getValue("size") }.toSet())
+        payload.skus.forEach { assertEquals(prices.getValue(it.specs.getValue("color")), it.priceCent) }
+        assertTrue(payload.missing.isEmpty())
+        // The shared container is swept once: no reverse sweep away from an edge.
+        assertTrue(driver.gridSwipeLog.none { it.first == SwipeDirection.RIGHT && it.second > 0 })
+        assertTrue(driver.gridSwipeLog.count { it.first == SwipeDirection.LEFT } <= 12)
+        val event = events.single { it.stage == AgentDiagnosticStage.COLOR_DISCOVERY }
+        assertEquals(47, event.clickableColorCount)
+    }
+
+    @Test
+    fun `shared container two row grid collects all colors when swipes overlap`() = sharedGridCollects47Colors(step = 3)
+
+    @Test
+    fun `shared container two row grid collects all colors when swipes move whole pages`() = sharedGridCollects47Colors(step = 4)
+
+    private fun sharedPixelGridCollects(count: Int, step: Int, maxSwipes: Int, jitter: Boolean = false) {
+        // Shared container, ~3.5 columns per screen, pixel-sized swipes whose
+        // last move is shorter than one column; partly visible columns count.
+        val colors = gridColors(count)
+        val grid = listOf(colors.filterIndexed { i, _ -> i % 2 == 0 }, colors.filterIndexed { i, _ -> i % 2 == 1 })
+        val prices = colors.mapIndexed { i, c -> c to 1000L + i * 10L }.toMap()
+        val driver = FakeCollectorDriver(
+            colors = colors,
+            prices = prices,
+            horizontalGrid = grid,
+            gridPixelStep = step,
+            gridClickJitter = jitter,
+            sizePages = listOf(listOf("S"), listOf("M")),
+            hideColorHeadingAfterFirstVerticalPage = true,
+        )
+        var clock = 0L
+
+        val result = PddProductDetailCollector(driver, { clock }, { clock += it }, taskId = 370)
+            .collect(GOODS_ID, rule(gridConfig()))
+
+        assertTrue(result.successful)
+        val payload = requireNotNull(result.payload)
+        assertEquals("completed", payload.status)
+        assertEquals(colors.toSet(), payload.dimensions.first { it.key == "color" }.values.toSet())
+        assertEquals(prices, payload.colorPrices.associate { it.color to it.priceCent })
+        assertTrue(payload.missing.isEmpty())
+        assertTrue(driver.gridSwipeLog.none { it.first == SwipeDirection.RIGHT && it.second > 0 })
+        val horizontal = driver.gridSwipeLog.size
+        assertTrue("horizontal swipes $horizontal > $maxSwipes ${driver.gridSwipeLog}", horizontal <= maxSwipes)
+        assertEquals(count, payload.colorPrices.size)
+        assertEquals(count * 2, payload.skus.size)
+        payload.skus.forEach { assertEquals(prices.getValue(it.specs.getValue("color")), it.priceCent) }
+    }
+
+    @Test
+    fun `shared container with click layout jitter still skips the reverse sweep`() =
+        sharedPixelGridCollects(count = 47, step = 640, maxSwipes = 12, jitter = true)
+
+    @Test
+    fun `shared container nine colors with click layout jitter does not sweep back`() =
+        sharedPixelGridCollects(count = 9, step = 200, maxSwipes = 6, jitter = true)
+
+    private fun midStartGrid(
+        failAttempts: Set<Int>,
+        initialOffset: Int = 2000,
+        traces: MutableList<String> = mutableListOf(),
+        captureCostMillis: Long = 0L,
+        elapsed: LongArray = LongArray(1),
+    ): Pair<FakeCollectorDriver, PddCollectorResult> {
+        val colors = gridColors(47)
+        val grid = listOf(colors.filterIndexed { i, _ -> i % 2 == 0 }, colors.filterIndexed { i, _ -> i % 2 == 1 })
+        val prices = colors.mapIndexed { i, c -> c to 1000L + i * 10L }.toMap()
+        var clock = 0L
+        val driver = FakeCollectorDriver(
+            colors = colors,
+            prices = prices,
+            horizontalGrid = grid,
+            gridPixelStep = 640,
+            captureCostMillis = captureCostMillis,
+            captureAdvance = { clock += it },
+            gridInitialOffset = initialOffset,
+            gridRightFailAttempts = failAttempts,
+            sizePages = listOf(listOf("S"), listOf("M")),
+            hideColorHeadingAfterFirstVerticalPage = true,
+        )
+        val result = PddProductDetailCollector(driver, { clock }, { clock += it }, trace = traces::add, taskId = 370)
+            .collect(GOODS_ID, rule(gridConfig()))
+        elapsed[0] = clock
+        return driver to result
+    }
+
+    private fun assertAll47Collected(result: PddCollectorResult) {
+        assertTrue(result.successful)
+        val payload = requireNotNull(result.payload)
+        assertEquals("completed", payload.status)
+        val collected = payload.dimensions.first { it.key == "color" }.values
+        assertEquals("collected ${collected.size}/47 colors", gridColors(47).toSet(), collected.toSet())
+        assertEquals(47, payload.colorPrices.size)
+        assertTrue(payload.missing.isEmpty())
+    }
+
+    private class SettleRun(
+        val driver: FakeCollectorDriver,
+        val result: PddCollectorResult,
+        val traces: List<String>,
+        val elapsedMs: Long,
+    )
+
+    // The grid keeps coasting until HORIZONTAL_SETTLE_MILLIS-ish of simulated
+    // clock time has passed since the last movement (timeBased), mirroring the
+    // ~1-1.3s measured on a device.
+    private fun inertiaGrid(timeBased: Boolean): SettleRun {
+        val colors = gridColors(47)
+        val grid = listOf(colors.filterIndexed { i, _ -> i % 2 == 0 }, colors.filterIndexed { i, _ -> i % 2 == 1 })
+        val prices = colors.mapIndexed { i, c -> c to 1000L + i * 10L }.toMap()
+        var clock = 0L
+        val driver = FakeCollectorDriver(
+            colors = colors,
+            prices = prices,
+            horizontalGrid = grid,
+            gridPixelStep = 640,
+            gridSettleClock = if (timeBased) ({ clock }) else null,
+            gridSettleMillis = if (timeBased) 1000L else 0L,
+            gridStrictClickPosition = true,
+            sizePages = listOf(listOf("S"), listOf("M")),
+            hideColorHeadingAfterFirstVerticalPage = true,
+        )
+        val traces = mutableListOf<String>()
+        val result = PddProductDetailCollector(driver, { clock }, { clock += it }, trace = traces::add, taskId = 370)
+            .collect(GOODS_ID, rule(gridConfig()))
+        return SettleRun(driver, result, traces, clock)
+    }
+
+    @Test
+    fun `color grid waits a fixed time after a horizontal swipe without extra parses`() {
+        val calm = inertiaGrid(timeBased = false)
+        val coasting = inertiaGrid(timeBased = true)
+        println("SIM_ELAPSED_47_COLORS=${coasting.elapsedMs}ms settles=${coasting.traces.count { it.startsWith("color-settle") }}")
+
+        assertAll47Collected(coasting.result)
+        assertTrue(coasting.traces.none { it.startsWith("color-click-miss") })
+        val settles = coasting.traces.filter { it.startsWith("color-settle") }
+        assertTrue(settles.isNotEmpty())
+        settles.forEach { assertEquals("color-settle waitedMs=1200", it) }
+        // No polling reads: the same captures and clicks as a grid that never coasts.
+        assertEquals(calm.driver.captureCount, coasting.driver.captureCount)
+        assertEquals(calm.driver.clickCount, coasting.driver.clickCount)
+    }
+
+    @Test
+    fun `reset from the right end with scattered anchor failures still confirms the left end`() {
+        val traces = mutableListOf<String>()
+        val elapsed = LongArray(1)
+        val (driver, result) = midStartGrid(
+            failAttempts = setOf(1, 3, 5, 7),
+            initialOffset = 4675,
+            traces = traces,
+            captureCostMillis = 900L,
+            elapsed = elapsed,
+        )
+        println("SIM_ELAPSED_RIGHT_START=${elapsed[0]}ms")
+        assertTrue("elapsed ${elapsed[0]}", elapsed[0] < BASELINE_RIGHT_START_ELAPSED_MS * 7 / 10)
+
+        assertAll47Collected(result)
+        assertTrue(traces.toString(), traces.any { it.startsWith("color-start confirmed=true") && it.contains("anchorRetries=4") })
+        val lastRightWithOffset = driver.gridSwipeLog.indexOfLast { it.first == SwipeDirection.RIGHT && it.second > 0 }
+        val firstLeft = driver.gridSwipeLog.indexOfFirst { it.first == SwipeDirection.LEFT }
+        assertTrue("no reverse sweep after the first LEFT", lastRightWithOffset < firstLeft)
+    }
+
+    @Test
+    fun `mid start with one anchor failure while resetting retries and still skips the reverse sweep`() {
+        val (driver, result) = midStartGrid(failAttempts = setOf(2))
+
+        assertAll47Collected(result)
+        // The retry used a different color node than the failed attempt.
+        val rights = driver.swipes.filter { it.first == SwipeDirection.RIGHT }
+        assertTrue(rights[0].second?.label != rights[1].second?.label)
+        // Reset reached the left edge, then the sweep ran left-to-right once.
+        val lastRightWithOffset = driver.gridSwipeLog.indexOfLast { it.first == SwipeDirection.RIGHT && it.second > 0 }
+        val firstLeft = driver.gridSwipeLog.indexOfFirst { it.first == SwipeDirection.LEFT }
+        assertTrue("no reverse sweep after the first LEFT", lastRightWithOffset < firstLeft)
+    }
+
+    @Test
+    fun `mid start whose reset cannot be confirmed keeps the full snake sweep`() {
+        val (driver, result) = midStartGrid(failAttempts = setOf(1, 2, 3))
+
+        assertAll47Collected(result)
+        // Reverse sweep from the right edge happened after the LEFT sweep.
+        val firstLeft = driver.gridSwipeLog.indexOfFirst { it.first == SwipeDirection.LEFT }
+        assertTrue(driver.gridSwipeLog.drop(firstLeft).any { it.first == SwipeDirection.RIGHT && it.second > 0 })
+    }
+
+    @Test
+    fun `shared container with a row that fails to follow keeps the full snake sweep`() {
+        val colors = gridColors(47)
+        val grid = listOf(colors.filterIndexed { i, _ -> i % 2 == 0 }, colors.filterIndexed { i, _ -> i % 2 == 1 })
+        val driver = FakeCollectorDriver(
+            colors = colors,
+            horizontalGrid = grid,
+            gridPixelStep = 640,
+            gridSwipeWhereOnlyFirstRowMoves = 3,
+            sizePages = listOf(listOf("S"), listOf("M")),
+            hideColorHeadingAfterFirstVerticalPage = true,
+        )
+        var clock = 0L
+
+        val result = PddProductDetailCollector(driver, { clock }, { clock += it }, taskId = 370)
+            .collect(GOODS_ID, rule(gridConfig()))
+
+        assertTrue(result.successful)
+        assertTrue(driver.gridSwipeLog.any { it.first == SwipeDirection.RIGHT && it.second > 0 })
+    }
+
+    @Test
+    fun `shared container nine colors with partial last swipe does not sweep back`() =
+        sharedPixelGridCollects(count = 9, step = 200, maxSwipes = 6)
+
+    @Test
+    fun `shared container forty seven colors with partial last swipe stays within twelve swipes`() =
+        sharedPixelGridCollects(count = 47, step = 640, maxSwipes = 12)
+
+    @Test
+    fun `independent row grid keeps the snake sweep and does not claim a shared container`() {
+        val colors = gridColors(20)
+        val grid = listOf(colors.take(10), colors.drop(10))
+        val driver = FakeCollectorDriver(
+            colors = colors,
+            horizontalGrid = grid,
+            gridVisibleColumns = 4,
+            gridStep = 3,
+            gridSharedContainer = false,
+            sizePages = listOf(listOf("S"), listOf("M")),
+            hideColorHeadingAfterFirstVerticalPage = true,
+        )
+        var clock = 0L
+
+        val result = PddProductDetailCollector(driver, { clock }, { clock += it }).collect(GOODS_ID, rule(gridConfig()))
+
+        assertTrue(result.successful)
+        val collected = requireNotNull(result.payload).dimensions.first { it.key == "color" }.values
+        // Row 0 is swept to its end; row 1 only exposes its first window because
+        // it starts at its own left edge, exactly as before.
+        assertEquals((colors.take(10) + colors.drop(10).take(4)).toSet(), collected.toSet())
+        assertEquals(14, collected.size)
+        assertTrue(driver.gridSwipeLog.any { it.first == SwipeDirection.RIGHT && it.second > 0 })
+    }
+
+    @Test
+    fun `row disappearing keeps reflow reason after later empty vertical reads`() {
+        val colors = listOf("A色", "B色", "C色", "D色", "E色", "F色")
+        val events = mutableListOf<AgentDiagnosticEvent>()
+        val driver = FakeCollectorDriver(
+            colors = colors,
+            colorPages = listOf(colors.take(4), colors.takeLast(2)),
+            rowSize = 2,
+            sizePages = listOf(listOf("S"), listOf("M")),
+            hideColorHeadingAfterFirstVerticalPage = true,
+        )
+        var clock = 0L
+
+        val result = PddProductDetailCollector(driver, { clock }, { clock += it }, taskId = 370, diagnostic = events::add)
+            .collect(GOODS_ID, rule(gridConfig()))
+
+        assertTrue(result.successful)
+        val event = events.single { it.stage == AgentDiagnosticStage.COLOR_DISCOVERY }
+        assertEquals(AgentDiagnosticReason.COLOR_ROW_REFLOWED, event.reason)
+        assertTrue(requireNotNull(event.colorTrailingEmptyReadCount) > 0)
+        assertEquals(null, event.colorHorizontalIncomplete)
+    }
+
+    @Test
+    fun `single row disjoint reflow keeps reflow reason`() {
+        val colors = listOf("A色", "B色", "C色", "D色")
+        val events = mutableListOf<AgentDiagnosticEvent>()
+        var clock = 0L
+
+        val result = PddProductDetailCollector(
+            FakeCollectorDriver(colors = colors, colorPages = listOf(colors.take(2), colors.takeLast(2))),
+            { clock }, { clock += it }, taskId = 370, diagnostic = events::add,
+        ).collect(GOODS_ID, rule())
+
+        assertTrue(result.successful)
+        assertEquals(AgentDiagnosticReason.COLOR_ROW_REFLOWED, events.single { it.stage == AgentDiagnosticStage.COLOR_DISCOVERY }.reason)
+    }
+
     private class FakeCollectorDriver(
         colors: List<String> = listOf("红色"),
         sizes: List<String> = listOf("S"),
@@ -2146,6 +2671,39 @@ class PddProductDetailCollectorTest {
         // restored to top. Heading count drops but color/size values are
         // untouched, so this must NOT be treated as a collapsed panel.
         private val specPanelDropsExtraDimensionAfterTopSwipe: Boolean = false,
+        // #370: horizontal multi-row color grid. Each swipe moves gridStep
+        // columns; gridSharedContainer moves all rows together, otherwise only
+        // the anchored row. Left/right swipes are logged with the largest
+        // column offset before the gesture.
+        private val horizontalGrid: List<List<String>>? = null,
+        private val gridVisibleColumns: Int = 4,
+        private val gridStep: Int = 3,
+        private val gridSharedContainer: Boolean = true,
+        // #370: when set, shared-container swipes move this many pixels (not whole
+        // columns) and columns partly inside the 835px viewport count as visible.
+        private val gridPixelStep: Int? = null,
+        // #370: after each click the grid nodes shift a few pixels, like the
+        // small layout change seen on a real device after selecting a color.
+        private val gridClickJitter: Boolean = false,
+        // #370: on this (1-based) horizontal swipe only the first row moves.
+        private val gridSwipeWhereOnlyFirstRowMoves: Int = 0,
+        // #370: the shared grid starts scrolled this many pixels to the right.
+        private val gridInitialOffset: Int = 0,
+        // #370: 1-based RIGHT swipe attempts that fail with anchorMissing.
+        private val gridRightFailAttempts: Set<Int> = emptySet(),
+        // #370: after a horizontal swipe that moved the grid, the next N captures
+        // still show it coasting (nodes drift 30px per remaining capture).
+        private val gridInertiaCaptures: Int = 0,
+        // #370: time-based coasting: captures within gridSettleMillis of the last
+        // grid movement (by gridSettleClock) show the nodes drifted by 30px.
+        private val gridSettleClock: (() -> Long)? = null,
+        private val gridSettleMillis: Long = 0L,
+        // #370: each capture() (a parse) costs this much simulated time.
+        private val captureCostMillis: Long = 0L,
+        private val captureAdvance: ((Long) -> Unit)? = null,
+        // #370: a click is NOT_FOUND when the node is not where the last capture
+        // placed it (position at click time differs from the parsed target).
+        private val gridStrictClickPosition: Boolean = false,
     ) : PddCollectorDriver {
         var captureCount = 0
         var clickCount = 0
@@ -2155,6 +2713,15 @@ class PddProductDetailCollectorTest {
         var backCount = 0
         var entryClickCount = 0
         var restoreGestures = 0
+        val gridSwipeLog = mutableListOf<Pair<SwipeDirection, Int>>()
+        private val gridOffsets = IntArray(horizontalGrid?.size ?: 0) { gridInitialOffset }
+        private var rightAttempts = 0
+        private var inertiaRemaining = 0
+        private var currentDrift = 0
+        // Parses between a spec swipe and the next click (discovery) cost captureCostMillis.
+        private var costlyParses = false
+        private var lastGridMoveAt = Long.MIN_VALUE / 2
+        private var lastSwipeFailure = "none"
         private var selected: String? = initialSelectedColor
         private var previousSelected: String? = null
         private var horizontalPage = 0
@@ -2167,7 +2734,15 @@ class PddProductDetailCollectorTest {
         private var adviceOpen = false
 
         override fun capture(): UiSnapshot {
+            if (captureCostMillis > 0 && costlyParses) captureAdvance?.invoke(captureCostMillis)
+            return captureFrame(advanceInertia = true)
+        }
+
+        private fun captureFrame(advanceInertia: Boolean): UiSnapshot {
             captureCount++
+            currentDrift = inertiaRemaining * 30 +
+                if (gridSettleClock != null && gridSettleClock.invoke() - lastGridMoveAt < gridSettleMillis) 30 else 0
+            if (advanceInertia && inertiaRemaining > 0) inertiaRemaining--
             fixedSnapshot?.let { return it }
             if (adviceOpen) return UiSnapshot(PDD_PACKAGE, ACTIVITY, listOf(
                 node("content", "", 0, 0, 1080, 2200, resourceId = "android:id/content", className = "android.widget.FrameLayout"),
@@ -2224,21 +2799,33 @@ class PddProductDetailCollectorTest {
             val continuationPage = hideDimensionHeadingsAfterFirstVerticalPage && verticalPage > 0
             val panelCollapsedNow = specPanelCollapsesAfterTopSwipe && downSwipeCount >= 1
             val hideColorNow = specPanelHidesColorInitially && downSwipeCount == 0
-            val visibleColors = colorVerticalPages?.get(verticalPage.coerceAtMost(colorVerticalPages.lastIndex))
+            val gridPlaced = horizontalGrid?.flatMapIndexed { r, row ->
+                if (gridPixelStep != null) {
+                    row.mapIndexed { c, color -> Triple(color, r, c) }.filter { (_, _, c) ->
+                        val left = 30 + c * 230 - gridOffsets[r]
+                        left < GRID_VIEWPORT_RIGHT && left + 190 > 0
+                    }
+                } else {
+                    row.drop(gridOffsets[r]).take(gridVisibleColumns).mapIndexed { c, color -> Triple(color, r, c) }
+                }
+            }
+            val visibleColors = gridPlaced?.map { it.first }
+                ?: colorVerticalPages?.get(verticalPage.coerceAtMost(colorVerticalPages.lastIndex))
                 ?: colorPages[horizontalPage.coerceAtMost(colorPages.lastIndex)]
-            val colorRowCount = (visibleColors.size + rowSize - 1) / rowSize
+            val colorRowCount = horizontalGrid?.size ?: ((visibleColors.size + rowSize - 1) / rowSize)
+            val placedColors = gridPlaced ?: visibleColors
+                .filterNot { hideSelectedColorOption && it == selected }
+                .mapIndexed { index, color -> Triple(color, index / rowSize, index % rowSize) }
             val sizeHeadingTop = maxOf(700, 470 + colorRowCount * 90 + 20)
             if (!continuationPage && !panelCollapsedNow && !(hideColorHeadingAfterFirstVerticalPage && verticalPage > 0)) {
                 nodes += node("scroll/color-heading", "颜色分类", 20, 400, 300, 450, parentPath = "scroll")
             }
             if (!continuationPage && !hideColorNow && !panelCollapsedNow) {
-                visibleColors
-                    .filterNot { hideSelectedColorOption && it == selected }
-                    .forEachIndexed { index, color ->
-                    val row = index / rowSize
-                    val column = index % rowSize
+                placedColors.forEach { (color, row, column) ->
                     val path = "scroll/color-$color-$captureCount"
-                    val left = 30 + column * 230
+                    val shift = if (gridPixelStep != null) gridOffsets[row] else 0
+                    val jitter = if (gridClickJitter && horizontalGrid != null) (clickCount % 4) * 2 else 0
+                    val left = 30 + column * 230 - shift + jitter + currentDrift
                     val top = 470 + row * 90
                     if (imageColorCards) {
                         nodes += SnapshotNode(
@@ -2254,7 +2841,7 @@ class PddProductDetailCollectorTest {
                         )
                     } else {
                         nodes += node(
-                            path, color, left, top, 220 + column * 230, top + 70,
+                            path, color, left, top, 220 + column * 230 - shift + jitter + currentDrift, top + 70,
                             clickable = true, selected = displayedSelected() == color, parentPath = "scroll",
                         )
                     }
@@ -2312,11 +2899,13 @@ class PddProductDetailCollectorTest {
 
         override fun clickFresh(target: SnapshotNode): FreshActionResult {
             clickCount++
+            costlyParses = false
             clickedLabels += target.label
             if (target.label in failedClicks) return FreshActionResult.FAILED
-            val current = capture().nodes.filter { it.label == target.label && (!imageColorCards || it.clickable) }
+            val current = captureFrame(advanceInertia = false).nodes.filter { it.label == target.label && (!imageColorCards || it.clickable) }
             if (current.isEmpty()) return FreshActionResult.NOT_FOUND
             if (current.size > 1) return FreshActionResult.AMBIGUOUS
+            if (gridStrictClickPosition && current.single().bounds != target.bounds) return FreshActionResult.NOT_FOUND
             if (!panelOpen && target.label == "单独购买") {
                 entryClickCount++
                 when {
@@ -2355,8 +2944,43 @@ class PddProductDetailCollectorTest {
         private fun displayedSelected(): String? =
             if (staleSelectionEvidence && previousSelected != null) previousSelected else selected
 
+        override fun specRowSwipeFailureReason(): String = lastSwipeFailure
+
         override fun swipeSpec(direction: SwipeDirection, anchor: SnapshotNode?): Boolean {
             swipes += direction to anchor
+            costlyParses = true
+            lastSwipeFailure = "none"
+            if (direction == SwipeDirection.RIGHT && horizontalGrid != null) {
+                rightAttempts++
+                if (rightAttempts in gridRightFailAttempts) {
+                    lastSwipeFailure = "anchorMissing"
+                    return false
+                }
+            }
+            if (horizontalGrid != null && (direction == SwipeDirection.LEFT || direction == SwipeDirection.RIGHT)) {
+                gridSwipeLog += direction to (gridOffsets.maxOrNull() ?: 0)
+                val unit = gridPixelStep ?: gridStep
+                val delta = if (direction == SwipeDirection.LEFT) unit else -unit
+                val moved = if (gridSharedContainer) horizontalGrid.indices.toList()
+                else listOf((((anchor?.bounds?.top ?: 470) - 470) / 90).coerceIn(0, horizontalGrid.lastIndex))
+                val sharedMax = if (gridPixelStep != null) {
+                    30 + (horizontalGrid.maxOf { it.size } - 1) * 230 + 190 - GRID_VIEWPORT_RIGHT
+                } else {
+                    horizontalGrid.maxOf { it.size } - gridVisibleColumns
+                }
+                val brokenSwipe = gridSwipeWhereOnlyFirstRowMoves > 0 &&
+                    gridSwipeLog.size == gridSwipeWhereOnlyFirstRowMoves
+                val offsetsBefore = gridOffsets.toList()
+                moved.filter { !brokenSwipe || it == 0 }.forEach { r ->
+                    val max = if (gridSharedContainer) sharedMax else horizontalGrid[r].size - gridVisibleColumns
+                    gridOffsets[r] = (gridOffsets[r] + delta).coerceIn(0, maxOf(0, max))
+                }
+                if (gridOffsets.toList() != offsetsBefore) {
+                    inertiaRemaining = gridInertiaCaptures
+                    gridSettleClock?.let { lastGridMoveAt = it.invoke() }
+                }
+                return true
+            }
             if ((direction == SwipeDirection.UP || direction == SwipeDirection.DOWN) && !verticalSwipeSucceeds) return false
             when (direction) {
                 SwipeDirection.LEFT -> horizontalPage = (horizontalPage + 1).coerceAtMost(colorPages.lastIndex)
@@ -2391,8 +3015,162 @@ class PddProductDetailCollectorTest {
         }
     }
 
+    // #379: purchase-1 card shape: clickable ViewGroup > (View, full-name ImageView,
+    // "打开大图" ImageView, non-clickable LinearLayout > clickable caption TextView).
+    private fun badgeCard(index: Int, left: Int, fullName: String, caption: String): List<SnapshotNode> {
+        fun described(path: String, parent: String?, text: String?, description: String?, bounds: NodeBounds, className: String, clickable: Boolean) =
+            SnapshotNode(
+                path, parent, text, description, null, className, bounds,
+                clickable, scrollable = false, selected = false, checked = false, enabled = true, visible = true,
+            )
+        val card = "scroll/card$index"
+        val right = left + 316
+        return listOf(
+            described(card, "scroll", null, fullName, NodeBounds(left, 470, right, 690), "android.view.ViewGroup", true),
+            described("$card/bg", card, null, null, NodeBounds(left, 470, right, 690), "android.view.View", false),
+            described("$card/image", card, null, fullName, NodeBounds(left, 470, right, 640), "android.widget.ImageView", true),
+            described("$card/big", card, null, "打开大图", NodeBounds(left, 470, left + 111, 581), "android.widget.ImageView", true),
+            described("$card/box", card, null, null, NodeBounds(left, 630, right, 690), "android.widget.LinearLayout", false),
+            described("$card/box/caption", "$card/box", caption, null, NodeBounds(left, 630, right, 690), "android.widget.TextView", true),
+        )
+    }
+
+    private fun badgeCardsSnapshot(cards: List<List<SnapshotNode>>): UiSnapshot = UiSnapshot(
+        PDD_PACKAGE,
+        ACTIVITY,
+        listOf(
+            node("content", "", 0, 0, 1080, 2200, resourceId = "android:id/content", className = "android.widget.FrameLayout"),
+            node("summary", "已选：", 20, 300, 700, 360),
+            node("title", "确认款式", 20, 370, 300, 410),
+            node("scroll", "", 0, 380, 1080, 1900, scrollable = true),
+            node("scroll/color-heading", "颜色分类", 20, 400, 300, 450, parentPath = "scroll"),
+        ) + cards.flatten() + listOf(
+            node("scroll/size-heading", "尺码", 20, 700, 300, 750, parentPath = "scroll"),
+            node("scroll/size-s", "S 75斤内穿", 30, 770, 220, 840, clickable = true, parentPath = "scroll"),
+            node("scroll/size-m", "M 80-90斤", 260, 770, 450, 840, clickable = true, parentPath = "scroll"),
+            node("confirm", "确定", 0, 2000, 1080, 2150, clickable = true),
+        ),
+    )
+
+    private fun purchase1Cards(captionOne: String = "黑色  微喇春秋加...\n ¥11.8 零差评") = listOf(
+        badgeCard(1, 36, "黑色  微喇春秋加薄绒长裤 （适合现在温度穿） ¥11.8", captionOne),
+        badgeCard(2, 382, "  黑色 微喇春夏款长裤 ¥9.8", "  黑色 微喇春夏...\n ¥9.8 最多人选择"),
+        badgeCard(3, 728, "黑色 微喇夏天薄款长裤 ¥9.8", "黑色 微喇夏天薄款长裤 ¥9.8"),
+    )
+
+    @Test
+    fun `price plus badge caption merges into the outer card and yields three colors`() {
+        val parsed = PddScreenParser.parse(badgeCardsSnapshot(purchase1Cards()), config(), GOODS_ID, evidence())
+
+        val colors = parsed.dimensions.first { it.key == "color" }.values
+        assertEquals(
+            listOf("黑色  微喇春秋加薄绒长裤 （适合现在温度穿）", "黑色 微喇春夏款长裤", "黑色 微喇夏天薄款长裤"),
+            colors.map { it.text },
+        )
+        assertEquals(colors.size, colors.map { it.text }.distinct().size)
+        assertTrue(colors.none { it.text.contains('¥') || it.text.contains('￥') })
+        assertEquals("黑色  微喇春秋加薄绒长裤 （适合现在温度穿） ¥11.8", colors[0].rawText)
+        assertTrue(colors.all { it.node.path.endsWith("/caption") || it.node.path.startsWith("scroll/card") })
+        // Size dimension is unaffected.
+        assertEquals(listOf("S 75斤内穿", "M 80-90斤"), parsed.dimensions.first { it.key == "size" }.values.map { it.text })
+    }
+
+    @Test
+    fun `price plus badge cards collect three colors without invalid marker`() {
+        val base = FakeCollectorDriver(colors = listOf("占位"), sizePages = listOf(listOf("S 75斤内穿", "M 80-90斤")))
+        val driver = object : PddCollectorDriver by base {
+            override fun capture(): UiSnapshot {
+                val snapshot = base.capture()
+                return snapshot.copy(
+                    nodes = snapshot.nodes.filterNot { it.path.startsWith("scroll/color-") && it.path != "scroll/color-heading" } +
+                        purchase1Cards().flatten(),
+                )
+            }
+        }
+        var clock = 0L
+
+        val result = PddProductDetailCollector(driver, { clock }, { clock += it }).collect(GOODS_ID, rule())
+
+        assertTrue(result.successful)
+        val payload = requireNotNull(result.payload)
+        assertEquals(
+            listOf("黑色  微喇春秋加薄绒长裤 （适合现在温度穿）", "黑色 微喇春夏款长裤", "黑色 微喇夏天薄款长裤"),
+            payload.dimensions.first { it.key == "color" }.values,
+        )
+        assertTrue(payload.missing.none { it.startsWith("spec_dimension_") })
+    }
+
+    @Test
+    fun `badge caption amount differing from the outer card price is not merged`() {
+        val parsed = PddScreenParser.parse(
+            badgeCardsSnapshot(purchase1Cards("黑色  微喇春秋加...\n ¥11.9 零差评")),
+            config(), GOODS_ID, evidence(),
+        )
+
+        val colors = parsed.dimensions.first { it.key == "color" }.values
+        assertEquals(4, colors.size)
+        assertTrue(colors.any { it.text.contains('¥') })
+    }
+
+    @Test
+    fun `badge caption with currency or an overlong badge is not merged`() {
+        for (caption in listOf("黑色  微喇春秋加...\n ¥11.8 零¥差评", "黑色  微喇春秋加...\n ¥11.8 零差评零差评零差评", "黑色  微喇春秋加...\n ¥11.8 零 差评")) {
+            val parsed = PddScreenParser.parse(badgeCardsSnapshot(purchase1Cards(caption)), config(), GOODS_ID, evidence())
+            val colors = parsed.dimensions.first { it.key == "color" }.values
+            assertEquals(caption, 4, colors.size)
+            assertTrue(caption, colors.any { it.text.contains('¥') })
+        }
+    }
+
+    @Test
+    fun `badge caption is not merged when the outer card has no price`() {
+        val cards = listOf(badgeCard(1, 36, "黑色  微喇春秋加薄绒长裤", "黑色  微喇春秋加...\n ¥11.8 零差评"))
+        val parsed = PddScreenParser.parse(badgeCardsSnapshot(cards), config(), GOODS_ID, evidence())
+
+        val colors = parsed.dimensions.first { it.key == "color" }.values
+        assertEquals(2, colors.size)
+        assertTrue(colors.any { it.text.contains('¥') })
+    }
+
+    @Test
+    fun `badge caption must still be a prefix of the outer name`() {
+        val parsed = PddScreenParser.parse(
+            badgeCardsSnapshot(purchase1Cards("红色  微喇春秋加...\n ¥11.8 零差评")),
+            config(), GOODS_ID, evidence(),
+        )
+
+        val colors = parsed.dimensions.first { it.key == "color" }.values
+        assertEquals(4, colors.size)
+    }
+
+    @Test
+    fun `badge caption does not merge when the card holds a second clickable text`() {
+        val card = badgeCard(1, 36, "黑色  微喇春秋加薄绒长裤 （适合现在温度穿） ¥11.8", "黑色  微喇春秋加...\n ¥11.8 零差评")
+        val extra = SnapshotNode(
+            "scroll/card1/box/other", "scroll/card1/box", "黑色", null, null, "android.widget.TextView",
+            NodeBounds(36, 630, 100, 660), clickable = true, scrollable = false, selected = false,
+            checked = false, enabled = true, visible = true,
+        )
+        val parsed = PddScreenParser.parse(badgeCardsSnapshot(listOf(card + extra)), config(), GOODS_ID, evidence())
+
+        val colors = parsed.dimensions.first { it.key == "color" }.values
+        assertTrue(colors.size > 1)
+    }
+
+    @Test
+    fun `truncated caption without badge still merges as before`() {
+        val cards = listOf(badgeCard(1, 36, "黑色  微喇春秋加薄绒长裤 （适合现在温度穿） ¥11.8", "黑色  微喇春秋加薄绒长裤 （适合 ¥11.8"))
+        val parsed = PddScreenParser.parse(badgeCardsSnapshot(cards), config(), GOODS_ID, evidence())
+
+        val colors = parsed.dimensions.first { it.key == "color" }.values
+        assertEquals(listOf("黑色  微喇春秋加薄绒长裤 （适合现在温度穿）"), colors.map { it.text })
+    }
+
     companion object {
         private const val GOODS_ID = "719834019024"
+        private const val GRID_VIEWPORT_RIGHT = 835
+        // Simulated elapsed time of the right-start 47 color scenario at 9619c38.
+        private const val BASELINE_RIGHT_START_ELAPSED_MS = 127_550L
         private const val PDD_PACKAGE = "com.xunmeng.pinduoduo"
         private const val ACTIVITY = "com.xunmeng.pinduoduo.activity.NewPageActivity"
 

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

@@ -3,171 +3,224 @@ package cn.ilapage.goauto.agent
 import cn.ilapage.goauto.agent.automation.*
 import org.junit.Assert.*
 import org.junit.Test
-import org.json.JSONObject
 
-/** #376 replaces #374's final value-proof contract. All fixtures are synthetic. */
+/** Final capture only; derived from the existing #331/#332 bounded purchase-sheet fixtures. */
 class PurchaseFinalSpecConfirmationTest {
-    @Test fun `local final evidence distinguishes target observed quantity and scoped summary flags`() {
-        val json = JSONObject(check(sheet("已选 黑色 XL"), input().copy(quantity = 2)).toLocalJson())
-        assertFalse(json.has("quantity"))
-        assertEquals(2, json.getLong("targetQuantity"))
-        assertEquals(1, json.getLong("observedQuantity"))
-        assertTrue(json.getBoolean("selectedSummaryPresent"))
-        assertFalse(json.getBoolean("summaryPromptPresent"))
-        val prompt = check(sheet("请 选择：颜色"), input())
-        assertFalse(prompt.selectedSummaryPresent)
-        assertTrue(prompt.summaryPromptPresent)
-        val external = sheet(null).addText("r/outside", "已选 黑色 XL", NodeBounds(20, 400, 800, 460))
-        assertFalse(check(external, input()).selectedSummaryPresent)
-        assertFalse(check(sheet("#黑色 XL#"), input()).selectedSummaryPresent)
+    @Test fun `bracket display variants and offscreen color are proven by full panel summary`() {
+        val snapshot = sheet("已选 [香槟]RW圆领 L码[105-115斤]", colors = listOf("其他颜色"), sizes = listOf("L码[105-115斤]"))
+            .selected("size/o0/t")
+        accepts(snapshot, "【香槟】RW圆领", "L码【105-115斤】")
     }
 
-    @Test fun `observed quantity is nullable for missing or multiple numeric editors`() {
-        val single = sheet(null)
-        assertEquals(1L, observedPurchaseQuantity(single))
-        assertNull(observedPurchaseQuantity(single.mapNodes { if (it.className == "android.widget.EditText") it.copy(visible = false) else it }))
-        val quantity = single.nodes.single { it.className == "android.widget.EditText" }
-        assertNull(observedPurchaseQuantity(single.copy(nodes = single.nodes + quantity.copy(path = "r/second"))))
-        val evidence = check(single, input()).copy(observedQuantity = null)
-        val json = JSONObject(evidence.toLocalJson())
-        assertTrue(json.has("observedQuantity"))
-        assertTrue(json.isNull("observedQuantity"))
+    @Test fun `summary above scroll area is accepted for scrollable and non scrollable sheets`() {
+        for (scrollable in listOf(true, false)) {
+            accepts(sheet("已选 黑色 XL", scrollable = scrollable))
+        }
     }
 
-    @Test fun `summary prompt is scoped to visible nonclickable header rather than option or external text`() {
-        val normal = sheet(null)
-        val driver = object : PurchaseUiDriver {
-            override fun capture() = normal
-            override fun swipePurchaseIn(target: SnapshotNode, direction: SwipeDirection, durationMs: Long): Boolean = error("unexpected swipe")
-            override fun clickFresh(target: SnapshotNode): FreshActionResult = error("unexpected click")
-            override fun tapPurchaseFresh(target: SnapshotNode): FreshActionResult = error("unexpected tap")
-            override fun inputFresh(target: SnapshotNode, value: String): FreshActionResult = error("unexpected input")
-            override fun swipePurchase(direction: SwipeDirection, durationMs: Long): Boolean = error("unexpected swipe")
-            override fun backPurchase(): Boolean = error("unexpected back")
-        }
-        val live = PurchaseLiveAutomation(driver, pause = {})
-        for (prompt in listOf("请选择颜色", "请 选择：颜色", "請選擇: 顏色")) {
-            assertTrue(live.selectionPromptPresent(sheet(prompt)))
-        }
-        val summaryBounds = NodeBounds(384, 791, 1068, 852)
-        for ((index, snapshot) in listOf(
-            normal.addText("r/external", "请选择颜色", summaryBounds),
-            normal.addText("r/sheet/fake", "请选择颜色", summaryBounds).mapNodes { if (it.path.endsWith("fake")) it.copy(parentPath = "r") else it },
-            sheet("请选择颜色").mapNodes { if (it.path.endsWith("body/summary")) it.copy(visible = false) else it },
-            sheet("请选择颜色").mapNodes { if (it.path.endsWith("body/summary")) it.copy(clickable = true) else it },
-            normal.addText("r/sheet/body/list/color/o0/prompt", "请选择颜色", NodeBounds(40, 1600, 300, 1640)),
-            normal.mapNodes { if (it.path.startsWith("r/sheet/body/qty")) it.copy(bounds = it.bounds.copy(top = 1990, bottom = 2020)) else it }
-                .addText("r/sheet/body/list/color/o0/prompt", "请选择颜色", NodeBounds(40, 1600, 300, 1640)),
-            sheet("请选择颜色").mapNodes { if (it.path in listOf("r/sheet", "r/sheet/body")) it.copy(bounds = NodeBounds(0, 0, 1080, 2216)) else it },
-        ).withIndex()) {
-            assertFalse("variant=$index", live.selectionPromptPresent(snapshot))
-            assertFalse(PurchaseSelectionEvidence.observe(snapshot).summaryPromptPresent)
-        }
-        // A missing final button never adds a pre-address failure by itself.
-        assertFalse(live.selectionPromptPresent(normal.mapNodes { if (it.path.startsWith("r/sheet/submit")) it.copy(visible = false) else it }))
-    }
-    @Test fun `normal button permits missing heading marketing summary and offscreen size`() {
-        accepts(sheet("#示例活动#" ).mapNodes { if (it.path.endsWith("color/h")) it.copy(visible = false) else it })
-        accepts(sheet("#示例活动#").mapNodes { if (it.path.contains("list/size")) it.copy(visible = false) else it })
+    @Test fun `checked only exact option and physical parent child duplicates provide selection proof`() {
+        accepts(sheet(null).selected("color/o0/img", checked = true).selected("size/o0/t", checked = true))
     }
 
-    @Test fun `normal button permits wrong selected values unavailable targets and collisions`() {
-        accepts(sheet(null).mapNodes {
-            when {
-                it.path.endsWith("color/o0") -> it.copy(selected = true, contentDescription = "白色")
-                it.path.endsWith("size/o0/t") -> it.copy(selected = true, text = "L")
+    @Test fun `selected other color or size overrides matching summary and positive target`() {
+        rejects(sheet("已选 黑色 XL", colors = listOf("黑色", "白色")).selected("color/o0").selected("color/o1"))
+        rejects(sheet("已选 黑色 XL", sizes = listOf("XL", "L")).selected("size/o1/t"))
+    }
+
+    @Test fun `selected bracket variants are not a conflict`() {
+        accepts(sheet("已选 [白色] XL", colors = listOf("[白色]")).selected("color/o0").selected("size/o0/t"), "【白色】")
+    }
+
+    @Test fun `distinct physical identical or normalized target options are collisions`() {
+        for (colors in listOf(listOf("黑色", "黑色"), listOf("【白色】", "[白色]"))) {
+            rejects(sheet("已选 ${colors[0]} XL", colors = colors).selected("color/o0"), colors[0])
+        }
+    }
+
+    @Test fun `explicit unavailable target cannot be rescued by summary`() {
+        rejects(sheet("已选 黑色 XL").mapNodes { if (it.path.contains("color/o0")) it.copy(enabled = false) else it })
+    }
+
+    @Test fun `all required selected proofs take priority over a single non proving summary`() {
+        accepts(sheet("已选 其他颜色 其他尺码").selected("color/o0/img").selected("size/o0/t"))
+        rejects(sheet("已选 白色 L", colors = listOf("黑色", "白色"), sizes = listOf("XL", "L"))
+            .selected("color/o0/img").selected("size/o0/t")) // Known alternative composition is a conflict.
+    }
+
+    @Test fun `selected options retain established parser separation of trailing display price`() {
+        accepts(sheet("已选 黑色 XL", colors = listOf("黑色 ¥19.60"), sizes = listOf("XL ￥19.60"))
+            .selected("color/o0/img").selected("size/o0/t"))
+        rejects(sheet("已选 黑色 XL", colors = listOf("黑色加绒 ¥19.60")).selected("color/o0/img"))
+        rejects(sheet("已选 黑色 XL", colors = listOf("黑色 ¥19.60", "黑色 ¥20.00")).selected("color/o0/img"))
+    }
+
+    @Test fun `unselected visible options alone and unrelated title cannot prove selection`() {
+        rejects(sheet(null).addText("r/title", "示例黑色 XL 商品"))
+    }
+
+    @Test fun `panel external prefixed summary is ignored even at same coordinates`() {
+        rejects(sheet(null).addText("r/fake", "已选 黑色 XL"))
+        accepts(sheet("已选 黑色 XL").addText("r/fake", "已选 白色 L"))
+    }
+
+    @Test fun `structural ancestry overrides textual path prefix`() {
+        rejects(sheet(null).addText("r/sheet/fake", "已选 黑色 XL", parent = "r"))
+    }
+
+    @Test fun `whole summary rejects substring sizes colors extra dimensions quantity and unsupported separators`() {
+        for (summary in listOf("已选 黑色 XL", "已选 黑色 加绒 L", "已选 黑色 L 2件", "已选 黑色,L", "已选 L 黑色")) {
+            rejects(sheet(summary, sizes = listOf("L")), size = "L")
+        }
+        rejects(sheet("已选 [白色+黑色]超值两件装 XL", colors = emptyList()), "【白色】")
+    }
+
+    @Test fun `known candidates making another full composition reject ambiguous summary`() {
+        rejects(sheet("已选 黑色 加绒 XL", colors = listOf("黑色", "黑色 加绒"), sizes = listOf("加绒 XL", "XL")), size = "加绒 XL")
+        rejects(sheet("已选 黑色 加绒 XL", colors = listOf("黑色", "黑色 加绒"), sizes = listOf("加绒 XL", "XL")), color = "黑色 加绒")
+    }
+
+    @Test fun `summary permits invisible color despite another unselected visible color`() {
+        accepts(sheet("已选 黑色 XL", colors = listOf("白色")))
+    }
+
+    @Test fun `required single dimension must equal whole summary and empty pair is never proof`() {
+        accepts(sheet("已选 黑色"), size = "")
+        accepts(sheet("已选 XL"), color = "")
+        rejects(sheet("已选 黑色 XL"), size = "")
+        rejects(sheet("已选 黑色 XL"), color = "")
+        rejects(sheet("已选 黑色 XL"), color = " ", size = "")
+    }
+
+    @Test fun `anchored selected prefix variants preserve internal colons commas and whitespace`() {
+        for (prefix in listOf("已选", "已选 ", "已选:", "已选： ", "  已选： ")) {
+            accepts(sheet("$prefix 黑色:加绒,款 XL", colors = emptyList()), color = "黑色:加绒,款")
+        }
+        accepts(sheet("已选 黑色  加绒 XL", colors = emptyList()), color = "黑色 加绒")
+        rejects(sheet("已选 黑色 加绒 XL", colors = emptyList()), color = "黑色加绒")
+        rejects(sheet("已选 黑色:加绒 XL", colors = emptyList()), color = "黑色加绒")
+        rejects(sheet("已选:：黑色 XL"))
+        accepts(sheet("已选:：黑色 XL", colors = emptyList()), color = "：黑色")
+    }
+
+    @Test fun `conflicting scoped summaries reject even both exact options selected`() {
+        rejects(sheet("已选 黑色 XL").selected("color/o0").selected("size/o0/t").addText("r/sheet/second", "已选 白色 L"))
+        accepts(sheet("已选 黑色 XL").addText("r/sheet/second", "已选：黑色 XL"))
+    }
+
+    @Test fun `display normalization is narrow and content preserving`() {
+        accepts(sheet("已选 [白色](加绒) RW12 XL", colors = emptyList()), color = "〔白色〕（加绒）　ＲＷ１２")
+        rejects(sheet("已选 白色 RW12 XL", colors = emptyList()), color = "白色 rw12")
+        rejects(sheet("已选 白色 1 XL", colors = emptyList()), color = "白色 ①")
+        rejects(sheet("已选 白色 XL", colors = emptyList()), color = "白色 ¥19.6")
+    }
+
+    @Test fun `existing structurally recognized unprefixed summary is usable`() {
+        accepts(prefixlessSheet())
+        rejects(sheet("黑色 XL")) // No quantity/header relationship in this fixture.
+        rejects(sheet(null).addText("r/title", "黑色 XL"))
+        rejects(prefixlessSheet().addText("r/sheet/body/info/second", "黑色 L"))
+    }
+
+    @Test fun `same dimension groups retain earlier selected conflicts and physical candidates`() {
+        val base = sheet("已选 黑色 XL").addText("r/sheet/body/list/extra/h", "颜色分类")
+            .addText("r/sheet/body/list/extra/o", "白色")
+            .mapNodes { when (it.path) {
+                "r/sheet/body/list/extra/h" -> it.copy(bounds = NodeBounds(20, 1000, 500, 1040), parentPath = "r/sheet/body/list")
+                "r/sheet/body/list/extra/o" -> it.copy(bounds = NodeBounds(20, 1045, 500, 1100), parentPath = "r/sheet/body/list", clickable = true, selected = true)
+                "r/sheet/body/list" -> it.copy(bounds = NodeBounds(0, 980, 1080, 2036))
                 else -> it
-            }
-        })
-        accepts(sheet("已选 白色 L").mapNodes { if (it.path.contains("color/o0")) it.copy(enabled = false) else it })
-        accepts(sheet(null).let { it.copy(nodes = it.nodes + it.nodes.filter { n -> n.path.contains("color/o0") }.map { n ->
-            n.copy(path = n.path.replace("o0", "o1"), parentPath = n.parentPath?.replace("o0", "o1"), bounds = n.bounds.copy(left = 400, right = 700))
-        }) })
+            } }
+        rejects(base)
+        rejects(base.mapNodes { if (it.path.endsWith("extra/o")) it.copy(text = "黑色") else it })
     }
 
-    @Test fun `normal button permits mismatched quantity and summary prompt`() {
-        accepts(sheet("请选择：颜色分类 尺码"), input().copy(quantity = 2))
-        accepts(sheet("請選擇: 顏色 尺碼"))
-    }
-
-    @Test fun `special button rejects simplified traditional whitespace and split prompt`() {
-        for (prompt in listOf("选择颜色分类及尺码后，提交订单", "選擇顏色及尺碼後,提交訂單", " 选 择 颜色 后 ， 提交 订单 ")) {
-            rejects(sheet("已选 黑色 XL").button(prompt), "PURCHASE_SPEC_NOT_MATCHED")
-        }
-        rejects(splitButton(), "PURCHASE_SPEC_NOT_MATCHED")
-        rejects(splitButton().mapNodes { if (it.path == "r/sheet/submit/l") it.copy(text = "选择颜色后，提交订单") else it }, "PURCHASE_SPEC_NOT_MATCHED")
-    }
-
-    @Test fun `whole match ignores prefix suffix hidden external and independent child fragments`() {
-        for (label in listOf("提示选择颜色后，提交订单", "选择颜色后，提交订单优惠", "选择颜色提交订单", "提交订单")) accepts(sheet(null).button(label))
-        accepts(sheet(null).addText("r/outside", "选择颜色后，提交订单", NodeBounds(20, 10, 800, 70)))
-        accepts(sheet(null).addText("r/sheet/submit/hidden", "选择颜色后，提交订单", NodeBounds(20, 2140, 800, 2170)).mapNodes {
-            if (it.path.endsWith("hidden")) it.copy(visible = false) else it
-        })
-        accepts(sheet(null).mapNodes { when (it.path) {
-            "r/sheet/submit" -> it.copy(text = "选择颜色后，提交订单")
-            "r/sheet/submit/l/t" -> it.copy(text = "选择颜色后，提交订单", visible = false)
-            else -> it
-        } }) // Do not use a parent's aggregate label when its labelled child is hidden.
-        accepts(splitButton().mapNodes { if (it.path.endsWith("/first")) it.copy(clickable = true) else it })
-        accepts(splitButton().mapNodes { if (it.path.endsWith("/first")) it.copy(path = "r/outside", parentPath = "r") else it })
-    }
-
-    @Test fun `address price and missing button still reject without actions`() {
-        rejects(sheet(null), "PURCHASE_PRICE_OUT_OF_RANGE", input().copy(maxUnitPriceCent = 1))
-        rejects(sheet(null).mapNodes { if (it.path.endsWith("addr/a/detail")) it.copy(text = "示例地址") else it }, "PURCHASE_ADDRESS_UPDATE_FAILED")
-        rejects(sheet(null).mapNodes { if (it.path.startsWith("r/sheet/submit")) it.copy(visible = false) else it }, "PURCHASE_SUBMIT_TARGET_AMBIGUOUS")
-    }
-
-    @Test fun `collector opt in retains independent candidates without changing regular parsing`() {
-        val snapshot = SpecPanelFixtures.sheet(SpecPanelFixtures.Sheet(colorLabels = listOf("黑色", "黑色")))
+    @Test fun `collector default still collapses same raw labels and leaves summary behavior unchanged`() {
+        val snapshot = sheet("已选 黑色 XL", colors = listOf("黑色", "黑色"))
         val config = PurchaseRehearsalExecutor.DEFAULT_COLLECTOR
-        val regular = PddScreenParser.parse(snapshot, config, "376", null)
-        val final = PddScreenParser.parse(snapshot, config, "376", null, forFinalConfirmation = true)
+        val regular = PddScreenParser.parse(snapshot, config, "374", null)
+        val final = PddScreenParser.parse(snapshot, config, "374", null, forFinalConfirmation = true)
         assertEquals(1, regular.dimensions.single { it.key == "color" }.values.size)
         assertEquals(2, final.dimensions.single { it.key == "color" }.values.size)
         assertEquals(regular.selectedSummary, final.selectedSummary)
+        assertTrue(regular.finalSelectionSummaries.isEmpty())
     }
 
-    private fun splitButton(): UiSnapshot = sheet(null).button("提交订单").mapNodes {
-        if (it.path.endsWith("submit/l/t")) it.copy(bounds = NodeBounds(600, 2180, 1000, 2216)) else it
-    }.addText("r/sheet/submit/l/first", "选择颜色后，", NodeBounds(20, 2180, 590, 2216))
+    @Test fun `independently bounded selected options survive absent full panel boundary`() {
+        val snapshot = sheet(null).selected("color/o0/img").selected("size/o0/t")
+            .mapNodes { if (it.path == "r/sheet") it.copy(bounds = NodeBounds(0, 0, 1080, 2216)) else it }
+        PurchaseFinalSpecVerifier.verify(snapshot, input()) { fail(it) }
+        val noSelections = snapshot.mapNodes { it.copy(selected = false, checked = false) }
+            .addText("r/sheet/fake", "已选 黑色 XL")
+        try {
+            PurchaseFinalSpecVerifier.verify(noSelections, input()) {}
+            fail("unproven full panel must not supply summary")
+        } catch (failure: PurchaseLiveException) { assertEquals("PURCHASE_SPEC_NOT_MATCHED", failure.code) }
+    }
 
-    private fun sheet(summary: String?): UiSnapshot = SpecPanelFixtures.sheet(SpecPanelFixtures.Sheet(colorLabels = listOf("黑色"), sizeLabels = listOf("XL")))
+    @Test fun `price quantity and address checks remain enforced`() {
+        rejects(sheet("已选 黑色 XL"), expectedCode = "PURCHASE_PRICE_OUT_OF_RANGE", input = input().copy(maxUnitPriceCent = 1))
+        rejects(sheet("已选 黑色 XL"), expectedCode = "PURCHASE_QUANTITY_MISMATCH", input = input().copy(quantity = 2))
+        rejects(sheet("已选 黑色 XL").mapNodes { if (it.path == "r/sheet/body/addr/a/detail") it.copy(text = "示例地址") else it }, expectedCode = "PURCHASE_ADDRESS_UPDATE_FAILED")
+    }
+
+    private fun sheet(
+        summary: String?, colors: List<String> = listOf("黑色"), sizes: List<String> = listOf("XL"), scrollable: Boolean = true,
+    ): UiSnapshot = SpecPanelFixtures.sheet(SpecPanelFixtures.Sheet(colorLabels = colors, sizeLabels = sizes, listScrollable = scrollable))
         .mapNodes { when (it.path) {
             "r/sheet/body/summary" -> it.copy(text = summary, visible = summary != null)
             "r/sheet/body/addr/a/detail" -> it.copy(text = ADDRESS)
-            "r/sheet/submit/l/t" -> it.copy(text = "提交订单")
             else -> it
         } }
+
+    /** Reuses the info-above-list shape from PddProductDetailCollectorTest.prefixlessPanel. */
+    private fun prefixlessSheet(): UiSnapshot {
+        val base = sheet("黑色 XL")
+        val info = base.nodes.single { it.path == "r/sheet/body/qty" }.copy(
+            path = "r/sheet/body/info", bounds = NodeBounds(0, 770, 1080, 1000), parentPath = "r/sheet/body",
+        )
+        return base.mapNodes { when {
+            it.path == "r/sheet/body/summary" -> it.copy(path = "r/sheet/body/info/summary", parentPath = info.path)
+            it.path == "r/sheet/body/qty" -> it.copy(path = "r/sheet/body/info/qty", parentPath = info.path)
+            it.path.startsWith("r/sheet/body/qty/") -> it.copy(path = it.path.replace("body/qty/", "body/info/qty/"), parentPath = "r/sheet/body/info/qty")
+            else -> it
+        } }.let { it.copy(nodes = it.nodes + info) }
+    }
+
     private fun UiSnapshot.mapNodes(transform: (SnapshotNode) -> SnapshotNode) = copy(nodes = nodes.map(transform))
-    private fun UiSnapshot.button(label: String) = mapNodes { if (it.path.endsWith("submit/l/t")) it.copy(text = label) else it }
-    private fun UiSnapshot.addText(path: String, text: String, bounds: NodeBounds) = copy(nodes = nodes + SnapshotNode(
-        path, path.substringBeforeLast('/'), text, null, null, "android.widget.TextView", bounds,
+    private fun UiSnapshot.selected(suffix: String, checked: Boolean = false) = mapNodes {
+        if (it.path.endsWith(suffix)) it.copy(selected = !checked, checked = checked) else it
+    }
+    private fun UiSnapshot.addText(path: String, text: String, parent: String = path.substringBeforeLast('/')) = copy(nodes = nodes + SnapshotNode(
+        path, parent, text, null, null, "android.widget.TextView", NodeBounds(384, 791, 1068, 852),
         false, false, false, false, true, true,
     ))
-    private fun input() = PurchaseExecutionInput(
-        taskId = 376, executionMode = "live", phase = "purchase", url = "https://mobile.yangkeduo.com/goods.html?goods_id=376",
-        goodsId = "376", mappedColor = "黑色", mappedSize = "XL", quantity = 1,
-        minUnitPriceCent = 1, maxUnitPriceCent = 3000, addressSuffix = "_cg376",
+    private fun input(color: String = "黑色", size: String = "XL") = PurchaseExecutionInput(
+        taskId = 374, executionMode = "live", phase = "purchase", url = "https://mobile.yangkeduo.com/goods.html?goods_id=374",
+        goodsId = "374", mappedColor = color, mappedSize = size, quantity = 1,
+        minUnitPriceCent = 1, maxUnitPriceCent = 3000, addressSuffix = "_cg374",
     )
+
     private fun check(snapshot: UiSnapshot, input: PurchaseExecutionInput, diagnostics: MutableList<String> = mutableListOf()): FinalConfirmationEvidence {
         val driver = object : PurchaseUiDriver {
             override fun capture() = snapshot
-            override fun backPurchase(): Boolean = error("unexpected back")
+            override fun clickFresh(target: SnapshotNode): FreshActionResult = error("final confirmation must be read only")
             override fun tapPurchaseFresh(target: SnapshotNode): FreshActionResult = error("unexpected tap")
-            override fun clickFresh(target: SnapshotNode): FreshActionResult = error("unexpected click")
             override fun inputFresh(target: SnapshotNode, value: String): FreshActionResult = error("unexpected input")
             override fun swipePurchase(direction: SwipeDirection, durationMs: Long): Boolean = error("unexpected swipe")
             override fun swipePurchaseIn(target: SnapshotNode, direction: SwipeDirection, durationMs: Long): Boolean = error("unexpected scoped swipe")
+            override fun backPurchase(): Boolean = error("unexpected back")
         }
         return PurchaseLiveAutomation(driver, pause = { error("unexpected pause") }, panelDiagnostic = diagnostics::add)
-            .finalConfirmation(input, ShippingAddressProof(ADDRESS, "_cg376"))
+            .finalConfirmation(input, ShippingAddressProof(ADDRESS, "_cg374"))
     }
-    private fun accepts(snapshot: UiSnapshot, input: PurchaseExecutionInput = input()) {
-        assertEquals(input.mappedColor, check(snapshot, input).mappedColor)
+    private fun accepts(snapshot: UiSnapshot, color: String = "黑色", size: String = "XL") {
+        val diagnostics = mutableListOf<String>()
+        val result = try { check(snapshot, input(color, size), diagnostics) } catch (failure: PurchaseLiveException) {
+            throw AssertionError("${failure.code}: ${diagnostics.lastOrNull()}", failure)
+        }
+        assertEquals(color, result.mappedColor)
     }
-    private fun rejects(snapshot: UiSnapshot, expectedCode: String, input: PurchaseExecutionInput = input()) {
+    private fun rejects(snapshot: UiSnapshot, color: String = "黑色", size: String = "XL", expectedCode: String = "PURCHASE_SPEC_NOT_MATCHED", input: PurchaseExecutionInput = input(color, size)) {
         val diagnostics = mutableListOf<String>()
         try {
             check(snapshot, input, diagnostics)
@@ -175,11 +228,14 @@ class PurchaseFinalSpecConfirmationTest {
         } catch (failure: PurchaseLiveException) {
             assertEquals(expectedCode, failure.code)
             if (expectedCode == "PURCHASE_SPEC_NOT_MATCHED") {
-                assertEquals("finalSpec;stage=selection_prompt", diagnostics.last())
-                assertTrue(failure.message.orEmpty().contains(diagnostics.last()))
+                val detail = diagnostics.last()
+                assertTrue(detail, detail.matches(Regex("finalSpec;dimension=(color|size|none);stage=[a-z_]+;summaryPresent=[01];selectedFound=[01];conflict=[01]")))
+                assertTrue(failure.message.orEmpty(), failure.message.orEmpty().contains(detail))
                 assertFalse(failure.message.orEmpty().contains(ADDRESS))
+                assertFalse(failure.message.orEmpty().contains("黑色"))
+                assertFalse(failure.message.orEmpty().contains("XL"))
             }
         }
     }
-    private companion object { const val ADDRESS = "示例区示例路376号_cg376" }
+    private companion object { const val ADDRESS = "示例区示例路374号_cg374" }
 }

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

@@ -8,9 +8,6 @@ import cn.ilapage.goauto.agent.automation.PurchaseExecutionInput
 import cn.ilapage.goauto.agent.automation.PurchaseLiveAutomation
 import cn.ilapage.goauto.agent.automation.PurchaseLiveException
 import cn.ilapage.goauto.agent.automation.PurchaseRuleParser
-import cn.ilapage.goauto.agent.automation.PurchaseRehearsalExecutor
-import cn.ilapage.goauto.agent.automation.PurchaseAgentCapabilities
-import cn.ilapage.goauto.agent.automation.PurchaseExecutionOutcome
 import cn.ilapage.goauto.agent.automation.PurchaseUiDriver
 import cn.ilapage.goauto.agent.automation.SnapshotNode
 import cn.ilapage.goauto.agent.automation.SwipeDirection
@@ -21,105 +18,6 @@ import org.junit.Assert.assertTrue
 import org.junit.Test
 
 class PurchaseLiveAutomationTest {
-    @Test
-    fun `pre address summary or button selection prompt stops executor before any address action`() {
-        for (variant in listOf("summary", "button", "second-dimension", "after-swipe")) {
-            val result = runPromptBoundary(prePrompt = variant)
-            assertEquals(variant, "failed", result.outcome.resultType)
-            assertEquals(variant, "PURCHASE_SPEC_SELECTION_UNCONFIRMED", result.outcome.errorCode)
-            assertTrue(result.outcome.message, result.outcome.message.contains("reason=selection_prompt"))
-            assertEquals(variant, 0, result.boundaries)
-            assertEquals(variant, 0, result.driver.addressPathClicks)
-            assertEquals(variant, 0, result.driver.inputCount)
-            assertEquals(variant, 0, result.driver.submitClicks)
-            assertEquals(variant, if (variant == "after-swipe") 1 else 0, result.preSwipes)
-        }
-    }
-
-    @Test
-    fun `final selection prompt is ordinary failure before boundary and unknown after boundary with zero clicks`() {
-        val before = runPromptBoundary(finalPrompt = true)
-        assertEquals("failed", before.outcome.resultType)
-        assertEquals("PURCHASE_SPEC_NOT_MATCHED", before.outcome.errorCode)
-        assertTrue(before.outcome.message.contains("finalSpec;stage=selection_prompt"))
-        assertEquals(0, before.boundaries)
-        assertEquals(0, before.driver.submitClicks)
-        assertEquals(1, before.driver.inputCount)
-        val after = runPromptBoundary(boundaryPrompt = true)
-        assertEquals("order_result_unknown", after.outcome.resultType)
-        assertEquals("PURCHASE_ORDER_RESULT_UNKNOWN", after.outcome.errorCode)
-        assertEquals(1, after.boundaries)
-        assertEquals(0, after.driver.submitClicks)
-        assertEquals(0, after.driver.scopedSwipes + after.driver.genericSwipes)
-    }
-
-    @Test
-    fun `post address wrong spec and quantity normal button complete executor once`() {
-        val result = runPromptBoundary(wrongFinalValues = true)
-        assertEquals("order_created", result.outcome.resultType)
-        assertEquals(1, result.boundaries)
-        assertEquals(1, result.driver.submitClicks)
-    }
-
-    private data class PromptBoundaryResult(val outcome: PurchaseExecutionOutcome, val driver: LiveDriver, val boundaries: Int, val preSwipes: Int)
-
-    private fun runPromptBoundary(
-        prePrompt: String? = null, finalPrompt: Boolean = false, boundaryPrompt: Boolean = false, wrongFinalValues: Boolean = false,
-    ): PromptBoundaryResult {
-        val addressDriver = LiveDriver()
-        var step = ""
-        var boundaries = 0
-        var verifyCaptures = 0
-        var preSwipes = 0
-        val selectedSheet = SpecPanelFixtures.sheet(SpecPanelFixtures.Sheet(colorLabels = listOf("黑色"), sizeLabels = listOf("XL"))).let { sheet ->
-            sheet.copy(nodes = sheet.nodes.map { when {
-                it.path.endsWith("body/summary") -> it.copy(text = "已选 黑色 XL")
-                it.path.endsWith("qty/input") -> it.copy(text = "2")
-                it.path.endsWith("submit/l/t") -> it.copy(text = "提交订单")
-                it.path.endsWith("color/o0") || it.path.endsWith("size/o0/t") -> it.copy(selected = true)
-                else -> it
-            } })
-        }
-        val driver = object : PurchaseUiDriver by addressDriver {
-            override fun capture(): UiSnapshot {
-                if (step in listOf("updateShippingAddress", "createOrder", "readOrderResult")) {
-                    val snapshot = addressDriver.capture()
-                    if (step != "createOrder") return snapshot
-                    return snapshot.copy(nodes = snapshot.nodes.map { node -> when {
-                        node.path == "panel/submit" && (finalPrompt || (boundaryPrompt && boundaries > 0)) ->
-                            node.copy(text = "选择颜色分类及尺码后，提交订单")
-                        wrongFinalValues && node.path == "panel/selected" -> node.copy(text = "已选 白色 L")
-                        wrongFinalValues && node.path == "panel/quantity" -> node.copy(text = "9")
-                        else -> node
-                    } })
-                }
-                if (step != "verifyOrderSummary") return selectedSheet
-                verifyCaptures++
-                return selectedSheet.copy(nodes = selectedSheet.nodes.map { node -> when {
-                    prePrompt == "after-swipe" && node.path.contains("list/color") -> node.copy(visible = false)
-                    prePrompt == "after-swipe" && preSwipes == 0 && node.path.endsWith("body/summary") -> node.copy(text = "已选 白色 XL")
-                    (prePrompt == "summary" || (prePrompt == "after-swipe" && preSwipes > 0)) && node.path.endsWith("body/summary") -> node.copy(text = "请选择：颜色分类")
-                    (prePrompt == "button" || (prePrompt == "second-dimension" && verifyCaptures > 1)) && node.path.endsWith("submit/l/t") ->
-                        node.copy(text = "选择颜色分类及尺码后，提交订单")
-                    else -> node
-                } })
-            }
-            override fun swipePurchaseIn(target: SnapshotNode, direction: SwipeDirection, durationMs: Long): Boolean {
-                if (step == "verifyOrderSummary") { preSwipes++; return true }
-                return addressDriver.swipePurchaseIn(target, direction, durationMs)
-            }
-        }
-        val rule = PurchaseRuleParser.parse("""{
-            "schemaVersion":1,"ruleType":"pddPurchase",
-            "requiredCapabilities":["purchase.live.v1","purchase.address-update.v1","purchase.order-create.v1"],
-            "actions":[{"type":"openProduct"},{"type":"verifyProduct"},{"type":"openSpecPanel"},{"type":"selectSpec"},{"type":"setQuantity"},{"type":"verifyUnitPrice"},{"type":"verifyOrderSummary"},{"type":"updateShippingAddress"},{"type":"createOrder"},{"type":"readOrderResult"}]
-        }""")
-        val outcome = PurchaseRehearsalExecutor(driver, { error("unexpected open") }, { null }, pause = {},
-            stepChanged = { step = it }, beforeOrderSubmit = { boundaries++ },
-        ).execute(input().copy(reuseProbeProduct = true), rule, PurchaseAgentCapabilities.supported)
-        return PromptBoundaryResult(outcome, addressDriver, boundaries, preSwipes)
-    }
-
     @Test
     fun `hint delayed address update preserves fresh payment back budget for late order evidence`() {
         val observationDriver = OrderObservationDriver { sample ->

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

@@ -8,6 +8,22 @@ import org.junit.Test
 class PurchaseOutboxHandoffTest {
     private val item = PendingPurchaseOutbox(1, 42, "probe", "request", "{}")
 
+    @Test fun `terminal conflict does not block later pending result`() {
+        val submitted = mutableListOf<Long>()
+        val uploaded = mutableListOf<Long>()
+        val result = runCatching {
+            PurchaseOutboxUploader(
+                { listOf(item, item.copy(id = 2, taskId = 43)) },
+                { submitted += it.id; if (it.id == 1L) throw cn.ilapage.goauto.agent.network.AgentApiException(409, "PURCHASE_STATE_CONFLICT", "untrusted", false) },
+                { uploaded += it.id },
+                markRejected = { _, _ -> },
+            ).flush()
+        }
+        assertTrue(result.isSuccess)
+        assertEquals(listOf(1L, 2L), submitted)
+        assertEquals(listOf(2L), uploaded)
+    }
+
     @Test fun `handoff callback runs only after successful submit and local upload mark`() {
         for (failure in listOf("submit", "mark", "none")) {
             val events = mutableListOf<String>()
@@ -31,4 +47,37 @@ class PurchaseOutboxHandoffTest {
         PurchaseOutboxUploader({ listOf(item) }, { submitted++ }, {}).flush()
         assertEquals(1, submitted)
     }
+
+    @Test fun `only whitelisted 409 is terminal independent of retryable`() {
+        for (code in listOf("PURCHASE_STATE_CONFLICT", "PURCHASE_LEASE_EXPIRED", "PURCHASE_RESULT_CONFLICT", "OTHER")) {
+            for (status in listOf(409, 401, 403, 500)) for (retryable in listOf(false, true)) {
+                val events = mutableListOf<String>()
+                val result = runCatching {
+                    PurchaseOutboxUploader({ listOf(item) },
+                        { throw cn.ilapage.goauto.agent.network.AgentApiException(status, code, "secret URL", retryable) },
+                        { events += "uploaded" }, { events += "handoff" },
+                        { _, fixedCode -> events += fixedCode },
+                    ).flush()
+                }
+                val rejected = status == 409 && code != "OTHER"
+                assertEquals(rejected, result.isSuccess)
+                assertEquals(if (rejected) listOf(code) else emptyList<String>(), events)
+            }
+        }
+    }
+
+    @Test fun `network and rejected persistence failures retain pending and stop flush`() {
+        for (diskFailure in listOf(false, true)) {
+            val events = mutableListOf<String>()
+            val result = runCatching {
+                PurchaseOutboxUploader({ listOf(item, item.copy(id = 2)) },
+                    { events += "submit"; if (diskFailure) throw cn.ilapage.goauto.agent.network.AgentApiException(409, "PURCHASE_STATE_CONFLICT", "raw", false) else error("network") },
+                    { events += "uploaded" }, { events += "handoff" },
+                    { _, _ -> events += "reject"; error("disk") },
+                ).flush()
+            }
+            assertTrue(result.isFailure)
+            assertEquals(if (diskFailure) listOf("submit", "reject") else listOf("submit"), events)
+        }
+    }
 }

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

@@ -0,0 +1,54 @@
+package cn.ilapage.goauto.agent
+
+import cn.ilapage.goauto.agent.network.AgentApiClient
+import cn.ilapage.goauto.agent.network.AgentApiException
+import cn.ilapage.goauto.agent.persistence.PendingPurchaseOutbox
+import cn.ilapage.goauto.agent.persistence.PurchaseOutboxUploader
+import java.net.ServerSocket
+import java.util.concurrent.Executors
+import java.util.concurrent.TimeUnit
+import org.junit.Assert.*
+import org.junit.Test
+
+class PurchaseOutboxHttpTest {
+    @Test fun `missing retryable is not evidence that an unknown 409 is terminal`() {
+        for (code in listOf("PURCHASE_STATE_CONFLICT", "PURCHASE_LEASE_EXPIRED", "PURCHASE_RESULT_CONFLICT", "UNKNOWN_CONFLICT")) {
+            ServerSocket(0).use { server ->
+                server.soTimeout = 3000
+                val executor = Executors.newSingleThreadExecutor()
+                val serving = executor.submit {
+                    server.accept().use { socket ->
+                        socket.soTimeout = 3000
+                        val reader = socket.getInputStream().bufferedReader()
+                        var contentLength = 0
+                        while (true) {
+                            val line = reader.readLine() ?: break
+                            if (line.isEmpty()) break
+                            if (line.startsWith("Content-Length:", true)) contentLength = line.substringAfter(':').trim().toInt()
+                        }
+                        repeat(contentLength) { check(reader.read() >= 0) }
+                        val response = """{"code":"$code","message":"untrusted diagnostic"}"""
+                        socket.getOutputStream().write(("HTTP/1.1 409 Conflict\r\nContent-Type: application/json\r\nContent-Length: ${response.toByteArray().size}\r\nConnection: close\r\n\r\n$response").toByteArray())
+                    }
+                }
+                try {
+                    val api = AgentApiClient("http://127.0.0.1:${server.localPort}")
+                    var pending = true
+                    val result = runCatching {
+                        PurchaseOutboxUploader(
+                            { listOf(PendingPurchaseOutbox(1,42,"probe","request","{}")) },
+                            { api.submitPurchaseResult(it.taskId,it.payloadJson,"synthetic") },
+                            { fail("409 is never uploaded") },
+                            { fail("409 is never a handoff") },
+                            { _, _ -> pending = false },
+                        ).flush()
+                    }
+                    assertEquals(code == "UNKNOWN_CONFLICT", pending)
+                    assertEquals(code != "UNKNOWN_CONFLICT", result.isSuccess)
+                    if (pending) assertFalse((result.exceptionOrNull() as AgentApiException).retryable)
+                    serving.get(5, TimeUnit.SECONDS)
+                } finally { executor.shutdownNow() }
+            }
+        }
+    }
+}

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

@@ -723,31 +723,6 @@ class PurchaseRehearsalExecutorTest {
         assertEquals(1, driver.clicked.count { it == "黑色" })
     }
 
-    @Test
-    fun `visible unselected target without summary cannot reuse historical proof`() {
-        val driver = FakePurchaseDriver(sizes = listOf("L"), hideSelectedSummaryAfterQuantitySet = true, hideSizeSelectedState = true)
-        val outcome = executor(driver, { driver.browser = true; true }, { null }, pause = {})
-            .execute(input().copy(mappedSize = "L"), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
-        assertEquals("failed", outcome.resultType)
-        assertEquals("PURCHASE_SPEC_SELECTION_UNCONFIRMED", outcome.errorCode)
-        assertTrue(outcome.message, outcome.message.contains("reason=target_visible_unselected"))
-        assertTrue(outcome.message, outcome.message.contains("proofRecorded=true"))
-    }
-
-    @Test
-    fun `visible unselected normalized target blocks historical proof without relocation`() {
-        val target = "L【建议105-115斤】"
-        val driver = FakePurchaseDriver(
-            sizes = listOf(target), hideSelectedSummaryAfterQuantitySet = true,
-            finalSizesAfterQuantitySet = listOf("Ｌ［建议105-115斤］"),
-        )
-        val outcome = executor(driver, { driver.browser = true; true }, { null }, pause = {})
-            .execute(input().copy(mappedSize = target), PurchaseRuleParser.parse(rule()), PurchaseAgentCapabilities.supported)
-        assertEquals("PURCHASE_SPEC_SELECTION_UNCONFIRMED", outcome.errorCode)
-        assertTrue(outcome.message, outcome.message.contains("reason=target_visible_unselected"))
-        assertFalse(driver.swipeInPaths.contains("scroll"))
-    }
-
     @Test
     fun `final verification keeps current attempt proof when selected panel becomes unclassified`() {
         val driver = FakePurchaseDriver(panelBecomesUnknownAfterSizeProof = true)

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

@@ -0,0 +1,32 @@
+package cn.ilapage.goauto.agent
+
+import cn.ilapage.goauto.agent.persistence.RejectedPurchaseResult
+import cn.ilapage.goauto.agent.ui.PurchaseRejectionPresentation
+import org.junit.Assert.*
+import org.junit.Test
+
+class PurchaseRejectionPresentationTest {
+    private fun item(payload: String, acknowledged: Long? = null) = RejectedPurchaseResult(1,42,"attempt",payload,100,"PURCHASE_STATE_CONFLICT",acknowledged)
+    @Test fun `only unacknowledged order evidence appears on procurement banner`() {
+        for (payload in listOf("""{"resultType":"order_created"}""", """{"resultType":"order_result_unknown"}""", """{"resultType":"failed","pddOrderNo":"123-456"}""")) {
+            assertTrue(PurchaseRejectionPresentation.showBanner(item(payload)))
+            assertFalse(PurchaseRejectionPresentation.showBanner(item(payload, 200)))
+        }
+        assertFalse(PurchaseRejectionPresentation.showBanner(item("""{"resultType":"spec_probe_completed"}""")))
+        assertFalse(PurchaseRejectionPresentation.showBanner(item("""{"resultType":"spec_probe_completed","pddOrderNo":null}""")))
+    }
+    @Test fun `notice includes task optional order and fixed review instruction without raw errors`() {
+        val message = PurchaseRejectionPresentation.notice(item("""{"resultType":"order_created","pddOrderNo":"123-456","message":"https://secret"}"""))
+        assertTrue(message.contains("#42")); assertTrue(message.contains("123-456"))
+        assertTrue(message.contains("请人工核对拼多多订单及后台任务，避免重复采购"))
+        assertFalse(message.contains("secret"))
+    }
+    @Test fun `connection classifies sync heartbeat and rejected separately`() {
+        assertEquals("正在同步", PurchaseRejectionPresentation.connection("CONNECTING", 2))
+        assertEquals("已连接 · 有 2 条采购结果被服务端拒收", PurchaseRejectionPresentation.connection("ONLINE", 2))
+        assertEquals("未连接 · 设备认证失败", PurchaseRejectionPresentation.connection("AUTH_ERROR", 2))
+        assertEquals("未连接 · 设备任务状态不一致", PurchaseRejectionPresentation.connection("TASK_MISMATCH", 2))
+        assertEquals("未连接 · 网络暂不可用", PurchaseRejectionPresentation.connection("NETWORK_ERROR", 2))
+        assertEquals("未连接 · 服务端暂不可用", PurchaseRejectionPresentation.connection("SERVER_ERROR", 2))
+    }
+}

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

@@ -502,7 +502,7 @@ class SpecPanelRecognitionTest {
         val base = SpecPanelFixtures.sheet(Sheet(submit = "none"))
         val snapshot = base.copy(
             nodes = base.nodes + listOf(
-                node("r/real-submit", "提交订单", NodeBounds(0, 2135, 1080, 2200), clickable = true, parent = "r"),
+                node("r/real-submit", "选择颜色分类及尺码后，提交订单", NodeBounds(0, 2135, 1080, 2200), clickable = true, parent = "r"),
                 // Zero-*area* (right==left) and lower on screen: must never win despite
                 // having its own non-blank label and a clickable ancestor.
                 node("r/decoy", "¥0.0", NodeBounds(500, 2200, 500, 2216), clickable = true, parent = "r"),
@@ -512,7 +512,7 @@ class SpecPanelRecognitionTest {
 
         PurchaseLiveAutomation(driver, pause = {}).submitOrderOnce()
 
-        assertEquals(listOf("提交订单"), driver.clicked)
+        assertEquals(listOf("选择颜色分类及尺码后，提交订单"), driver.clicked)
     }
 
     @Test

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

@@ -196,13 +196,7 @@ class TruncatedSpecCardTest {
         var sizeSelected = false
         val clicks = mutableListOf<String>()
         override fun capture() = if (opened) snapshot.copy(nodes = snapshot.nodes.map { n ->
-            when {
-                n.path.contains("/size/o") -> n.copy(selected = sizeSelected && n.path.startsWith("r/sheet/body/list/size/o2"))
-                // #376: a completed fake selection must no longer expose PDD's incomplete-selection prompts.
-                sizeSelected && n.label.startsWith("请选择") -> n.copy(text = "已选 黑色示例长裤【有抽绳】 有口袋不起球 2XL建议130-150斤")
-                sizeSelected && n.label == "选择颜色分类及尺码后，提交订单" -> n.copy(text = "提交订单")
-                else -> n
-            }
+            if (n.path.contains("/size/o")) n.copy(selected = sizeSelected && n.path.startsWith("r/sheet/body/list/size/o2")) else n
         }) else SpecPanelFixtures.productDetailPage()
         override fun clickFresh(target: SnapshotNode): FreshActionResult {
             clicks += target.label
@@ -248,12 +242,7 @@ class TruncatedSpecCardTest {
     }
 
     @Test fun `existing final confirmation target first ordering is documented not changed`() {
-        val snapshot = sheet(otherSelected = true).let { sheet -> sheet.copy(nodes = sheet.nodes.map { node -> when {
-            node.label.startsWith("请选择") -> node.copy(text = "已选 $full $size")
-            node.label == "选择颜色分类及尺码后，提交订单" -> node.copy(text = "提交订单")
-            else -> node
-        } }) }
-        val screen = parse(snapshot)
+        val screen = parse(sheet(otherSelected = true))
         val executor = executor(Driver(sheet()))
         val immediate = PurchaseRehearsalExecutor::class.java.declaredMethods.single { it.name == "isExactSpecSelected" }
         immediate.isAccessible = true

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

@@ -8,10 +8,32 @@ import org.junit.Assert.assertTrue
 import org.junit.Test
 
 class AgentDiagnosticStoreMigrationTest {
+    @Test fun v1AndV5UpgradeToV6PreservesEveryExistingTableAndReopens() {
+        for (version in listOf(1,5)) {
+            val file=java.io.File.createTempFile("sync-v6-upgrade-",".db")
+            try {
+                val old: Map<String,List<List<String?>>>
+                DriverManager.getConnection("jdbc:sqlite:${file.absolutePath}").use { db ->
+                    createOldDatabase(db,version); insertOldDiagnostic(db); old=snapshotTables(db)
+                    migrate(db,version,6); assertOldDiagnosticPreserved(db)
+                    old.forEach { (name,rows)-> assertEquals(rows,tableRows(db,name)) }
+                    val store=SyncDiagnosticStore(JdbcSyncSql(db))
+                    val id=store.start("first",1000,null,SyncContext())
+                    store.finish(id,1100,100,SyncFailure("heartbeat","network",1100,100))
+                    store.ack(store.snapshot("first",1200)!!)
+                }
+                DriverManager.getConnection("jdbc:sqlite:${file.absolutePath}").use { db ->
+                    assertOldDiagnosticPreserved(db); old.forEach { (name,rows)-> assertEquals(rows,tableRows(db,name)) }
+                    val snapshot=SyncDiagnosticStore(JdbcSyncSql(db)).snapshot("reopened",1300)!!
+                    assertEquals(0,snapshot.report.getInt("failedRounds")); assertTrue(snapshot.report.getLong("snapshotSeq")>2)
+                }
+            } finally { check(file.delete()) }
+        }
+    }
     @Test
     fun freshV5DatabaseHasNullableColorDiscoveryOutcomeColumns() = withDatabase { db ->
         db.createStatement().use { it.execute(AgentDiagnosticSchema.createTableSql) }
-        assertEquals(5, AgentDiagnosticSchema.VERSION)
+        assertEquals(6, AgentDiagnosticSchema.VERSION)
         assertV5Columns(db)
         insertOldDiagnostic(db)
         assertOldDiagnosticPreserved(db)

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

@@ -0,0 +1,106 @@
+package cn.ilapage.goauto.agent.persistence
+
+import cn.ilapage.goauto.agent.network.AgentApiException
+import cn.ilapage.goauto.agent.network.HeartbeatResult
+import cn.ilapage.goauto.agent.service.AgentSyncCycle
+import cn.ilapage.goauto.agent.service.recoverPurchaseBoundary
+import java.sql.DriverManager
+import java.util.concurrent.CancellationException
+import org.json.JSONArray
+import org.junit.Assert.*
+import org.junit.Test
+
+class HandledRecoveryDiagnosticTest {
+    @Test
+    fun handledBoundaryApiFailureIsPersistedButDoesNotChangeRecoveryOrClaimPolicy() {
+        for (status in listOf(500, 409)) {
+            for (pending in listOf(false, true)) {
+                DriverManager.getConnection("jdbc:sqlite::memory:").use { db ->
+                    val sql = JdbcSyncSql(db)
+                    AgentDiagnosticSchema.syncStatements.forEach { sql.execute(it) }
+                    val store = SyncDiagnosticStore(sql)
+                    var elapsed = 10L
+                    val round =
+                        SyncDiagnosticRecorder(store, "p", { 1000 }, { elapsed })
+                            .begin(SyncContext())
+                    val events = mutableListOf<String>()
+                    var originalMarkerPresent = true
+                    val replayBoundary: () -> Unit = {
+                        events += "recover"
+                        elapsed = 45
+                        throw AgentApiException(
+                            status,
+                            "PRIVATE_CODE",
+                            "private URL and payload",
+                            false,
+                        )
+                    }
+                    val cycle =
+                        AgentSyncCycle(
+                                heartbeat = {
+                                    round.step("heartbeat") {
+                                        events += "heartbeat"
+                                        HeartbeatResult(1, true, false, 15)
+                                    }
+                                },
+                                activeTaskId = { null },
+                                executionActive = { false },
+                                recover = {
+                                    round.step("recover") {
+                                        recoverPurchaseBoundary(round::handledFailure) {
+                                            replayBoundary()
+                                            originalMarkerPresent = false
+                                        }
+                                    }
+                                },
+                                flush = { round.step("flush") { events += "flush" } },
+                                hasPending = { pending },
+                            )
+                            .run()
+                    round.finish()
+                    assertEquals(listOf("heartbeat", "recover", "flush"), events)
+                    assertTrue(originalMarkerPresent)
+                    assertNull(cycle.failureCode)
+                    assertEquals(!pending, cycle.canClaim)
+                    val row = sql.query("SELECT * FROM sync_round").single()
+                    assertEquals("failure", row["status"])
+                    assertEquals("recover", row["failure_step"])
+                    assertEquals(
+                        if (status == 500) "api_server" else "api_conflict",
+                        row["failure_category"],
+                    )
+                    assertEquals("35", row["failure_duration_ms"])
+                    assertEquals(status.toString(), row["http_status"])
+                    assertNull(row["api_code"])
+                    val steps = JSONArray(row["steps"])
+                    assertEquals("failure", steps.getJSONObject(2).getString("status"))
+                    assertEquals(35, steps.getJSONObject(2).getLong("durationMs"))
+                    assertEquals("success", steps.getJSONObject(3).getString("status"))
+                    assertFalse(row.toString().contains("private"))
+                    assertEquals(1, store.snapshot("p", 1100)!!.report.getInt("failedRounds"))
+                }
+            }
+        }
+    }
+
+    @Test
+    fun boundaryPolicyStillRethrowsAuthenticationCancellationAndFatalErrors() {
+        for (error in
+            listOf(
+                AgentApiException(401, "OTHER", "private", false),
+                AgentApiException(409, "DEVICE_DISABLED", "private", false),
+                CancellationException(),
+                OutOfMemoryError(),
+            )) {
+            val thrown =
+                assertThrows(error.javaClass) {
+                    recoverPurchaseBoundary({
+                        fail("only handled nonauthentication API errors are observed")
+                    }) {
+                        throw error
+                    }
+                }
+            assertSame(error, thrown)
+        }
+    }
+}

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

@@ -0,0 +1,100 @@
+package cn.ilapage.goauto.agent.persistence
+
+import java.sql.Connection
+import java.sql.DriverManager
+import org.junit.Assert.*
+import org.junit.Test
+
+class PurchaseRejectionStoreTest {
+    @Test fun `v2 upgrade adds exactly three nullable columns and preserves all old data`() = database { db ->
+        val before = rows(db, "SELECT * FROM purchase_outbox")
+        val taskBefore = rows(db, "SELECT * FROM purchase_task")
+        migrate(db)
+        assertEquals(3, PurchaseRejectionSql.migration.size)
+        assertEquals(taskBefore, rows(db, "SELECT * FROM purchase_task"))
+        assertEquals(before, rows(db, "SELECT id, task_id, attempt_id, request_id, payload_json, upload_status, created_at, updated_at FROM purchase_outbox"))
+        assertEquals(listOf(listOf(null, null, null)), rows(db, "SELECT rejected_at,rejection_error_code,acknowledged_at FROM purchase_outbox"))
+        val columns = rows(db, "PRAGMA table_info(purchase_outbox)").takeLast(3)
+        assertTrue(columns.all { it[3] == "0" && it[4] == null })
+    }
+
+    @Test fun `reject is atomic preserves payload excludes pending and targets current attempt only`() = database { db ->
+        migrate(db)
+        reject(db)
+        assertEquals(listOf(listOf("rejected", "payload", "100", "PURCHASE_STATE_CONFLICT")), rows(db, "SELECT upload_status,payload_json,rejected_at,rejection_error_code FROM purchase_outbox"))
+        assertEquals(listOf(listOf("completed", "rejected", "payload")), rows(db, "SELECT status,upload_status,result_json FROM purchase_task"))
+        assertTrue(rows(db, PurchaseRejectionSql.activeTask).isEmpty())
+        assertTrue(rows(db, "SELECT id FROM purchase_outbox WHERE upload_status='pending'").isEmpty())
+    }
+
+    @Test fun `old outbox rejection cannot overwrite a newer task attempt`() = database { db ->
+        migrate(db)
+        db.createStatement().use { it.execute("UPDATE purchase_task SET attempt_id='new',status='running',upload_status='none'") }
+        reject(db)
+        assertEquals(listOf(listOf("new", "running", "none")), rows(db, "SELECT attempt_id,status,upload_status FROM purchase_task"))
+    }
+
+    @Test fun `rejected record never counts active even if legacy local status says running`() = database { db ->
+        migrate(db); reject(db)
+        db.createStatement().use { it.execute("UPDATE purchase_task SET status='running'") }
+        assertTrue(rows(db, PurchaseRejectionSql.activeTask).isEmpty())
+    }
+
+    @Test fun `invalid whitelist and mismatched outbox identity cannot change evidence`() = database { db ->
+        migrate(db)
+        for ((item, code) in listOf(
+            PendingPurchaseOutbox(1,42,"old","request","payload") to "UNKNOWN",
+            PendingPurchaseOutbox(1,42,"new","request","payload") to "PURCHASE_STATE_CONFLICT",
+        )) {
+            assertTrue(runCatching { PurchaseRejectionSql.reject(item, code, 100) { sql, args -> update(db, sql, args) } }.isFailure)
+        }
+        assertEquals(listOf(listOf("pending", null, null)), rows(db, "SELECT upload_status,rejected_at,rejection_error_code FROM purchase_outbox"))
+    }
+
+    @Test fun `task update failure rolls back rejection evidence too`() = database { db ->
+        migrate(db)
+        db.createStatement().use { it.execute("CREATE TRIGGER fail_task BEFORE UPDATE ON purchase_task BEGIN SELECT RAISE(ABORT, 'test'); END") }
+        assertTrue(runCatching { reject(db) }.isFailure)
+        assertEquals(listOf(listOf("pending", null, null)), rows(db, "SELECT upload_status,rejected_at,rejection_error_code FROM purchase_outbox"))
+        assertEquals(listOf(listOf("pending")), rows(db, "SELECT upload_status FROM purchase_task"))
+    }
+
+    @Test fun `ack survives database reopen and changes no payload or task state`() {
+        val file = java.io.File.createTempFile("purchase-rejection-", ".db")
+        try {
+            connect(file.absolutePath).use { db ->
+                seed(db); migrate(db); reject(db)
+                update(db, PurchaseRejectionSql.acknowledge, listOf(200L, 1L))
+            }
+            connect(file.absolutePath).use { db ->
+                assertEquals(listOf(listOf("200", "payload", "rejected")), rows(db, "SELECT acknowledged_at,payload_json,upload_status FROM purchase_outbox"))
+                assertEquals(listOf(listOf("completed", "rejected")), rows(db, "SELECT status,upload_status FROM purchase_task"))
+            }
+        } finally { check(file.delete()) }
+    }
+
+    private fun reject(db: Connection) {
+        db.autoCommit = false
+        try {
+            PurchaseRejectionSql.reject(PendingPurchaseOutbox(1,42,"old","request","payload"), "PURCHASE_STATE_CONFLICT", 100) { sql, args -> update(db, sql, args) }
+            db.commit()
+        } catch (error: Exception) { db.rollback(); throw error }
+        finally { db.autoCommit = true }
+    }
+    private fun update(db: Connection, sql: String, args: List<Any>): Int = db.prepareStatement(sql).use { statement ->
+        args.forEachIndexed { index, arg -> statement.setObject(index + 1, arg) }
+        statement.executeUpdate()
+    }
+    private fun migrate(db: Connection) = PurchaseRejectionSql.migration.forEach { sql -> db.createStatement().use { it.execute(sql) } }
+    private fun connect(path: String): Connection { Class.forName("org.sqlite.JDBC"); return DriverManager.getConnection("jdbc:sqlite:$path") }
+    private fun database(block: (Connection) -> Unit) = connect(":memory:").use { seed(it); block(it) }
+    private fun rows(db: Connection, sql: String): List<List<String?>> = db.createStatement().use { statement ->
+        statement.executeQuery(sql).use { r -> buildList { while(r.next()) add((1..r.metaData.columnCount).map { r.getString(it) }) } }
+    }
+    private fun seed(db: Connection) = db.createStatement().use {
+        it.execute("CREATE TABLE purchase_task (task_id INTEGER PRIMARY KEY,attempt_id TEXT NOT NULL,rule_snapshot_hash TEXT NOT NULL,current_step TEXT NOT NULL,status TEXT NOT NULL,result_json TEXT,upload_status TEXT NOT NULL,created_at INTEGER NOT NULL,updated_at INTEGER NOT NULL,order_submit_request_id TEXT,final_confirmation_json TEXT,irreversible_at INTEGER)")
+        it.execute("CREATE TABLE purchase_outbox (id INTEGER PRIMARY KEY AUTOINCREMENT,task_id INTEGER NOT NULL,attempt_id TEXT NOT NULL,request_id TEXT NOT NULL UNIQUE,payload_json TEXT NOT NULL,upload_status TEXT NOT NULL,created_at INTEGER NOT NULL,updated_at INTEGER NOT NULL)")
+        it.execute("INSERT INTO purchase_task VALUES (42,'old','hash','submit_result','completed','payload','pending',1,2,NULL,NULL,NULL)")
+        it.execute("INSERT INTO purchase_outbox VALUES (1,42,'old','request','payload','pending',1,2)")
+    }
+}

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

@@ -0,0 +1,225 @@
+package cn.ilapage.goauto.agent.persistence
+
+import java.sql.DriverManager
+import java.util.concurrent.CancellationException
+import org.junit.Assert.*
+import org.junit.Test
+
+class SyncDiagnosticRecorderTest {
+    @Test
+    fun collectionWithSameNumericIdCannotInheritPurchaseAttempt() {
+        val old = SyncContext(taskId = 7, attemptId = "old-purchase", phase = "purchase")
+        val collection =
+            syncTaskIdentity(7, "collection", true, old) {
+                error("must not read purchase fallback")
+            }
+        assertEquals(7L, collection.taskId)
+        assertNull(collection.attemptId)
+        assertNull(collection.phase)
+        val purchase = syncTaskIdentity(7, "purchase", true, old) { null }
+        assertEquals("old-purchase", purchase.attemptId)
+        val recovered = syncTaskIdentity(8, null, false, old) { "recovered" }
+        assertEquals("recovered", recovered.attemptId)
+        assertNull(recovered.phase)
+    }
+
+    @Test
+    fun failureOfEachPersistenceStageIsIsolatedAndNeverCreatesFakeSuccess() {
+        for (target in
+            listOf(
+                "open",
+                "INSERT INTO sync_round",
+                "UPDATE sync_round SET steps",
+                "UPDATE sync_round SET ended_at",
+                "SELECT sequence",
+                "DELETE FROM sync_round",
+            )) {
+            DriverManager.getConnection("jdbc:sqlite::memory:").use { db ->
+                val real = JdbcSyncSql(db)
+                AgentDiagnosticSchema.syncStatements.forEach { real.execute(it) }
+                val broken =
+                    object : SyncSql {
+                        override fun execute(sql: String, args: List<Any?>) {
+                            if (sql.startsWith(target)) error("private secret")
+                            real.execute(sql, args)
+                        }
+
+                        override fun query(
+                            sql: String,
+                            args: List<Any?>,
+                        ): List<Map<String, String?>> {
+                            if (sql.startsWith(target)) error("private secret")
+                            return real.query(sql, args)
+                        }
+
+                        override fun <T> transaction(block: () -> T): T {
+                            if (target == "open") error("private secret")
+                            return real.transaction(block)
+                        }
+                    }
+                var warnings = 0
+                val recorder =
+                    SyncDiagnosticRecorder(SyncDiagnosticStore(broken), "p", { 1000 }, { 10 }) {
+                        warnings++
+                    }
+                var business = 0
+                val round = recorder.begin(SyncContext())
+                round.step("heartbeat") { business++ }
+                round.finish()
+                assertEquals(target, 1, business)
+                assertTrue(target, warnings > 0)
+                val rows = real.query("SELECT * FROM sync_round")
+                if (target != "DELETE FROM sync_round")
+                    assertTrue(target, rows.none { it["status"] == "success" })
+                assertFalse(rows.toString().contains("private secret"))
+            }
+        }
+    }
+
+    @Test
+    fun readAckCleanupFailuresKeepUnacknowledgedFailuresAndCancellationIsNotSwallowed() {
+        DriverManager.getConnection("jdbc:sqlite::memory:").use { db ->
+            val real = JdbcSyncSql(db)
+            AgentDiagnosticSchema.syncStatements.forEach { real.execute(it) }
+            val store = SyncDiagnosticStore(real)
+            val id = store.start("p", 1000, null, SyncContext())
+            store.finish(id, 1100, 100, SyncFailure("flush", "exception", 1100, 100))
+            val snapshot = store.snapshot("p", 1200)!!
+            var failure: Exception = IllegalStateException("secret")
+            val broken =
+                object : SyncSql {
+                    override fun execute(sql: String, args: List<Any?>) {
+                        throw failure
+                    }
+
+                    override fun query(sql: String, args: List<Any?>): List<Map<String, String?>> {
+                        throw failure
+                    }
+
+                    override fun <T> transaction(block: () -> T): T = real.transaction(block)
+                }
+            val recorder =
+                SyncDiagnosticRecorder(SyncDiagnosticStore(broken), "p", { 1300 }, { 10 })
+            recorder.ack(snapshot)
+            assertNull(recorder.snapshot())
+            assertEquals(1, store.snapshot("p", 1400)!!.report.getInt("failedRounds"))
+            failure = CancellationException()
+            assertThrows(CancellationException::class.java) { recorder.snapshot() }
+            assertThrows(CancellationException::class.java) { recorder.begin(SyncContext()) }
+        }
+    }
+
+    @Test
+    fun freshRecorderDoesNotReusePreviousElapsedClockAndAbortedRoundStaysRunning() {
+        DriverManager.getConnection("jdbc:sqlite::memory:").use { db ->
+            val sql = JdbcSyncSql(db)
+            AgentDiagnosticSchema.syncStatements.forEach { sql.execute(it) }
+            val store = SyncDiagnosticStore(sql)
+            SyncDiagnosticRecorder(store, "old", { 1000 }, { 9000 }).begin(SyncContext()).finish()
+            val round = SyncDiagnosticRecorder(store, "new", { 2000 }, { 5 }).begin(SyncContext())
+            round.abort()
+            round.finish()
+            val row = sql.query("SELECT * FROM sync_round ORDER BY id DESC LIMIT 1").single()
+            assertNull(row["start_gap_ms"])
+            assertEquals("running", row["status"])
+        }
+    }
+
+    @Test
+    fun wallClockJumpDoesNotChangeElapsedDurationAndRepeatedStepsHaveDistinctOrdinals() {
+        DriverManager.getConnection("jdbc:sqlite::memory:").use { db ->
+            AgentDiagnosticSchema.syncStatements.forEach {
+                db.createStatement().use { s -> s.execute(it) }
+            }
+            val sql = JdbcSyncSql(db)
+            var wall = 1000L
+            var elapsed = 10L
+            val recorder =
+                SyncDiagnosticRecorder(SyncDiagnosticStore(sql), "process", { wall }, { elapsed })
+            val round = recorder.begin(SyncContext())
+            round.step("heartbeat") {
+                wall = -500
+                elapsed = 30
+            }
+            round.step("heartbeat") { elapsed = 40 }
+            round.finish()
+            val row = sql.query("SELECT * FROM sync_round").single()
+            assertEquals("30", row["duration_ms"])
+            val steps = org.json.JSONArray(row["steps"])
+            assertEquals(3, steps.length())
+            assertEquals(1, steps.getJSONObject(1).getInt("ordinal"))
+            assertEquals(2, steps.getJSONObject(2).getInt("ordinal"))
+            assertEquals(0, steps.getJSONObject(1).getLong("startedOffsetMs"))
+            assertEquals(20, steps.getJSONObject(1).getLong("endedOffsetMs"))
+            assertEquals(20, steps.getJSONObject(2).getLong("startedOffsetMs"))
+            assertEquals(30, steps.getJSONObject(2).getLong("endedOffsetMs"))
+            elapsed = 110
+            recorder.begin(SyncContext()).finish()
+            assertEquals(
+                "100",
+                sql.query("SELECT start_gap_ms FROM sync_round ORDER BY id DESC LIMIT 1")
+                    .single()["start_gap_ms"],
+            )
+        }
+    }
+
+    @Test
+    fun authenticationCodesAndUninstrumentedTimeoutAreSafelyClassified() {
+        assertEquals(
+            "api_auth",
+            syncFailure(
+                    cn.ilapage.goauto.agent.network.AgentApiException(
+                        409,
+                        "DEVICE_DISABLED",
+                        "private",
+                        false,
+                    ),
+                    "heartbeat",
+                    1000,
+                    10,
+                )
+                .category,
+        )
+        val failure =
+            syncFailure(
+                java.net.SocketTimeoutException("connect timed out url secret"),
+                "register",
+                1000,
+                10,
+            )
+        assertEquals("timeout_unknown", failure.category)
+        assertEquals("SocketTimeoutException", failure.exceptionClass)
+        assertNull(
+            syncFailure(IllegalArgumentException("private"), "flush", 1000, 10).exceptionClass
+        )
+    }
+
+    @Test
+    fun storageFailuresNeverBlockBusinessButCancellationAndFatalErrorsPropagate() {
+        val sql =
+            object : SyncSql {
+                override fun execute(sql: String, args: List<Any?>) {
+                    throw IllegalStateException("private message")
+                }
+
+                override fun query(sql: String, args: List<Any?>): List<Map<String, String?>> {
+                    throw IllegalStateException("private message")
+                }
+
+                override fun <T> transaction(block: () -> T): T = block()
+            }
+        val recorder = SyncDiagnosticRecorder(SyncDiagnosticStore(sql), "p", { 1000 }, { 10 })
+        var count = 0
+        val round = recorder.begin(SyncContext())
+        round.step("heartbeat") { count++ }
+        round.finish()
+        assertEquals(1, count)
+        assertNull(recorder.snapshot())
+        assertThrows(CancellationException::class.java) {
+            round.step("flush") { throw CancellationException() }
+        }
+        assertThrows(OutOfMemoryError::class.java) {
+            round.step("flush") { throw OutOfMemoryError() }
+        }
+    }
+}

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

@@ -0,0 +1,168 @@
+package cn.ilapage.goauto.agent.persistence
+
+import java.sql.DriverManager
+import org.junit.Assert.*
+import org.junit.Test
+
+class SyncDiagnosticStoreTest {
+    @Test
+    fun contextRejectsArbitraryTextInsteadOfPersistingIt() {
+        DriverManager.getConnection("jdbc:sqlite::memory:").use { db ->
+            val sql = JdbcSyncSql(db)
+            AgentDiagnosticSchema.syncStatements.forEach { sql.execute(it) }
+            SyncDiagnosticStore(sql)
+                .start(
+                    "p",
+                    1000,
+                    null,
+                    SyncContext(
+                        deviceId = -1,
+                        taskId = -1,
+                        attemptId = "secret URL",
+                        phase = "secret URL",
+                        transport = "secret URL",
+                    ),
+                )
+            val row = sql.query("SELECT * FROM sync_round").single()
+            assertNull(row["device_id"])
+            assertNull(row["task_id"])
+            assertNull(row["attempt_id"])
+            assertNull(row["phase"])
+            assertEquals("unknown", row["transport"])
+            assertFalse(row.toString().contains("secret URL"))
+        }
+    }
+
+    @Test
+    fun retentionBoundsSyncHistoryOnlyAndSequenceDoesNotReset() {
+        DriverManager.getConnection("jdbc:sqlite::memory:").use { db ->
+            val sql = JdbcSyncSql(db)
+            AgentDiagnosticSchema.syncStatements.forEach { sql.execute(it) }
+            sql.execute(AgentDiagnosticSchema.createTableSql)
+            sql.execute(
+                "INSERT INTO agent_diagnostic(task_id,stage,reason,attempt,elapsed_ms,agent_version,created_at) VALUES(1,'x','x',0,0,'old',1)"
+            )
+            val store = SyncDiagnosticStore(sql)
+            val expired = store.start("p", 1, null, SyncContext())
+            store.finish(expired, 2, 1, SyncFailure("sync", "exception", 2, 1))
+            val before = store.snapshot("p", 10)!!.report.getLong("snapshotSeq")
+            val now = SyncDiagnosticStore.RETENTION_MS + 1000
+            store.start("p", 999, null, SyncContext())
+            store.start("p", 1000, null, SyncContext())
+            store.cleanup(now)
+            assertEquals("1", sql.query("SELECT COUNT(*) AS n FROM sync_round").single()["n"])
+            repeat(6001) { store.start("p", now, null, SyncContext()) }
+            store.cleanup(now)
+            assertEquals("6000", sql.query("SELECT COUNT(*) AS n FROM sync_round").single()["n"])
+            assertEquals("1", sql.query("SELECT COUNT(*) AS n FROM agent_diagnostic").single()["n"])
+            assertTrue(store.snapshot("p", now)!!.report.getLong("snapshotSeq") > before)
+        }
+    }
+
+    @Test
+    fun ackCannotEraseRunningRoundThatFailsAfterSnapshotAndRestartKeepsSequence() {
+        DriverManager.getConnection("jdbc:sqlite::memory:").use { db ->
+            AgentDiagnosticSchema.syncStatements.forEach { sql ->
+                db.createStatement().use { it.execute(sql) }
+            }
+            val sql = JdbcSyncSql(db)
+            val store = SyncDiagnosticStore(sql)
+            val first = store.start("p1", 1000, null, SyncContext())
+            store.finish(first, 1100, 100, SyncFailure("heartbeat", "network", 1100, 100))
+            val running = store.start("p1", 1200, 200, SyncContext())
+            val snapshot = store.snapshot("p1", 1250)!!
+            assertEquals(1, snapshot.report.getInt("failedRounds"))
+            store.finish(running, 1300, 100, SyncFailure("flush", "exception", 1300, 100))
+            store.ack(snapshot)
+            val restart = SyncDiagnosticStore(sql).snapshot("p2", 1400)!!
+            assertEquals(1, restart.report.getInt("failedRounds"))
+            assertEquals("flush", restart.report.getString("latestFailureStep"))
+            assertTrue(
+                restart.report.getLong("snapshotSeq") > snapshot.report.getLong("snapshotSeq")
+            )
+            assertEquals(1, store.snapshot("p2", 1450)!!.report.getInt("failedRounds"))
+        }
+    }
+
+    @Test
+    fun oldRunningIsInterruptedAndNeverInventsFailure() {
+        DriverManager.getConnection("jdbc:sqlite::memory:").use { db ->
+            AgentDiagnosticSchema.syncStatements.forEach { sql ->
+                db.createStatement().use { it.execute(sql) }
+            }
+            val store = SyncDiagnosticStore(JdbcSyncSql(db))
+            store.start("old", 1000, null, SyncContext())
+            val snapshot = store.snapshot("new", 1200)!!
+            assertTrue(snapshot.report.getBoolean("hasInterruptedRound"))
+            assertEquals(0, snapshot.report.getInt("failedRounds"))
+            assertTrue(snapshot.report.isNull("latestFailureAt"))
+            store.ack(snapshot)
+            assertTrue(store.snapshot("new", 1300)!!.report.getBoolean("hasInterruptedRound"))
+            store.cleanup(1001 + SyncDiagnosticStore.RETENTION_MS)
+            assertFalse(
+                store
+                    .snapshot("new", 1001 + SyncDiagnosticStore.RETENTION_MS)!!
+                    .report
+                    .getBoolean("hasInterruptedRound")
+            )
+        }
+    }
+
+    @Test
+    fun v6AddsSyncHistoryWithoutChangingLegacyRetention() {
+        assertEquals(6, AgentDiagnosticSchema.VERSION)
+        assertEquals(50, AgentDiagnosticRetentionPolicy.MAX_RECORDS)
+        DriverManager.getConnection("jdbc:sqlite::memory:").use { db ->
+            db.createStatement().use { it.execute(AgentDiagnosticSchema.createTableSql) }
+            AgentDiagnosticSchema.failureSnapshotStatements.forEach { sql ->
+                db.createStatement().use { it.execute(sql) }
+            }
+            AgentDiagnosticSchema.migrationStatements(5, 6, emptySet()).forEach { sql ->
+                db.createStatement().use { it.execute(sql) }
+            }
+            db.createStatement().use { s ->
+                s.executeQuery("SELECT COUNT(*) FROM sync_round").use {
+                    assertTrue(it.next())
+                    assertEquals(0, it.getInt(1))
+                }
+            }
+        }
+    }
+}
+
+internal class JdbcSyncSql(private val db: java.sql.Connection) : SyncSql {
+    override fun execute(sql: String, args: List<Any?>) {
+        db.prepareStatement(sql).use { s ->
+            args.forEachIndexed { i, v -> s.setObject(i + 1, v) }
+            s.executeUpdate()
+        }
+    }
+
+    override fun query(sql: String, args: List<Any?>): List<Map<String, String?>> =
+        db.prepareStatement(sql).use { s ->
+            args.forEachIndexed { i, v -> s.setObject(i + 1, v) }
+            s.executeQuery().use { r ->
+                buildList {
+                    while (r.next()) add(
+                        (1..r.metaData.columnCount).associate {
+                            r.metaData.getColumnLabel(it) to r.getString(it)
+                        }
+                    )
+                }
+            }
+        }
+
+    override fun <T> transaction(block: () -> T): T {
+        db.autoCommit = false
+        try {
+            val value = block()
+            db.commit()
+            return value
+        } catch (e: Throwable) {
+            db.rollback()
+            throw e
+        } finally {
+            db.autoCommit = true
+        }
+    }
+}

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

@@ -0,0 +1,128 @@
+package cn.ilapage.goauto.agent.service
+
+import cn.ilapage.goauto.agent.network.AgentApiException
+import cn.ilapage.goauto.agent.network.HeartbeatResult
+import cn.ilapage.goauto.agent.persistence.PendingPurchaseOutbox
+import cn.ilapage.goauto.agent.persistence.PurchaseOutboxUploader
+import org.junit.Assert.*
+import org.junit.Test
+
+class AgentSyncCycleTest {
+    @Test fun taskIdentityReadFailureRemainsObservableWithoutChangingCycleOrder() {
+        val error=IllegalStateException("private")
+        val result=AgentSyncCycle({ online }, { throw error }, { false }, {}, {}, { false }).run()
+        assertSame(error,result.failure)
+        assertFalse(result.canClaim)
+    }
+    @Test fun cancellationAndFatalErrorsAreNeverConvertedToBusinessFailures() {
+        for(error in listOf(java.util.concurrent.CancellationException(), OutOfMemoryError())) {
+            assertThrows(error.javaClass) {
+                AgentSyncCycle({ throw error }, { null }, { false }, {}, {}, { false }).run()
+            }
+        }
+    }
+    private val online = HeartbeatResult(7, true, false, 15)
+    private fun api(status: Int, code: String) = AgentApiException(status, code, "untrusted URL", false)
+
+    @Test fun `stale completed probe heartbeat mismatch rejected then refreshed heartbeat permits next claim`() {
+        val events = mutableListOf<String>()
+        var active: Long? = 42
+        var pending = true
+        val result = AgentSyncCycle(
+            heartbeat = { id -> events += "heartbeat:$id"; if (id != null) throw api(409, "DEVICE_TASK_MISMATCH") else online },
+            activeTaskId = { active }, executionActive = { false },
+            recover = { events += "recover" },
+            flush = {
+                PurchaseOutboxUploader(
+                    { listOf(PendingPurchaseOutbox(1,42,"probe","request","{}")) },
+                    { throw api(409,"PURCHASE_STATE_CONFLICT") },
+                    { fail("rejected probe must not be marked uploaded") },
+                    { fail("rejected probe must not establish handoff") },
+                    { _, _ -> events += "reject-probe"; pending = false; active = null },
+                ).flush()
+            },
+            hasPending = { pending },
+        ).run()
+        if (result.canClaim) events += "claim"
+        assertEquals(listOf("heartbeat:42", "recover", "reject-probe", "heartbeat:null", "claim"), events)
+        assertEquals(online, result.heartbeat)
+    }
+
+    @Test fun `authentication errors skip recovery and flush including unrecognized HTTP 401 and 403`() {
+        for ((status, code) in listOf(401 to "OTHER", 403 to "OTHER", 409 to "DEVICE_TOKEN_INVALID", 409 to "DEVICE_INSTALL_ID_CONFLICT", 409 to "DEVICE_DISABLED")) {
+            val result = AgentSyncCycle({ throw api(status, code) }, { 42 }, { false },
+                { fail("recovery after auth failure") }, { fail("flush after auth failure") }, { true }).run()
+            assertFalse(result.canClaim)
+            assertEquals("AUTH_ERROR", result.failureCode)
+        }
+    }
+
+    @Test fun `heartbeat survives recovery or flush failure but claiming stops`() {
+        for (recoverFails in listOf(false, true)) {
+            var flushed = false
+            val result = AgentSyncCycle({ online }, { null }, { false },
+                { if (recoverFails) error("disk") },
+                { flushed = true; if (!recoverFails) throw api(500, "INTERNAL") }, { false }).run()
+            assertTrue(flushed)
+            assertEquals(online, result.heartbeat)
+            assertFalse(result.canClaim)
+        }
+    }
+
+    @Test fun `failed heartbeat still flushes but never claims and mismatch retries only once`() {
+        for (code in listOf("DEVICE_TASK_MISMATCH", "INTERNAL")) {
+            var heartbeats = 0
+            var flushed = false
+            val result = AgentSyncCycle({ heartbeats++; throw api(409, code) }, { null }, { false }, {},
+                { flushed = true }, { false }).run()
+            assertTrue(flushed)
+            assertEquals(if (code == "DEVICE_TASK_MISMATCH") 2 else 1, heartbeats)
+            assertFalse(result.canClaim)
+        }
+    }
+
+    @Test fun `network failure leaves pending even if heartbeat succeeds`() {
+        var pending = true
+        val result = AgentSyncCycle({ online }, { 42 }, { false }, {}, { throw java.io.IOException("network") }, { pending }).run()
+        assertTrue(pending)
+        assertEquals(online, result.heartbeat)
+        assertFalse(result.canClaim)
+    }
+
+    @Test fun `active execution sends heartbeat without recovery or flush`() {
+        val result = AgentSyncCycle({ online }, { 42 }, { true }, { fail("recover") }, { fail("flush") }, { false }).run()
+        assertEquals(online, result.heartbeat)
+        assertFalse(result.canClaim)
+    }
+
+    @Test fun `retained irreversible local task prevents claim even without outbox`() {
+        val result = AgentSyncCycle({ online }, { 42 }, { false }, {}, {}, { false }).run()
+        assertFalse(result.canClaim)
+    }
+
+    @Test fun `authentication failure during recovery or flush stops round without heartbeat retry`() {
+        for (duringRecovery in listOf(true, false)) {
+            var heartbeats = 0
+            var flushes = 0
+            val result = AgentSyncCycle({ heartbeats++; throw api(409,"DEVICE_TASK_MISMATCH") }, { 42 }, { false },
+                { if (duringRecovery) throw api(401,"OTHER") },
+                { flushes++; throw api(403,"OTHER") }, { true }).run()
+            assertEquals(1, heartbeats)
+            assertEquals(if (duringRecovery) 0 else 1, flushes)
+            assertEquals("AUTH_ERROR", result.failureCode)
+            assertFalse(result.canClaim)
+        }
+    }
+
+    @Test fun `server failure is classified separately from transport failure`() {
+        val result = AgentSyncCycle({ throw api(503,"UNAVAILABLE") }, { null }, { false }, {}, {}, { false }).run()
+        assertEquals("SERVER_ERROR", result.failureCode)
+    }
+
+    @Test fun `claim failure cannot erase successful heartbeat except authentication`() {
+        assertNull(syncConnectionFailureCode(api(409,"PURCHASE_STATE_CONFLICT"), true))
+        assertNull(syncConnectionFailureCode(IllegalStateException("disk"), true))
+        assertNull(syncConnectionFailureCode(api(503,"INTERNAL"), true))
+        assertEquals("AUTH_ERROR", syncConnectionFailureCode(api(401,"OTHER"), true))
+    }
+}

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

@@ -0,0 +1,147 @@
+package cn.ilapage.goauto.agent.service
+
+import cn.ilapage.goauto.agent.automation.PddLaunchEvent
+import cn.ilapage.goauto.agent.automation.PddLaunchFallback
+import cn.ilapage.goauto.agent.automation.PddLaunchPath
+import cn.ilapage.goauto.agent.automation.PddLaunchStatus
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class PddManualOpenTest {
+    private class Harness(
+        val busy: String? = null,
+        val direct: () -> Boolean = { true },
+        val browser: () -> Boolean = { true },
+    ) {
+        val calls = mutableListOf<String>()
+        var preferDirect: Boolean? = null
+        val coordinator = PddManualOpenCoordinator(
+            busyReason = { calls += "busy"; busy },
+            invalidateHandoff = { calls += "invalidate" },
+            launch = { _, prefer, diagnostic ->
+                calls += "launch"
+                preferDirect = prefer
+                PddLaunchFallback.open(prefer, direct = { calls += "direct"; direct() },
+                    browser = { calls += "browser"; browser() }, diagnostic = diagnostic)
+            },
+        )
+    }
+
+    @Test fun linkUsesGoodsIdOnly() {
+        assertEquals("https://mobile.yangkeduo.com/goods.html?goods_id=825093359197", PddManualOpenCoordinator.link("825093359197"))
+    }
+
+    @Test fun linkRejectsBlankOrNonDigitGoodsId() {
+        listOf(null, "", " ", "12a", "1 2", "12&x=1", "-1", "１２３").forEach { assertNull(it, PddManualOpenCoordinator.link(it)) }
+    }
+
+    @Test fun invalidGoodsIdNeitherChecksBusyNorInvalidatesNorOpens() {
+        val h = Harness()
+        assertEquals(PddManualOpenResult.InvalidGoodsId, h.coordinator.run("abc", purchase = false))
+        assertTrue(h.calls.isEmpty())
+    }
+
+    @Test fun collectionButtonOnlyUsesBrowser() {
+        val h = Harness(direct = { error("unexpected") })
+        assertEquals(PddManualOpenResult.Opened(null), h.coordinator.run("1", purchase = false))
+        assertEquals(false, h.preferDirect)
+        assertFalse(h.calls.contains("direct"))
+        assertTrue(h.calls.contains("browser"))
+    }
+
+    @Test fun purchaseButtonPrefersDirectAndStopsWhenAccepted() {
+        val h = Harness(browser = { error("unexpected") })
+        assertEquals(PddManualOpenResult.Opened(null), h.coordinator.run("1", purchase = true))
+        assertEquals(true, h.preferDirect)
+        assertFalse(h.calls.contains("browser"))
+    }
+
+    @Test fun purchaseDirectExceptionFallsBackToBrowserWithSimpleClassName() {
+        val h = Harness(direct = { throw SecurityException("secret url and address") })
+        val result = h.coordinator.run("1", purchase = true)
+        assertEquals(PddManualOpenResult.Opened("拼多多直接打开失败，已改用浏览器（SecurityException）"), result)
+        val text = PddManualOpenCoordinator.message(result)
+        assertFalse(text.contains("secret"))
+        assertFalse(text.contains("http"))
+        assertTrue(text.endsWith(PddManualOpenCoordinator.OPENED_HINT))
+    }
+
+    @Test fun purchaseDirectRejectedFallbackNoticeOmitsParenthesesWithoutClass() {
+        val h = Harness(direct = { false })
+        assertEquals(PddManualOpenResult.Opened("拼多多直接打开失败，已改用浏览器"), h.coordinator.run("1", purchase = true))
+    }
+
+    @Test fun allPathsFailingReportsOpenFailure() {
+        val h = Harness(direct = { throw IllegalStateException("x") }, browser = { false })
+        val result = h.coordinator.run("1", purchase = true)
+        assertEquals(PddManualOpenResult.Failed, result)
+        assertEquals("无法打开拼多多链接", PddManualOpenCoordinator.message(result))
+    }
+
+    @Test fun fallbackNoticeNeedsAcceptedBrowser() {
+        val events = listOf(
+            PddLaunchEvent(PddLaunchPath.DIRECT, PddLaunchStatus.EXCEPTION, "java.lang.SecurityException"),
+            PddLaunchEvent(PddLaunchPath.BROWSER, PddLaunchStatus.REJECTED),
+        )
+        assertNull(PddManualOpenCoordinator.fallbackNotice(events))
+    }
+
+    @Test fun busyAtClickTimeDoesNotInvalidateOrOpen() {
+        val h = Harness(busy = DeviceBusyPolicy.TASK)
+        val result = h.coordinator.run("1", purchase = true)
+        assertEquals(PddManualOpenResult.Busy("设备正在执行任务"), result)
+        assertEquals(listOf("busy"), h.calls)
+        assertEquals("设备正在执行任务，暂不能打开拼多多", PddManualOpenCoordinator.message(result))
+    }
+
+    @Test fun handoffIsInvalidatedBeforeAnyLaunch() {
+        val h = Harness()
+        h.coordinator.run("1", purchase = true)
+        assertEquals(listOf("busy", "invalidate", "launch", "direct"), h.calls)
+    }
+
+    @Test fun handoffIsInvalidatedEvenWhenOpeningFails() {
+        val h = Harness(direct = { false }, browser = { false })
+        h.coordinator.run("1", purchase = true)
+        assertTrue(h.calls.indexOf("invalidate") in 0 until h.calls.indexOf("launch"))
+    }
+
+    @Test fun idleInputsAreNotBusy() {
+        assertNull(DeviceBusyPolicy.reason(DeviceBusyPolicy.Inputs()))
+    }
+
+    @Test fun runningTaskIsBusy() {
+        assertEquals("设备正在执行任务", DeviceBusyPolicy.reason(DeviceBusyPolicy.Inputs(taskActive = true)))
+    }
+
+    @Test fun repurchaseRoundIsBusyIncludingBetweenTasks() {
+        // Between two tasks every task input is false but the round is still busy.
+        assertEquals("重购进行中", DeviceBusyPolicy.reason(DeviceBusyPolicy.Inputs(repurchaseBusy = true)))
+    }
+
+    @Test fun backfillIsBusy() {
+        assertEquals("订单回填中", DeviceBusyPolicy.reason(DeviceBusyPolicy.Inputs(backfillRunning = true)))
+    }
+
+    @Test fun currentPageCollectionIsBusy() {
+        assertEquals("当前页采集进行中", DeviceBusyPolicy.reason(DeviceBusyPolicy.Inputs(currentPageCollecting = true, taskActive = true)))
+    }
+
+    @Test fun unuploadedOrRecoverablePurchaseIsBusy() {
+        assertEquals("有未上传的采购结果", DeviceBusyPolicy.reason(DeviceBusyPolicy.Inputs(unuploadedPurchase = true)))
+    }
+
+    @Test fun repurchaseLocalIdleViewIgnoresOwnRoundButKeepsOtherWork() {
+        // The service builds the repurchase-idle inputs with repurchaseBusy=false: the round never blocks itself.
+        assertNull(DeviceBusyPolicy.reason(DeviceBusyPolicy.Inputs(repurchaseBusy = false)))
+        assertEquals("订单回填中", DeviceBusyPolicy.reason(DeviceBusyPolicy.Inputs(repurchaseBusy = false, backfillRunning = true)))
+    }
+
+    @Test fun collectionCooldownIsNotAnInput() {
+        // A cooldown only blocks claiming new collection work; it leaves every busy input false.
+        assertTrue(DeviceBusyPolicy.Inputs::class.java.declaredFields.none { it.name.contains("cooldown", ignoreCase = true) })
+    }
+}

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

@@ -0,0 +1,59 @@
+package cn.ilapage.goauto.agent.service
+
+import org.junit.Assert.*
+import org.junit.Test
+
+class PurchaseRuntimeReconciliationTest {
+    @Test fun `manual current page cannot enter while sync owns recovery and flush`() {
+        val mutex = TaskExecutionMutex()
+        val syncing = java.util.concurrent.atomic.AtomicBoolean(false)
+        val syncEntered = java.util.concurrent.CountDownLatch(1)
+        val finishSync = java.util.concurrent.CountDownLatch(1)
+        val worker = java.util.concurrent.Executors.newSingleThreadExecutor()
+        val future = worker.submit {
+            synchronized(mutex) { assertTrue(syncing.compareAndSet(false, true)) }
+            syncEntered.countDown()
+            check(finishSync.await(3, java.util.concurrent.TimeUnit.SECONDS))
+            syncing.set(false)
+        }
+        try {
+            assertTrue(syncEntered.await(3, java.util.concurrent.TimeUnit.SECONDS))
+            assertFalse(tryAcquireCurrentPage(mutex, syncing, Long.MAX_VALUE))
+            assertNull(mutex.currentTaskId())
+            finishSync.countDown()
+            future.get(3, java.util.concurrent.TimeUnit.SECONDS)
+            assertTrue(tryAcquireCurrentPage(mutex, syncing, Long.MAX_VALUE))
+        } finally { finishSync.countDown(); worker.shutdownNow() }
+    }
+
+    @Test fun `reboot restored rejected task clears runtime so repurchase becomes idle`() {
+        var runtimeTaskId: Long? = 42
+        val currentDatabaseAttemptRejected = true
+        if (shouldClearRejectedPurchase(42, runtimeTaskId, "purchase", null, currentDatabaseAttemptRejected)) runtimeTaskId = null
+        assertNull(runtimeTaskId)
+        assertTrue(runtimeTaskId == null) // final runtime predicate in repurchaseLocalIdle
+    }
+
+    @Test fun `another task collection active executor or newer attempt cannot be cleared`() {
+        assertFalse(shouldClearRejectedPurchase(42, 43, "purchase", null, true))
+        assertFalse(shouldClearRejectedPurchase(42, 42, "collection", null, true))
+        assertFalse(shouldClearRejectedPurchase(42, 42, "purchase", 42, true))
+        assertFalse(shouldClearRejectedPurchase(42, 42, "purchase", 43, true))
+        assertFalse(shouldClearRejectedPurchase(42, 42, "purchase", null, false))
+    }
+
+    @Test fun `stopped service remains stopped after an in flight heartbeat completes`() {
+        val gate = AgentStatePublicationGate()
+        var connection = "CONNECTING"
+        gate.publish { connection = "ONLINE" }
+        assertEquals("ONLINE", connection)
+        gate.stop { connection = "STOPPED" }
+        gate.publish { connection = "ONLINE" }
+        assertEquals("STOPPED", connection)
+        val restartedService = AgentStatePublicationGate()
+        restartedService.publish { connection = "CONNECTING" }
+        assertEquals("CONNECTING", connection)
+        gate.publish { connection = "ONLINE" }
+        assertEquals("CONNECTING", connection)
+    }
+}

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

@@ -2,8 +2,8 @@
 generated: true (请先修改 Gitea Wiki，禁止直接编辑本文件)
 wiki_page: Architecture-and-Code-Map
 wiki_url: https://git.ilapage.cn/OPC/goauto/wiki/Architecture-and-Code-Map.-
-wiki_revision: 76854d900b2372ddedd46a2b82b5677d8bf5cb31
-synchronized_at: 2026-10-09T07:45:10Z
+wiki_revision: 5508fe99e1040dff61d3bc6dbdf08ce0a1fd02ad
+synchronized_at: 2026-10-10T03:10:31Z
 <!-- gitea-wiki-mirror:end -->
 
 <!-- gitea-wiki-mirror:start -->
@@ -673,3 +673,28 @@ Web 唯一展示位置为“采集采购 → SYB 同步记录”：列表状态
 - `PddProductDetailCollector.collectColors` 只基于既有解析帧记录颜色阶段 UP 派发次数、空发现轮次和横向探索三态；不增加抓取、手势或等待。标签及签名只在内存使用，持久化仍为安全聚合。
 - 不新增 Server/Web API 字段、服务端迁移或权限；普通结果 payload/missing 与采购探测失败策略未改变。完整遍历与不完整候选拦截仍属 #370 后续待证据实施范围，不能把本地诊断值作为已实现的业务门禁。
 - 读取与三态限制见 Troubleshooting；旧版不保证降级打开 v5。JDBC 测试与实际 Android 安装升级分别验收，测试不代替真实竖向颜色采集验证。
+
+## Admin 列表按当前筛选导出全部页（#372，待验收）
+
+实现绑定 `a4a793f`（分支 `feat/372-list-export`，未合并、未发布）。
+
+- 采购管理与 SYB 商品页各增「导出」按钮：`web/src/utils/list-export.js` 先按当前筛选读第 1 页取总数，超过 5000 条不导出，否则逐页读取（采购每页 100、SYB 每页 500）再用 `web/src/vendor/Export2Excel.js`（经 `utils/save-excel.js` 按需加载）生成 xlsx；任一页或批次失败不生成文件；筛选条件以点击时复制的参数为准。无服务端导出接口、无异步导出任务。
+- `GET /api/admin/v1/purchase-tasks` 的 `AdminListRequest`（`server/app/goauto/purchase/admin_query.go`）新增可选 `orderSubmittedFrom` / `orderSubmittedTo`（`YYYY-MM-DD`，含首尾两天，按 `order_submitted_at`，UTC+8 与 SYB 创建时间筛选一致）；格式错误或起止倒置返回 `INVALID_REQUEST`；无下单时间的任务在设置该筛选时不出现。采购页筛选栏用日期范围选择器。
+- `GET /api/admin/v1/return-matches` 的 `returnmatch.ListItem` 新增只读 `yeekeQuantity`（`server/app/goauto/returnmatch/service.go`，来自既有 `yeeke_return_item` join，不参与匹配）；该接口原本就支持一次传多个 `sybProductId`，SYB 导出按每批 200 个商品 ID 调用，不逐行请求，且只采用 `matched`/`confirmed` 的匹配。
+- 无数据库迁移、无新接口、无新权限；导出按钮不单独鉴权，能打开列表的用户（含采购员）都可导出。
+
+## 设备心跳诊断与逐设备离线事务（#378，实现基线）
+
+Server 实现绑定 `d84728d`，Android 绑定 `dbe7e98`，分支 `feat/378-heartbeat-diagnostics`；main 合并记录见 #378；未执行线上迁移、发布或装机。以下是分支实现，不代表线上或现有手机已经更新。
+
+- `server/app/goauto/device/heartbeat.go`：成功且非 requestId 重放的心跳在核心事务提交后、HTTP 返回前尽力保存历史；设备 offline→online、超时离线和已有停用入口在状态变化事务内保存事件。没有新增启用入口，身份恢复/重新注册不补造配对事件。
+- `device/diagnostics.go`：严格校验报告、独立 200ms 写历史 context、按生命周期运行清理；历史失败不改变在线判断。清理与每 15 秒离线扫描分离。
+- `agent_heartbeat_log` 保存 device_id、received_at、request_id、上报/服务端任务 ID、busy、agent_version、校验后的报告 JSON 和状态。索引 `ix_heartbeat_device_received(device_id,received_at)`、`ix_heartbeat_received(received_at)`。
+- `agent_device_status_event` 保存 device_id、occurred_at、from_status/to_status、固定 reason、last_heartbeat_at、failed_task_count、order_result_unknown_count；索引 `ix_device_event_occurred(occurred_at)`。失败与订单结果未知分别计数。
+- 离线候选列表在事务外读取；每台设备单独事务，设备主键及相关任务 NOWAIT 锁定当前读，复核心跳和状态后使用已经锁定的任务 ID/状态更新任务与 attempt、设备和事件。禁止用跨设备旧快照重选任务。
+- MySQL 3572 只回滚并跳过当前设备，下一轮再试；不持有前面设备的锁等待后面设备，不本轮循环重试。其他错误保留错误语义及此前真实提交计数。事件日志只在提交后输出；没有全系统锁顺序重构。
+
+- Android `AgentForegroundService` 在实际同步开始时创建记录，包装注册、心跳、恢复、补传与领任务；`SyncDiagnosticRecorder` 保存步骤序号、单调时钟起止偏移与总耗时。恢复函数内部已处理的非认证 API 错误也被观察，原业务吞错、占位与后续流程不变。
+- `SyncDiagnosticStore` 在 `goauto_diagnostics.db` v6 追加 `sync_round`，并以单行 `sync_meta` 保存跨清理、重启的递增序号。既有采集诊断、三个采购失败快照表及其保留策略不变。同步表每轮尽力清理到最近24小时且最多6000轮。
+- `HeartbeatReportNegotiation` 由服务实例持有，不因每轮重建 `AgentApiClient` 而丢失协商状态；只确认实际发出的已完成报告边界。HTTP请求阶段由 `AgentApiClient.request` 标注，不依靠异常消息区分连接/响应超时。
+- 当前任务上下文只采用实际可核验的设备/任务ID、attempt UUID及固定phase；采集和采购即使数字ID相同也不复用旧采购上下文。foreground表示Android前台服务已启动，不表示Agent Activity当前占据屏幕。

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: f8bb75d1fc0b5e8822186c740ac2034fbd562057
-synchronized_at: 2026-10-09T09:25:31Z
+wiki_revision: 01132608beefbecb40b62284482e3b73822fcc87
+synchronized_at: 2026-10-12T08:31:15Z
 <!-- gitea-wiki-mirror:end -->
 
 <!-- gitea-wiki-mirror:start -->
@@ -220,6 +220,7 @@ Admin 的「创建时间」范围按 SYB 货运单列表的 `t_stock.created`（
 - 采购规则的 `probeSpecs.dimensionAliases` 是只读规格维度标题的服务端下发事实源；颜色别名可由管理员增加“组合”等 PDD 页面文案，尺码别名单独维护。该字段只影响探测和 AI 匹配输入，不能改变 `selectSpec` 的精确点击目标；旧任务快照缺省时才使用 Agent 内置兼容值。
 - PDD 采集规则的 `collector.textAliases` 是规格面板、维度标题、选择摘要、评价入口、售罄主商品证据和购买入口等只读识别文案的服务端下发事实源；缺省字段只为旧快照兼容使用 Agent 内置默认值。颜色/尺码分类不得再用代码字面量扩大 `dimensionAliases`。订单和支付文字可以参与只读页面判定，但 Agent 内不可配置的创建订单/确认订单/支付/付款点击拒绝清单始终优先，规则不能放宽；修改地址和收货地址在只读及点击字段中都禁止。
 - PDD 颜色采集对首屏已识别为多行或网格的颜色区执行动态行发现：每次动作后重新解析全部可见行，单列不做无效横向滑动，并复用规则中的 `specVerticalSwipes` 与 `stableEdgeReads` 有界纵向翻页；颜色结束后规格面板归顶，再进入尺码发现。选项重排或已选项从无障碍节点消失时，不得静默跳过仍未尝试的可用颜色。
+- #370 第 2 阶段（合并 main `26562fc`，2026-10-12；测试机回归通过，采购机未装机）：横向颜色网格每次横滑后按颜色文字与位置逐帧重新定位同一行；多行共用一个横滑容器时用选项位置签名判断网格是否移动，且只有确认起点已在最左端时才跳过逐行蛇形反扫；横滑后固定等待 1.2 秒再读取；滑回最左端使用独立额度（`specHorizontalSwipes` × 2），锚点暂时丢失的重试不计入次数但有连续与累计上限。异常终止保留最早原因，仍不得静默跳过未尝试的可用颜色。只改 Android Agent 采集遍历，不改 Admin 图搜、自动关联和服务端。
 - 正式采购规则可以调用独立审核的改地址、创建待付款订单和只读核单动作；采集规则和演练规则不能调用。真机首次安装或验证仍需独立人工授权。
 - 系统当前不提供自动支付、实时屏幕或管理端远程控制。付款、免密支付及任何等价动作不能配置为点击目标；只读识别字段可以包含支付或订单文字。后续若新增支付能力，必须由独立工单和显式控制重新评估。
 
@@ -933,3 +934,61 @@ Android 0.9.64 / versionCode 77，源码 `6550b9f`（分支实现，尚未安装
 - 不新增分享、OCR/VLM、滑动取证、自动重新选规格或付款；合成测试与 APK 构建不代表真实订单验证。安装、真实采购、合并和发布须按相应授权执行。
 
 验证：19 个相关套件共418项通过，0失败/错误/跳过；Debug APK与release单测源码编译通过。执行器测试模拟提交边界回调，并验证本地JSON序列化；未执行真实SQLite/服务端边界端到端或真实采购验证。不宣称全量Android测试通过（既有图搜返回忙循环用例不在本次回归范围）。
+
+## Android 采购结果明确拒收恢复（#377）
+
+实现位于工单分支 fix/377-rejected-purchase-outbox（实现提交 8b75a95，运行占位与互斥补齐 309dce3）；仅 Android，未合并 main、未安装或发布，真机恢复尚待独立授权验证。
+
+- 每轮先发心跳，再在无任务执行锁时恢复中断任务及补传。心跳任务不一致不能挡住拒收收敛；收尾后只额外重发一次心跳。认证错误停止补传，只有最终心跳成功、没有未完成本地任务/待上传结果且收尾正常才领取新任务。不放宽服务端任务身份校验，不修改心跳间隔或离线阈值。
+- 只有 HTTP 409 且错误码精确属于 PURCHASE_STATE_CONFLICT、PURCHASE_LEASE_EXPIRED、PURCHASE_RESULT_CONFLICT 才视为明确拒收。未知 409、网络异常、5xx 及认证错误不按拒收处理；缺少 retryable 不构成拒收证据。
+- 本地拒收使用 rejected，不伪装 sent。按 outbox 与 task/attempt 归属事务保存，保留原 payload；不再自动补传该条，继续处理后续结果。拒收不触发上传成功或规格探测交接，交接凭证失效。拒收记录不再充当待上传占位；不改变服务端采购结果和原重购停止边界。
+- order_created、order_result_unknown 或带订单号的拒收结果在采购页持续提示人工核对。“已核对”只持久隐藏提醒，不删除结果、不调用服务端、不允许再次下单；非订单拒收仍可在设置及任务详情查看。
+- goauto_purchase.db v2→v3 只追加拒收时间、白名单错误码及人工核对时间三个可空列，旧结果与记录保持不变；v1 升级仍经过原 v2 追加列。旧版 SQLiteOpenHelper 不保证能打开 v3，不能靠卸载清数据回退，优先使用保留 v3 schema 的修复版本。
+- 设置页区分同步中、真实心跳失败、已连接但有拒收；新说明采用固定文案，不展示任意服务端错误消息。本单只修复明确拒收后的持续阻塞，不代表最初心跳中断的原因已查明，历史诊断仍属于 #378。
+
+- 拒收后只在执行锁空闲、当前运行标记属于同一采购任务且本地当前 attempt 已拒收时清理恢复占位，不清除其他采集/采购或新 attempt；手动当前页采集与同步共用既有 working/任务锁门禁。服务停止写 STOPPED，原服务实例的迟到状态更新不覆盖它。
+
+## Admin 列表导出 Excel（#372，待验收）
+
+实现绑定 `a4a793f`，分支 `feat/372-list-export`，未合并、未发布。
+
+- 范围：采购管理和 SYB 商品页的「导出」导出**当前筛选条件下的全部页**，不是只导出当前页；筛选以点击导出时的值为准。总数超过 **5000** 条时提示缩小筛选范围并不导出；任一页读取失败不生成文件；无数据提示且不生成文件。分页读取期间数据变化可能有少量重复或遗漏，以导出时刻近似结果为准。
+- 格式：时间 `YYYY-MM-DD HH:mm:ss`（浏览器本地时区）；金额单位元，写成 Excel **数字单元格**（按分换算，例如 1230 分 → 12.3，可直接求和）并显示为 `0.00`；空值留空，0 写成 0；文件名 `采购导出_YYYYMMDD-HHmmss.xlsx`、`SYB商品导出_YYYYMMDD-HHmmss.xlsx`。不导出收货人、地址、账号等个人信息。
+- 采购导出列（按顺序）：SYB订单号、虾皮商品ID、颜色、尺码（均为 SYB 目标规格快照）、数量、状态（页面同款中文）、PDD单号、下单时间、价格（元）（数字单元格）。价格取 `pddOrderAmountCent / 100`，即 Agent 在 PDD 待付款页读到的应付金额；旧版 Agent 或人工补录前为空则留空。要导出成功采购，先把状态筛为「订单已创建」并按需选择下单日期。
+- 采购管理新增「下单日期」筛选：含首尾两天，按 `order_submitted_at`，日期边界 UTC+8，与 SYB 商品页创建时间筛选一致；没有下单时间的任务在设置该筛选时不出现。
+- SYB 商品导出列（按顺序）：SYB订单、**店铺**、虾皮商品ID、**SYB售价（TWD）**、SYB颜色、SYB尺码、SYB数量、yeeke颜色、yeeke尺码、yeeke数量、匹配时间。店铺取商品行 `shopName`（SYB 订单的店铺，与页面「店铺」列同值，文本单元格，无值留空，不使用店铺筛选下拉的显示名）；yeeke 颜色/尺码来自该商品有效（`matched` 或 `confirmed`）退货匹配的 `variationName`，按第一个英文或中文逗号拆分，没有逗号时整段放 yeeke 颜色；yeeke 数量为对应退货商品数量；SYB售价（TWD）取商品行 `unitPriceCent / 100`，与页面「售价」列同源（SYB `detail/listByStock` 的 `productPrice`，单件成交单价，元/TWD），数字单元格，无值留空；没有有效匹配时 yeeke 列与匹配时间留空。要导出已用退货，先把处理阶段筛为「已用退货」。
+- 权限：不新增按钮权限，能打开列表的用户（含采购员）都可导出。
+
+## 设备离线诊断的事务边界（#378，实现基线）
+
+Server实现 `d84728d`、Android实现 `dbe7e98`，main 合并记录见 #378；未发布或装机；本节不代表线上/手机行为已经更新。
+
+默认心跳 15 秒、离线阈值 45 秒、离线扫描 15 秒不变。扫描逐设备独立事务：锁定最新设备/任务状态后，将设备离线、相关任务和 attempt 收敛、对应状态事件一起提交。锁争用时本设备不作任何部分修改，跳过后继续其他设备，下轮再检查；不自动重试采购或换机。
+
+运行中采集和未提交订单采购仍转失败；已 `order_submit_started` 的采购仍转 `order_result_unknown`，人工核对、禁止自动重派。两个数量分开记录。诊断历史是尽力保存，不作为设备在线或任务业务状态的事实来源；事件失败回滚当前设备业务变化，其他已提交设备保持不变。
+
+
+Android同步诊断不改变#377的心跳→恢复→补传→必要的一次任务不一致心跳→符合条件才领任务的顺序。诊断failure是本轮观察到的同步错误，不等同于业务任务失败；恢复内部暂缓处理的API错误也记录，但不改变原恢复占位、后续flush/claim规则，不增加采购重试或付款动作。
+
+可恢复诊断存储异常不阻断同步，取消和致命错误不记成假成功。同步记录独立保留24小时/6000轮，不占采集50条额度；旧进行中记录只表示中断/不完整，不伪造原现场、失败原因或成功。报告确认不会清除发送期间新增失败；本地确认失败或响应丢失允许重复，报告不能用于改变设备在线或采购状态。
+
+## 规格规范化同名冲突与徽标说明合并（#379）
+
+合并 main `4039fda`（2026-10-12）；单元测试覆盖，测试机回归通过；采购1（PDD 8.26.0）徽标形态的真机验证待装机时完成。普通采集与采购规格探测共用同一采集器。
+
+- 变更 #160 的同名冲突规则：同一维度内不同原文规范化后同名（同帧或跨帧，例如尾价时有时无）时不再整维作废，只保留一个值（先出现的原文及其价格、图片），在 missing 写 `spec_dimension_conflict:<dimensionKey>`，任务为 `completed_partial`。用户接受「重复或合并规格」的风险，不接受「整组没有尺码/颜色」。
+- 规范化后为空或仍含 `¥/￥` 的值维持整维拒绝，写 `spec_dimension_invalid:<dimensionKey>`，不放宽；服务端规范化防线不变。
+- 尺码续页路径与正常路径一样去掉尾价，冲突检查在去重之前完成。
+- #362 截短卡片合并扩展：说明文字形如「截短名[...|…] ¥金额 徽标」（徽标 1–8 个字符，不含货币符号、数字和空白）时，金额须等于外层完整名的尾价，去掉省略号后须为完整名的严格前缀，并满足 #362 全部结构条件，才与外层卡片合并；任一条件不满足行为不变。不维护徽标词表。
+- 残余风险：两个真实不同、规范化后同名、且从未同屏出现的选项会被合并为一个；同屏出现时下单因 `SPEC_TARGET_AMBIGUOUS` 失败，不会任选。
+- 未覆盖：说明文字只有徽标、不带价格（如「…零差评」）时仍可能多出一个截短重复颜色，不导致作废。
+
+## Agent 详情页在拼多多中打开商品（#375）
+
+合并 main `82ed666`（2026-10-12）；测试机真机验证通过，采购机未装机。
+
+- 采集详情与采购详情显示描边按钮「在拼多多中打开」，用任务商品编号拼 `https://mobile.yangkeduo.com/goods.html?goods_id=<编号>`；编号为空或非纯数字时不显示。用途仅为人工查看商品，不复现后台执行过程。
+- 采集按钮沿用采集的浏览器打开方式；采购按钮沿用采购方式先直达 PDD，失败回退浏览器，并提示异常简单类名。人工入口不代点浏览器中的「打开拼多多APP」，不在 PDD 内点击任何控件；提示不含链接和异常消息原文。
+- 打开由 Agent 服务执行：点击时再判断设备是否忙，忙则不打开；不忙时先作废 #373 一次性交接凭证再打开，下一次采购必须重新打开本任务链接。
+- 设备忙：重购一轮进行中（含两个任务之间）、订单回填中、当前页采集进行中、设备正在执行任务（含图搜）、有未上传或待恢复的采购结果；任务结束后的冷却期不算忙。忙时按钮置灰并显示原因，状态约每 2 秒发布，与 `repurchaseLocalIdle` 共用同一判断。
+- 不暂停领任务，不改调度、心跳和租约；查看期间来了新任务由 Agent 接管屏幕，打开后提示「打开期间如有新任务，Agent 会接管屏幕」。不上传打开结果，不写日志或诊断。

docs/06-troubleshooting.md

@@ -2,8 +2,8 @@
 generated: true (请先修改 Gitea Wiki，禁止直接编辑本文件)
 wiki_page: Troubleshooting
 wiki_url: https://git.ilapage.cn/OPC/goauto/wiki/Troubleshooting
-wiki_revision: 6b370764320d1f5148fbc31f0ef6ce999370173d
-synchronized_at: 2026-10-09T02:06:57Z
+wiki_revision: 50f5923623db34cddb9ea152238c11669a25eb95
+synchronized_at: 2026-10-12T08:31:42Z
 <!-- gitea-wiki-mirror:end -->
 
 # 故障排查
@@ -158,3 +158,89 @@ adb -s <serial> shell run-as cn.ilapage.goauto.agent sqlite3 -readonly databases
 ```
 
 排查须绑定同一设备、Agent/PDD 版本、任务与规则快照，并对照同次 App 布局。网页竖排与 App 横排不是同一复现场景；当前横排只能做横向兼容性回归。真机测试结果及待验证项以 #370 工单为准。
+
+## 采购结果拒收后设备持续离线（#377）
+
+修复绑定工单分支 fix/377-rejected-purchase-outbox 的 8b75a95、309dce3；尚未合并 main、安装或发布。自动化覆盖不等于真实设备验收，不能假定线上手机已具备本节恢复行为。
+
+旧版同步在心跳之前补传，一条结果被服务端永久拒收就能让每轮跳过心跳及领任务。离线之后本地仍携带旧任务 ID，又可能被心跳的 DEVICE_TASK_MISMATCH 拒绝；仅把心跳前置不足以恢复。#377 先发心跳，仍进行有界拒收收尾，再在任务不一致时重发一次心跳；认证失败不会继续收尾，执行中的任务不会被恢复流程并发接管。
+
+排查步骤：
+
+1. 核实 APK 对应提交，不仅看版本名（本次未改 versionCode/versionName）。设置页“正在同步”不代表断线；真实心跳网络、服务端或认证失败使用固定原因说明；任务处理错误不再覆盖此前成功的连接状态。
+2. “已连接 · 有 N 条采购结果被服务端拒收”表示本地已有 rejected 结果，不等于服务端接收成功。可在设置页“查看拒收结果”和对应采购详情查看；有订单证据的结果还在采购页顶部持续提醒。
+3. 人工核对 PDD 实际订单及后台任务。需要补录订单时沿用 Admin 原有人工流程；Agent 的“已核对”只隐藏这条本机提醒，不能代替后台保存、恢复回填、解锁重试或完成任务。原结果/订单号与核对时间继续保存。
+4. 未知 409、网络失败或 5xx 保持 pending；如果仍卡住，核对错误分类及原任务状态，不自动把 pending 改成 sent。不反复重试真实采购来试探是否已下单。
+5. 早期现场曾经另获授权，通过同时修改 outbox 与本地任务 upload_status=sent 恢复设备，但这不代表服务端已收件，也会把订单号留在手机。它只是历史应急处置，不是新版运维步骤，不应复制到脚本或作为常规修复。
+
+数据库升级仅限手机私有 goauto_purchase.db：v3 在 purchase_outbox 添加 rejected_at、rejection_error_code、acknowledged_at；保留原始 payload 和任务数据。不得把整库、订单/地址内容上传到工单、Wiki、普通日志或 SynapBus。旧 APK 不保证能够降级打开 v3；回退优先使用保留 v3 的兼容修复构建，不卸载清数据、不擅自降低库版本。
+
+已验证 SQLite JDBC 执行同一生产迁移/拒收/核对 SQL、事务回滚及文件重开；尚未执行 Android SQLiteOpenHelper 仪器测试、真机界面或真实采购。最初心跳和结果同时中断的原因仍未查明，#378 的诊断计划不属于本修复。
+
+## 心跳历史、离线事件与锁争用（#378，实现基线）
+
+Server适用 `d84728d`、Android适用 `dbe7e98`，main 合并记录见 #378；未发布或装机；先确认目标实例/手机确实包含实现并完成对应迁移。旧版本没有下列表，不能直接执行这些查询。
+
+经授权只读排查时用参数化查询指定设备和时间，不输出 Token、任务正文或其他个人数据：
+```sql
+SELECT device_id, received_at, request_id, current_task_id, running_task_id,
+       busy, agent_version, client_report_status
+FROM agent_heartbeat_log
+WHERE device_id = ? AND received_at >= ? AND received_at < ?
+ORDER BY received_at, id;
+
+SELECT device_id, occurred_at, from_status, to_status, reason,
+       last_heartbeat_at, failed_task_count, order_result_unknown_count
+FROM agent_device_status_event
+WHERE device_id = ? AND occurred_at >= ? AND occurred_at < ?
+ORDER BY occurred_at, id;
+```
+
+- 心跳记录相邻间隔超过 45 秒只说明历史有缺口；200ms 历史写入超时或失败也会缺记录，不能单凭此宣称设备离线。
+- 实际离线次数/时长以同设备 timeout/resumed 事件配对为准；仅有一端、跨时间窗、停用或身份恢复造成的不配对单列，不把缺少事件伪造为完整区间。
+- `heartbeat_timeout` 中失败数不包含 `order_result_unknown_count`，后者表示订单已提交后的未知结果，不能自动重下单。
+- 离线扫描遇到 MySQL 3572 只记固定锁争用分类及 deviceId 的 warn；它表示该设备当前被操作占用，未发生离线状态变更，等下一轮扫描。其他设备继续处理。
+- 非 3572 数据库错误仍报告；事件写入失败会回滚该设备的状态与任务，已经成功处理的其他设备不回滚。不得通过删除任务或清空诊断来掩盖错误。
+- 需要核对锁范围时对实际锁定 SQL 做 EXPLAIN；小型测试数据的执行计划不等于线上计划，不未经授权修改生产索引。
+
+
+手机上经授权只读查询 `goauto_diagnostics.db` 的同步表，参数时间为epoch毫秒；不要为心跳排错公开整库，库内其他表可能含敏感失败现场：
+```sql
+SELECT id, process_id, started_at, ended_at, start_gap_ms, duration_ms,
+       device_id, task_id, attempt_id, phase, validated_network, transport,
+       foreground, status, failure_step, failure_category, failure_duration_ms,
+       http_status, api_code, exception_class, steps, completion_seq, reported
+FROM sync_round
+WHERE started_at >= ? AND started_at < ?
+ORDER BY id;
+```
+- started_at/ended_at是墙钟对照；start_gap_ms、duration_ms、steps里的startedOffsetMs/endedOffsetMs来自单调时钟，不用墙钟相减解释耗时。新服务实例不延用上个实例的单调起点。
+- process_id是诊断服务实例的随机标识，不是Android系统PID。
+- running表示诊断没有完整结束，可能是卡住、进程退出、取消或诊断写入失败，不能仅凭它断言崩溃原因。旧实例running在保留期内一直触发hasInterruptedRound，报告确认不会把它改成成功/失败或隐藏。
+- 一轮中观察到步骤失败（包括恢复内部暂缓处理的500/409），诊断可记failure，即使业务随后恢复连接；这不是采集/采购任务失败，也不能据此重下单。已正常收敛的明确拒收仍按#377处理。
+- timeout_connect/timeout_response/timeout_unknown根据请求实际阶段分类，未知阶段不猜。诊断故障只输出sync_diagnostic_persistence_failed或sync_diagnostic_context_failed固定提示；不附错误正文、URL或SQL参数。
+- reported只表示Agent已收到该报告请求的成功响应并在本地确认，不保证Server历史写入成功；响应丢失或确认失败可能重复补报。
+
+## Android 颜色横向网格遍历（#370 第 2 阶段）
+
+实现已合并 main（`26562fc`）。遍历过程只写 `Log.i`（标签 `GoAutoCollector`），不落库、不上报；排查时在已授权的 Debug 设备上实时抓取，用完删除：
+
+```powershell
+adb -s <serial> logcat -v time -s GoAutoCollector:V
+```
+
+- `color-start confirmed= swipes= anchorRetries= end=`：滑回最左端的结果；`confirmed=false` 时不会跳过逐行反扫。
+- `color-row row= dir= match= moved= others= sharedMoves= sharedBroken= uncertain= signatureReads=`：每次横滑后的行定位与是否移动；`others=moved` 表示多行共用一个横滑容器。
+- `color-row-end row= end=`：该行结束原因（如 `edge` 到达边缘）。
+- `color-settle waitedMs=1200`：横滑后的固定等待。
+- `color-click-miss`：点击目标未生效。
+- 漏色时先核对同一设备、Agent/PDD 版本和规则快照，再看 `color-row-end` 是否过早出现或 `color-start` 是否未确认。日志缓冲较小时可能被覆盖，缺少日志不能证明没执行。
+
+## 采购探测报「没有找到可采购的 PDD 颜色或尺码」（#379）
+
+服务端只看规格候选是否为空，不读 missing，该提示可能掩盖「某维度被整维作废」的真实原因：
+
+1. 查同一次探测或采集结果的 missing：有 `spec_dimension_invalid:color|size` 表示该维度被整维清空（规范化后为空或仍含货币符号）；`spec_dimension_conflict:*` 表示同名冲突已保留一个值，维度仍可用。
+2. 已知成因（2026-10-12，采购1 / PDD 8.26.0 / 商品 715527668284）：颜色卡片的截短说明文字在价格后带「零差评」「最多人选择」等徽标，旧版本无法与外层卡片合并，说明值仍含 `¥` 导致颜色整维作废。#379 后满足条件的徽标说明会合并；同一商品在其他设备或 PDD 版本上可能不出现徽标，不能用测试机结果否定。
+3. 实时日志 `spec-normalize dim= outcome= reason= path= pass= sameFrame= onlyTrailingPriceDiff= rawVariants= candidates= badgeCaptionMerged=`：`outcome=invalid_rejected` 对应整维作废，`reason=unsafe_currency|empty`；`outcome=conflict_kept` 对应同名冲突保留；`badgeCaptionMerged` 为本帧合并的徽标卡片数。只含计数和枚举，不含规格原文。每维每类只记录首次。
+4. 若需看规格面板原文，只在用户手动打开面板后做一次只读 uiautomator 导出并过滤地址、电话，用完立即删除；不得为打开面板点击购买类按钮。

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: 2102252a3f0ecb646b49941cc603423abb76ca2c
-synchronized_at: 2026-10-08T07:11:01Z
+wiki_revision: c05446aecd49fb7234f79f5d5e2df68f244166e9
+synchronized_at: 2026-10-12T08:31:57Z
 <!-- gitea-wiki-mirror:end -->
 
 <!-- gitea-wiki-mirror:start -->
@@ -421,6 +421,7 @@ POST /api/agent/v1/tasks/{taskId}/result
 - size 规格值只允许剥离位于文本尾部的 ¥ / ￥ 数字价格片段，括号说明、体重区间和其他规格身份文本原样保留；Android 与服务端使用相同语义。
 - 服务端在结果完整性校验前执行规范化。规范化后为空、同维度重复、仍残留货币符号或无法由最小安全规则确定时，整维不接受，并原子丢弃引用该维度的 SKU；color 被拒时同时丢弃 colorPrices。
 - 服务端强制将任务收敛为 completed_partial，并在 missing 增加稳定值 spec_dimension_invalid:<dimensionKey>，例如 spec_dimension_invalid:size。客户端应把它展示为对应规格维度无法安全采集，不得视为完整档案，也不得自行猜测或补齐候选。
+- #379 起 Android 在提交前处理规范化同名冲突：同一维度不同原文规范化后同名时只提交一个值，并在 missing 增加稳定值 `spec_dimension_conflict:<dimensionKey>`（任务为 completed_partial，不新增字段）。它表示该维度可能把规范化后同名的选项合并为一个，维度本身仍可用；残留货币符号或空值仍由 Android 整维清空并写 `spec_dimension_invalid:<dimensionKey>`。服务端只保存该 missing 值、不校验其种类；图搜自动关联白名单仍只含 reviewCount、salesText、shopName。
 - 被拒维度不得以污染值覆盖商品已有档案；历史任务和既有商品数据不自动清洗，须在修复后的 Agent 上重新采集。
 
 ## Android：提交失败
@@ -1530,3 +1531,34 @@ Server追加迁移 `1791400000000_purchase_failure_snapshot.go` 建立purchase_f
 - 有ZIP的新上传只接受相符的非成功执行 attempt；不能向 pending/成功 attempt 新增失败诊断，已有有效载荷重放仍幂等。manifest 与 multipart metadata 语义相同；ZIP拒绝未知条目、重复路径、加密/未知压缩、CRC错误，XML拒绝DTD和处理指令，除限定XML声明。
 - 本地队列绑定 Server Origin 和载荷 fingerprint，切换服务器不向新服务器转交旧ZIP；旧上传响应不删除后来首次恢复ZIP。每60秒维护，网络/408/429/5xx按60秒至1小时退避，410与其他永久4xx停止该队列项。结果Outbox优先，不因设备忙而永久饥饿；上传线程不持有任务互斥、不操作设备。
 - 诊断接口不进入通用请求正文日志；私有SQL记录器不输出manifest/BLOB。管理员摘要不包含窗口和节点内容。默认HTTP例外只沿用既有Agent设置，不新增开关；传输私有原始内容时同样存在明文风险，部署须确认现有传输策略。
+
+## 心跳诊断报告契约（#378，Server/Android 实现基线）
+
+Server绑定 `d84728d`、Android绑定 `dbe7e98`；main 合并记录见 #378；未在线迁移/发布或装机。本节契约已在实现基线并作本地跨端验证，不代表现有手机已经补报。
+
+心跳成功响应追加 `acceptsClientReport: true`；原 requestId 幂等及 currentTaskId 一致性校验不变。请求可以省略 `clientReport`（记录状态 none）；显式 null、非法类型/字段/值只使报告为 client_report_invalid，历史 JSON 为 NULL，不让合法基础心跳失败。主 JSON 非法仍按原错误处理，整个请求上限仍为 64KiB。
+
+报告 JSON 原始片段最多 2048 bytes，必须包含以下 8 个精确 camelCase 键（大小写别名不接受），不允许额外键：
+| 字段 | 约束 |
+|---|---|
+| snapshotSeq | 整数 1..9007199254740991 |
+| failedRounds | 整数 0..1000000 |
+| latestFailureAt | null 或有效非零 RFC3339 时间 |
+| latestFailureStep | null 或 sync/register/heartbeat/recover/flush/claim |
+| latestFailureCategory | null 或 api_auth/api_conflict/api_server/api_other/timeout_connect/timeout_response/timeout_unknown/network/exception |
+| latestFailureDurationMs | null 或整数 0..86400000 |
+| previousSyncDurationMs | null 或整数 0..86400000 |
+| hasInterruptedRound | 非 null 布尔 |
+
+failedRounds 为 0 时四个 latestFailure* 必须全为 null；大于 0 时四个均须有效且非 null。前三个非 nullable 标量为 snapshotSeq、failedRounds、hasInterruptedRound。只存经校验并重新编码的白名单，不存 URL、异常消息、正文或页面内容。无有效正数快照序号时应省略报告。
+
+服务端仅对成功非 requestId 重放的心跳写历史，核心事务提交后使用独立 200ms context，写失败不改变响应；acceptsClientReport 表示协议能力，不是历史持久化保证。
+
+Android 已实现的协商边界：上次成功心跳明确 true 才在下一次携带报告；缺少标志/false、进程重启、地址或认证上下文变化撤销缓存。带报告请求遇旧版明确 HTTP422/INVALID_REQUEST/“请求 JSON 无效”时，可移除报告并沿用 requestId 最多重发一次基础心跳；401/403、任务冲突、网络或5xx不触发此兼容重发。基础回退成功不能确认报告。只确认实际发送快照及之前的本地失败，发送期间新失败保留；丢响应/确认失败允许重复，不代表服务端按 snapshotSeq 去重。
+
+
+Agent在响应设备身份校验通过后才更新协商和确认报告。兼容回退响应不确认报告，也不直接授予补报能力，下轮基础心跳重新协商。HTTP连接/响应超时仍为10秒/15秒，不因诊断改变。
+
+snapshotSeq来自持久递增序号；本地同时捕获“已完成记录”的序号边界，成功响应只确认这条边界以前的失败。当前正在运行的一轮即使在发送期间后来失败，也不会被较早快照清除。hasInterruptedRound表示保留期内是否存在旧服务实例的running记录，确认报告不清除该事实。
+
+诊断数据库打开、写入、读取、确认或清理的可恢复异常只损失诊断证据，正常同步继续；不吞取消或fatal error，不将不完整持久化伪装为成功。报告和本地同步表均不保存异常message、URL、请求/响应正文或PDD页面内容。

docs/13-deployment-and-operations.md

@@ -2,8 +2,8 @@
 generated: true (请先修改 Gitea Wiki，禁止直接编辑本文件)
 wiki_page: Deployment-and-Operations
 wiki_url: https://git.ilapage.cn/OPC/goauto/wiki/Deployment-and-Operations.-
-wiki_revision: 3f69f2e39675752dfd43dc38de41cb7defb74a42
-synchronized_at: 2026-10-09T07:58:00Z
+wiki_revision: d08a0dfbb8356f9cd7212d495e4f11beca59e293
+synchronized_at: 2026-10-10T03:56:35Z
 <!-- gitea-wiki-mirror:end -->
 
 <!-- gitea-wiki-mirror:start -->
@@ -372,3 +372,50 @@ Provider 故障日志只允许记录调用关联 ID、操作类型、耗时、
 - 集成验证25套件478项通过，0失败/错误/跳过；compileReleaseUnitTestKotlin与assembleDebug通过。不是全量单测结论；#374记录的未修改图搜返回测试忙循环未在本次重跑。未进行真机采购。
 - 集成APK位于本机 `D:/OPC/goauto-worktrees/release-373-374/android/app/build/outputs/apk/debug/app-debug.apk`，版本仍为 `0.9.69-373-fix1 / code82`，**已同时包含#374，不能只靠版本文字区分前一#373单独包**。SHA256 `6e2d0e0ed1eb943b3f168bb16d628d2c2bb4ce3b7c7c8b9e567dcdf8259150f8`；apksigner校验通过，沿用原签名证书 `bf86d7465c6092be74ce9c4187eb30c9a7d045c3b91891a547e2598429766dec`。
 - 本次仅合并、验证和推送，未覆盖安装、未执行真实采购/付款、未发布或重启服务；不需要业务库迁移。手机仍使用此前安装版本。后续装机须另行授权，保留原签名及用户数据。
+
+
+## #372 Admin 列表导出发布（2026-10-10）
+
+- 用户授权合并 main 并发布。#372 以 `--no-ff` 合并为 main `72a15f8`（同时包含此前已在 main 的 #377 Android 提交，本次不构建或安装 Android）。合并时 `docs/03` 镜像冲突，选用包含 #377 与 #372 两段的较新导出版本（Business-Rules-and-Glossary@1c57a86），`sync --check` 通过。
+- 发布目录 `/home/goauto/releases/20261010-72a15f8-372`，上一目录 `/home/goauto/releases/20261009-e26743c-integrated` 保留供回滚。自上次发布 `e26743c` 以来 Server/Web 的源码变化只有 #372：采购列表新增可选下单日期参数、`return-matches` 列表新增只读 `yeekeQuantity`、两页导出按钮。没有数据库迁移、权限或菜单变更，未执行 migrate。
+- 切换前复查：采集、采购及 attempt 都没有执行中的任务；有 1 个 pending 采购任务保持原状，没有取消、重置或发起业务。config 从上一发布逐字复制（diff 一致）；static/temp/var 沿用同一真实目录；上一发布的 js/css 哈希资源以不覆盖方式保留，便于已打开页面加载旧分块。发布目录 0755、`www` 用户可读 index 已在切换前确认。
+- Server 为 Linux amd64、CGO_ENABLED=0、go1.26.5 构建，SHA256 `ab3943a1261f438eaad4d4acf006910e8a996cf97afc18a399ad5bee6c8f3a1f`，运行进程二进制一致；Web 入口 index.html SHA256 `c3465960bd6f450d7b0d51994475bfdc126c7b6a47068d92bad9b4ac751d0529`。current 原子切换，goauto.service 重启后 active；Nginx 配置未变，未 reload。
+- 按内容验收：公网 `/` 与 `/login` 返回同一 index（含 `id="app"`，无欢迎页），10 项入口 JS/CSS 200，`/api/v1/health` 200，验证码 code=200；未登录采购列表（带下单日期参数）与 return-matches 业务码 401；服务日志无 panic/fatal/1146/1054。
+- 未验证：登录后采购管理、SYB 商品多页导出，以及采购员账号导出，待业务验收。两台采购手机在发布前（10-09 晚）已离线，与本次发布无关。
+- 回滚：Server/Web 成套把 current 切回 `/home/goauto/releases/20261009-e26743c-integrated` 并重启；无迁移，不需要处理数据库。
+
+
+## #372 v2 导出售价列的纯 Web 发布（2026-10-10）
+
+- 用户授权合并 #372 v2 并更新线上。`feat/372-export-price` 以 `--no-ff` 合并为 main `4ad59bd`；合并后 Web 单元测试 93/93 通过，`build:prod` 通过。与上一发布 `72a15f8` 相比，Server 源码没有变化。
+- 发布目录 `/home/goauto/releases/20261010-4ad59bd-372v2-web`，只替换 dist。goauto-server 从上一发布目录逐字复制（cmp 一致），config 一致，static/temp/var 沿用同一真实目录；上一版 js/css 哈希资源以不覆盖方式保留。index.html SHA256 `83c2dfa845c29073234bbdaaabac0690c46b51d32c85609aaf2743b854915a57`。
+- 已确认 Nginx root 与运行进程 `GOAUTO_WEB_DIST` 都指向 `/home/goauto/current/dist`，所以按 #363 的纯 Web 方式只原子切换 current，不重启 GoAuto 或 Nginx；切换前后进程 PID 4786 不变，服务 active。
+- 按内容验收：`/` 与 `/login` 返回新 index（含 `id="app"`，无欢迎页），10 项入口 JS/CSS 200，导出模块包含新表头「SYB售价（TWD）」，health 200，验证码 code=200，未登录业务接口 401。
+- 未验证：登录后实际导出，以及 Excel 打开后售价与页面一致、能否求和，待业务验收。
+- 回滚：把 current 原子切回 `/home/goauto/releases/20261010-72a15f8-372` 即可，不需要重启或处理数据库。
+
+## 设备心跳诊断迁移与回退（#378，实现基线）
+
+Server实现 `d84728d`、Android实现 `dbe7e98`，main 合并记录见 #378；未执行线上迁移、发布、重启或装机。以下为后续经授权部署时的边界，不是本次线上操作记录。
+
+- 追加迁移 `1791600000000_agent_diagnostics.go` 已注册，新增 `agent_heartbeat_log`、`agent_device_status_event` 及索引；不改业务表结构。本轮并发修正不另加迁移或索引。
+- 本地验证只能使用明确隔离且初始为空的 MySQL 8 库 `goauto_378_test`，凭据由当前进程注入 `GOAUTO_378_TEST_MYSQL_DSN`，执行 `go test ./app/goauto/device -run TestMySQLAgentDiagnostics -count=1 -v`（cwd server）。不得把线上或本地业务库 DSN 用于该测试；测试会创建并清理合成表。
+- 现有迁移框架只有 up；本地删除新诊断表/版本记录后 re-up 的测试不等于存在生产 down 命令。MySQL DDL 隐式提交，不能承诺事务回滚整批 DDL。
+- 常规运行回退停止诊断写入和能力广告，保留表及数据；不自动 DROP 表。删除生产数据或执行迁移仍需单独授权。
+- API 生命周期中独立清理：心跳历史每小时清理严格超过 7 天的数据，状态事件每天清理严格超过30天的数据，每次至多5000条，剩余等下轮；不占离线15秒扫描，不修改Admin定时任务开关。
+- 离线扫描使用 MySQL8 的 NOWAIT，争用只跳过本设备。测试执行计划仅是测试库证据，不代表线上数据分布；不据此擅自新增索引。
+
+- Android诊断库v5→v6仅追加sync_round和单行sync_meta；v1旧库按既有升级链追加，保留原采集及采购失败快照。旧APK的SQLiteOpenHelper不保证能打开v6，回退应使用保留v6结构的修复构建，不卸载/清数据、不自动降库。
+- 本地Android验证（cwd仓库根，JDK17及现有Android SDK）：`./android/gradlew.bat -p android :app:testDebugUnitTest --tests '*HeartbeatReport*Test' --tests '*AgentTransportTimeoutTest' --tests '*SyncDiagnostic*Test' --tests '*HandledRecoveryDiagnosticTest' --tests '*AgentDiagnosticStoreMigrationTest' --tests '*AgentSyncCycleTest' :app:assembleDebug :app:compileReleaseUnitTestKotlin`。发布前还应执行#377受影响的outbox、运行占位、互斥、重购等回归；SQLite JDBC验证不等同于真机升级。
+- Android兼容性测试在`android/build/diagnostics378-client-reports.json`生成纯合成HTTP捕获报告；在server目录将该绝对路径注入`GOAUTO_378_ANDROID_REPORTS`，执行`go test ./app/goauto/device -run TestAndroidGeneratedHeartbeatReports -count=1 -v`，使用真实validator/handler验证三类报告与重放。未设置路径时该项明确skip，不得据此宣称跨端通过；产物不提交Git。
+- 线上迁移、发布、重启、装机仍需单独授权；本地构建/夹具不代表真机或线上30分钟心跳验收。
+
+
+## #372 v3 导出店铺列的纯 Web 发布（2026-10-10）
+
+- 用户授权合并 #372 v3 并部署线上。`feat/372-export-shop` 以 `--no-ff` 合并为 main `3d5e964`；Web 单元测试 93/93 通过，`build:prod` 通过。相对上一线上 Web（`4ad59bd`），Web 只有 v3 的导出改动。
+- **main 已含 #378 的 Server 代码和迁移，本次没有部署**：线上 Server 仍是 `72a15f8` 构建的二进制。#378 的 Server 发布和迁移需另行授权。
+- 发布目录 `/home/goauto/releases/20261010-3d5e964-372v3-web`，只替换 dist。goauto-server 与 config 从上一发布逐字复制（cmp/diff 一致），static/temp/var 沿用原目录，旧 js/css 哈希资源保留。index.html SHA256 `b900a40ec4691f0fb2c3d89e1e20826e7ca3205db311a33c24087767a515979a`。
+- 只原子切换 current，不重启 GoAuto/Nginx；切换前后 PID 4786 不变，服务 active。
+- 按内容验收：`/` 与 `/login` 返回新 index，10 项 JS/CSS 200，线上导出模块的 SYB 表头含「店铺」，health 200，验证码 code=200，未登录业务接口 401。登录后的实际导出待业务验收。
+- 回滚：current 原子切回 `/home/goauto/releases/20261010-4ad59bd-372v2-web`，不需要重启。

server/app/goauto/device/android_client_report_contract_test.go

@@ -0,0 +1,89 @@
+package device
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+)
+
+// Feed reports captured by Android's real HTTP client into the real Server
+// handler. This optional cross-build check uses synthetic test data only.
+func TestAndroidGeneratedHeartbeatReports(t *testing.T) {
+	path := os.Getenv("GOAUTO_378_ANDROID_REPORTS")
+	if path == "" {
+		t.Skip("set GOAUTO_378_ANDROID_REPORTS to the Android test-generated JSON array")
+	}
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var reports []json.RawMessage
+	if err := json.Unmarshal(data, &reports); err != nil {
+		t.Fatal("Android report fixture is not a JSON array")
+	}
+	if len(reports) < 3 {
+		t.Fatal("expected zero-failure, failed and interrupted reports")
+	}
+	db := openTestDatabase(t)
+	service := newTestService(t, db)
+	_, registered := registerHeartbeatDevice(t, service)
+	gin.SetMode(gin.TestMode)
+	router := gin.New()
+	router.POST("/heartbeat", Handler{DB: db}.Heartbeat)
+	var sawZero, sawFailure, sawInterrupted bool
+	for i, raw := range reports {
+		t.Run(fmt.Sprintf("android_report_%d", i), func(t *testing.T) {
+			canonical, status := validateHeartbeatClientReport(raw)
+			if status != "accepted" || canonical == nil {
+				t.Fatalf("Android-generated report rejected: classification=%s", status)
+			}
+			var report heartbeatClientReport
+			if err := json.Unmarshal(raw, &report); err != nil {
+				t.Fatal("report decode failed")
+			}
+			sawZero = sawZero || report.FailedRounds == 0
+			sawFailure = sawFailure || report.FailedRounds > 0
+			sawInterrupted = sawInterrupted || report.HasInterruptedRound
+			id := uuid.NewString()
+			body := fmt.Sprintf(`{"requestId":%q,"currentTaskId":null,"clientReport":%s}`, id, raw)
+			for replay := 0; replay < 2; replay++ {
+				req := httptest.NewRequest(http.MethodPost, "/heartbeat", strings.NewReader(body))
+				req.Header.Set("Authorization", "Bearer "+testDeviceToken)
+				res := httptest.NewRecorder()
+				router.ServeHTTP(res, req)
+				if res.Code != http.StatusOK {
+					t.Fatalf("heartbeat status=%d", res.Code)
+				}
+				var response struct {
+					Data struct {
+						AcceptsClientReport bool `json:"acceptsClientReport"`
+					} `json:"data"`
+				}
+				if json.Unmarshal(res.Body.Bytes(), &response) != nil || !response.Data.AcceptsClientReport {
+					t.Fatal("successful response did not advertise report capability")
+				}
+			}
+			var rows []struct {
+				DeviceID           uint64
+				ClientReportStatus string
+				ClientReportJSON   *string
+			}
+			if err := db.Table("agent_heartbeat_log").Where("request_id = ?", id).Find(&rows).Error; err != nil {
+				t.Fatal(err)
+			}
+			if len(rows) != 1 || rows[0].DeviceID != registered.DeviceID || rows[0].ClientReportStatus != "accepted" || rows[0].ClientReportJSON == nil || *rows[0].ClientReportJSON != *canonical {
+				t.Fatal("accepted Android report was not stored once with the correct device and canonical payload")
+			}
+		})
+	}
+	if !sawZero || !sawFailure || !sawInterrupted {
+		t.Fatal("fixture must cover zero-failure, failed and interrupted reports")
+	}
+}

server/app/goauto/device/diagnostics.go

@@ -0,0 +1,165 @@
+package device
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"time"
+
+	"go-admin/app/goauto/models"
+
+	log "github.com/go-admin-team/go-admin-core/logger"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+)
+
+const heartbeatHistoryBudget = 200 * time.Millisecond
+
+type heartbeatClientReport struct {
+	SnapshotSeq             int64      `json:"snapshotSeq"`
+	FailedRounds            int64      `json:"failedRounds"`
+	LatestFailureAt         *time.Time `json:"latestFailureAt"`
+	LatestFailureStep       *string    `json:"latestFailureStep"`
+	LatestFailureCategory   *string    `json:"latestFailureCategory"`
+	LatestFailureDurationMs *int64     `json:"latestFailureDurationMs"`
+	PreviousSyncDurationMs  *int64     `json:"previousSyncDurationMs"`
+	HasInterruptedRound     bool       `json:"hasInterruptedRound"`
+}
+
+func validateHeartbeatClientReport(raw json.RawMessage) (*string, string) {
+	if len(raw) == 0 {
+		return nil, "none"
+	}
+	invalid := func() (*string, string) { return nil, "client_report_invalid" }
+	if len(raw) > 2048 {
+		return invalid()
+	}
+	var fields map[string]json.RawMessage
+	if json.Unmarshal(raw, &fields) != nil || len(fields) != 8 {
+		return invalid()
+	}
+	// encoding/json matches struct keys case-insensitively. Require every
+	// exact contract key before decoding so aliases cannot hide a missing key.
+	for _, name := range []string{"snapshotSeq", "failedRounds", "latestFailureAt", "latestFailureStep", "latestFailureCategory", "latestFailureDurationMs", "previousSyncDurationMs", "hasInterruptedRound"} {
+		if _, ok := fields[name]; !ok {
+			return invalid()
+		}
+	}
+	for _, name := range []string{"snapshotSeq", "failedRounds", "hasInterruptedRound"} {
+		if v, ok := fields[name]; !ok || bytes.Equal(bytes.TrimSpace(v), []byte("null")) {
+			return invalid()
+		}
+	}
+	var report heartbeatClientReport
+	decoder := json.NewDecoder(bytes.NewReader(raw))
+	decoder.DisallowUnknownFields()
+	if decoder.Decode(&report) != nil || report.SnapshotSeq < 1 || report.SnapshotSeq > 9007199254740991 || report.FailedRounds < 0 || report.FailedRounds > 1000000 {
+		return invalid()
+	}
+	for _, v := range []*int64{report.LatestFailureDurationMs, report.PreviousSyncDurationMs} {
+		if v != nil && (*v < 0 || *v > 86400000) {
+			return invalid()
+		}
+	}
+	if report.FailedRounds == 0 {
+		if report.LatestFailureAt != nil || report.LatestFailureStep != nil || report.LatestFailureCategory != nil || report.LatestFailureDurationMs != nil {
+			return invalid()
+		}
+	} else {
+		if report.LatestFailureAt == nil || report.LatestFailureAt.IsZero() || report.LatestFailureStep == nil || report.LatestFailureCategory == nil || report.LatestFailureDurationMs == nil {
+			return invalid()
+		}
+		if !oneOf(*report.LatestFailureStep, "sync", "register", "heartbeat", "recover", "flush", "claim") || !oneOf(*report.LatestFailureCategory, "api_auth", "api_conflict", "api_server", "api_other", "timeout_connect", "timeout_response", "timeout_unknown", "network", "exception") {
+			return invalid()
+		}
+	}
+	canonical, _ := json.Marshal(report)
+	value := string(canonical)
+	return &value, "accepted"
+}
+func oneOf(value string, allowed ...string) bool {
+	for _, v := range allowed {
+		if value == v {
+			return true
+		}
+	}
+	return false
+}
+
+func (s *Service) saveHeartbeatHistory(ctx context.Context, row models.AgentHeartbeatLog) {
+	// Client cancellation after the core commit must not suppress history. There
+	// is deliberately no goroutine: the caller waits at most this DB deadline.
+	writeCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), heartbeatHistoryBudget)
+	defer cancel()
+	err := s.DB.WithContext(writeCtx).Session(&gorm.Session{Logger: logger.Default.LogMode(logger.Silent), SkipDefaultTransaction: true}).Create(&row).Error
+	if err != nil {
+		classification := "database_error"
+		if errors.Is(err, context.DeadlineExceeded) || writeCtx.Err() != nil {
+			classification = "deadline_exceeded"
+		}
+		log.Warnf("agent heartbeat history skipped: device_id=%d classification=%s", row.DeviceID, classification)
+	}
+}
+
+func insertDeviceStatusEvent(tx *gorm.DB, event *models.AgentDeviceStatusEvent) error {
+	// Never issue a diagnostic SELECT or log the SQL error/body.
+	if err := tx.Session(&gorm.Session{Logger: logger.Default.LogMode(logger.Silent)}).Create(event).Error; err != nil {
+		return internalError(errors.New("device status event write failed"))
+	}
+	return nil
+}
+func logDeviceStatusEvent(event models.AgentDeviceStatusEvent) {
+	log.Infof("agent device status changed: device_id=%d reason=%s failed_task_count=%d order_result_unknown_count=%d", event.DeviceID, event.Reason, event.FailedTaskCount, event.OrderResultUnknownCount)
+}
+
+const diagnosticsCleanupBatch = 5000
+
+// RunDiagnosticsCleanup shares the API server lifecycle but never occupies the
+// offline monitor's 15-second scan loop.
+func RunDiagnosticsCleanup(ctx context.Context, s *Service, onError func(error)) {
+	heartbeats := time.NewTicker(time.Hour)
+	defer heartbeats.Stop()
+	events := time.NewTicker(24 * time.Hour)
+	defer events.Stop()
+	runDiagnosticsCleanup(ctx, s, heartbeats.C, events.C, onError)
+}
+func runDiagnosticsCleanup(ctx context.Context, s *Service, heartbeats, events <-chan time.Time, onError func(error)) {
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-heartbeats:
+			if _, err := s.CleanupHeartbeatHistory(ctx); err != nil && ctx.Err() == nil && onError != nil {
+				onError(err)
+			}
+		case <-events:
+			if _, err := s.CleanupDeviceStatusEvents(ctx); err != nil && ctx.Err() == nil && onError != nil {
+				onError(err)
+			}
+		}
+	}
+}
+
+func (s *Service) CleanupHeartbeatHistory(ctx context.Context) (int64, error) {
+	return cleanupDiagnostics(s.DB.WithContext(ctx), &models.AgentHeartbeatLog{}, "received_at", s.Now().Add(-7*24*time.Hour))
+}
+func (s *Service) CleanupDeviceStatusEvents(ctx context.Context) (int64, error) {
+	return cleanupDiagnostics(s.DB.WithContext(ctx), &models.AgentDeviceStatusEvent{}, "occurred_at", s.Now().Add(-30*24*time.Hour))
+}
+func cleanupDiagnostics(db *gorm.DB, model any, timestamp string, cutoff time.Time) (int64, error) {
+	// A fixed-size ID batch works on both MySQL and SQLite. Recheck expiration
+	// in DELETE, and never loop through an unbounded backlog in one run.
+	var ids []uint64
+	if err := db.Model(model).Where(timestamp+" < ?", cutoff).Order(timestamp+", id").Limit(diagnosticsCleanupBatch).Pluck("id", &ids).Error; err != nil {
+		return 0, errors.New("diagnostics cleanup read failed")
+	}
+	if len(ids) == 0 {
+		return 0, nil
+	}
+	result := db.Where("id IN ? AND "+timestamp+" < ?", ids, cutoff).Delete(model)
+	if result.Error != nil {
+		return 0, errors.New("diagnostics cleanup delete failed")
+	}
+	return result.RowsAffected, nil
+}

server/app/goauto/device/diagnostics_mysql_test.go

@@ -0,0 +1,372 @@
+package device_test
+
+import (
+	"context"
+	"errors"
+	"net"
+	"os"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	. "go-admin/app/goauto/device"
+	"go-admin/app/goauto/models"
+	versionlocal "go-admin/cmd/migrate/migration/version-local"
+	common "go-admin/common/models"
+
+	driver "github.com/go-sql-driver/mysql"
+	"github.com/google/uuid"
+	"gorm.io/driver/mysql"
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/logger"
+)
+
+// Explicit opt-in only; refuses production/remote DSNs and any nonempty schema.
+// Credentials are injected by the caller and never included in test errors.
+func TestMySQLAgentDiagnostics(t *testing.T) {
+	raw := os.Getenv("GOAUTO_378_TEST_MYSQL_DSN")
+	if raw == "" {
+		t.Skip("isolated local MySQL DSN not provided")
+	}
+	cfg, err := driver.ParseDSN(raw)
+	if err != nil {
+		t.Fatal("invalid test DSN")
+	}
+	host, _, err := net.SplitHostPort(cfg.Addr)
+	if err != nil || cfg.Net != "tcp" || (host != "127.0.0.1" && host != "localhost" && host != "::1") || cfg.DBName != "goauto_378_test" {
+		t.Fatal("requires local tcp database goauto_378_test")
+	}
+	cfg.ParseTime = true
+	db, err := gorm.Open(mysql.Open(cfg.FormatDSN()), &gorm.Config{Logger: logger.Default.LogMode(logger.Silent)})
+	if err != nil {
+		t.Fatal("test MySQL connection failed")
+	}
+	sqlDB, err := db.DB()
+	if err != nil {
+		t.Fatal("test database unavailable")
+	}
+	t.Cleanup(func() { _ = sqlDB.Close() })
+	sqlDB.SetMaxOpenConns(8)
+	var version string
+	if db.Raw("SELECT VERSION()").Scan(&version).Error != nil || !strings.HasPrefix(version, "8.") {
+		t.Fatal("requires MySQL 8")
+	}
+	tables, err := db.Migrator().GetTables()
+	if err != nil || len(tables) != 0 {
+		t.Fatal("test schema must be empty")
+	}
+	owned := []any{&common.Migration{}, &models.AgentDevice{}, &models.PDDProduct{}, &models.CollectionRule{}, &models.CollectionTask{}, &models.PurchaseTask{}, &models.PurchaseTaskAttempt{}, &models.PDDAccount{}, &models.ShopeeProduct{}, &models.SYBProduct{}}
+	t.Cleanup(func() {
+		for _, model := range append([]any{&models.AgentHeartbeatLog{}, &models.AgentDeviceStatusEvent{}}, owned...) {
+			if err := db.Migrator().DropTable(model); err != nil {
+				t.Errorf("test table cleanup failed for %T", model)
+			}
+		}
+	})
+	if err := db.AutoMigrate(owned...); err != nil {
+		t.Fatal("test base migration failed")
+	}
+	const migrationVersion = "1791600000000_agent_diagnostics"
+	for i := 0; i < 2; i++ {
+		if versionlocal.MigrateAgentDiagnostics(db, migrationVersion) != nil {
+			t.Fatal("diagnostic migration failed")
+		}
+	}
+	for _, idx := range []struct {
+		model any
+		name  string
+	}{{&models.AgentHeartbeatLog{}, "ix_heartbeat_device_received"}, {&models.AgentHeartbeatLog{}, "ix_heartbeat_received"}, {&models.AgentDeviceStatusEvent{}, "ix_device_event_occurred"}} {
+		if !db.Migrator().HasIndex(idx.model, idx.name) {
+			t.Fatalf("missing MySQL index %s", idx.name)
+		}
+	}
+	// Exercise reviewed rollback only on fresh diagnostic tables in this schema.
+	if db.Migrator().DropTable(&models.AgentHeartbeatLog{}, &models.AgentDeviceStatusEvent{}) != nil {
+		t.Fatal("diagnostic test rollback failed")
+	}
+	if db.Where("version = ?", migrationVersion).Delete(&common.Migration{}).Error != nil {
+		t.Fatal("test version rollback failed")
+	}
+	if versionlocal.MigrateAgentDiagnostics(db, migrationVersion) != nil {
+		t.Fatal("diagnostic reapply failed")
+	}
+	seed := func(t *testing.T) (*Service, RegisterResponse, string) {
+		t.Helper()
+		s := NewService(db)
+		s.Now = func() time.Time { return time.Date(2026, 10, 10, 0, 0, 0, 0, time.UTC) }
+		token := "isolated-mysql-" + uuid.NewString()
+		s.GenerateToken = func() (string, error) { return token, nil }
+		d, err := s.Register(context.Background(), RegisterRequest{RequestID: uuid.NewString(), InstallID: uuid.NewString(), Name: "test", Manufacturer: "test", Model: "test", AndroidVersion: "14", AgentVersion: "test", PDDVersion: "test"}, "")
+		if err != nil {
+			t.Fatal("synthetic device registration failed")
+		}
+		if db.Model(&models.AgentDevice{}).Where("id = ?", d.DeviceID).Update("last_heartbeat_at", s.Now().Add(-time.Minute)).Error != nil {
+			t.Fatal("test seed failed")
+		}
+		t.Cleanup(func() {
+			if db.Model(&models.AgentDevice{}).Where("id = ?", d.DeviceID).Update("status", models.DeviceStatusDisabled).Error != nil {
+				t.Error("synthetic device cleanup failed")
+			}
+		})
+		return s, d, token
+	}
+	t.Run("v4", func(t *testing.T) { runOfflineV4MySQLTests(t, db, seed) })
+
+	t.Run("scan_revalidates_real_heartbeat_after_candidate_read", func(t *testing.T) {
+		s, d, token := seed(t)
+		type scanMarker struct{}
+		callback := "v4_heartbeat_before_scan_lock"
+		if db.Callback().Query().Before("gorm:query").Register(callback, func(tx *gorm.DB) {
+			if tx.Statement.Context.Value(scanMarker{}) != true || tx.Statement.Table != "agent_device" {
+				return
+			}
+			if _, ok := tx.Statement.Clauses["FOR"]; !ok {
+				return
+			}
+			if _, err := s.Heartbeat(context.Background(), HeartbeatRequest{RequestID: uuid.NewString()}, token); err != nil {
+				tx.AddError(errors.New("concurrent heartbeat failed"))
+			}
+		}) != nil {
+			t.Fatal("register heartbeat barrier failed")
+		}
+		defer db.Callback().Query().Remove(callback)
+		n, err := s.MarkStaleDevicesOffline(context.WithValue(context.Background(), scanMarker{}, true), DefaultOfflineThreshold)
+		if err != nil || n != 0 {
+			t.Fatal("fresh heartbeat falsely marked offline")
+		}
+		requireOfflineDevice(t, db, d.DeviceID, models.DeviceStatusOnline, 0)
+	})
+	t.Run("concurrent_scans_and_resume_are_unique", func(t *testing.T) {
+		s, d, testDeviceToken := seed(t)
+		var wg sync.WaitGroup
+		errs := make(chan error, 2)
+		for i := 0; i < 2; i++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				_, err := s.MarkStaleDevicesOffline(context.Background(), DefaultOfflineThreshold)
+				errs <- err
+			}()
+		}
+		wg.Wait()
+		for i := 0; i < 2; i++ {
+			if err := <-errs; err != nil {
+				var dbErr *driver.MySQLError
+				if errors.As(err, &dbErr) {
+					t.Fatalf("concurrent scan failed mysql_errno=%d", dbErr.Number)
+				}
+				t.Fatalf("concurrent scan failed classification=%T", err)
+			}
+		}
+		req := HeartbeatRequest{RequestID: uuid.NewString()}
+		for i := 0; i < 2; i++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				_, err := s.Heartbeat(context.Background(), req, testDeviceToken)
+				errs <- err
+			}()
+		}
+		wg.Wait()
+		for i := 0; i < 2; i++ {
+			if <-errs != nil {
+				t.Fatal("concurrent heartbeat failed")
+			}
+		}
+		var events []models.AgentDeviceStatusEvent
+		db.Where("device_id = ?", d.DeviceID).Order("id").Find(&events)
+		if len(events) != 2 || events[0].Reason != "heartbeat_timeout" || events[1].Reason != "heartbeat_resumed" {
+			t.Fatalf("transition count=%d", len(events))
+		}
+		var n int64
+		db.Model(&models.AgentHeartbeatLog{}).Where("device_id = ?", d.DeviceID).Count(&n)
+		if n != 1 {
+			t.Fatalf("replay history count=%d", n)
+		}
+	})
+	t.Run("event_failure_rolls_back_real_mysql", func(t *testing.T) {
+		s, d, _ := seed(t)
+		product := models.PDDProduct{GoodsID: "37801", URL: "https://example.invalid/test"}
+		rule := models.CollectionRule{Name: "test", ContentJSON: `{}`}
+		if db.Create(&product).Error != nil || db.Create(&rule).Error != nil {
+			t.Fatal("synthetic task input failed")
+		}
+		task := models.CollectionTask{PDDProductID: &product.ID, RuleID: rule.ID, DeviceID: &d.DeviceID, Status: models.TaskStatusRunning, URLSnapshot: product.URL, GoodsIDSnapshot: product.GoodsID, RuleSnapshot: rule.ContentJSON}
+		if db.Create(&task).Error != nil {
+			t.Fatal("synthetic task creation failed")
+		}
+		if db.Exec("CREATE TRIGGER diagnostic_test_reject BEFORE INSERT ON agent_device_status_event FOR EACH ROW SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'synthetic_failure'").Error != nil {
+			t.Fatal("test trigger creation failed")
+		}
+		defer db.Exec("DROP TRIGGER IF EXISTS diagnostic_test_reject")
+		n, err := s.MarkStaleDevicesOffline(context.Background(), DefaultOfflineThreshold)
+		if err == nil || n != 0 {
+			t.Fatal("failed event did not abort")
+		}
+		var device models.AgentDevice
+		db.First(&device, d.DeviceID)
+		if device.Status != models.DeviceStatusOnline {
+			t.Fatal("state escaped rollback")
+		}
+		var storedTask models.CollectionTask
+		if db.First(&storedTask, task.ID).Error != nil || storedTask.Status != models.TaskStatusRunning || storedTask.DeviceRunSlot == nil {
+			t.Fatal("task escaped rollback")
+		}
+		if db.Exec("DROP TRIGGER diagnostic_test_reject").Error != nil {
+			t.Fatal("test trigger removal failed")
+		}
+		n, err = s.MarkStaleDevicesOffline(context.Background(), DefaultOfflineThreshold)
+		if err != nil || n != 1 {
+			t.Fatal("retry failed")
+		}
+		var event models.AgentDeviceStatusEvent
+		if db.Where("device_id = ?", d.DeviceID).First(&event).Error != nil || event.FailedTaskCount != 1 || event.OrderResultUnknownCount != 0 {
+			t.Fatal("per-device counts incorrect")
+		}
+	})
+	for _, domain := range []string{"collection", "purchase"} {
+		t.Run("scan_does_not_deadlock_task_then_device_reset_"+domain, func(t *testing.T) {
+			s, d, _ := seed(t)
+			goodsID := "37802"
+			if domain == "purchase" {
+				goodsID = "37803"
+			}
+			product := models.PDDProduct{GoodsID: goodsID, URL: "https://example.invalid/test"}
+			rule := models.CollectionRule{Name: "test", ContentJSON: `{}`}
+			if db.Create(&product).Error != nil || db.Create(&rule).Error != nil {
+				t.Fatal("synthetic inputs failed")
+			}
+			var taskID uint64
+			var taskModel any
+			if domain == "collection" {
+				task := models.CollectionTask{PDDProductID: &product.ID, RuleID: rule.ID, DeviceID: &d.DeviceID, Status: models.TaskStatusRunning, URLSnapshot: product.URL, GoodsIDSnapshot: product.GoodsID, RuleSnapshot: rule.ContentJSON}
+				if db.Create(&task).Error != nil {
+					t.Fatal("synthetic task failed")
+				}
+				taskID = task.ID
+				taskModel = &models.CollectionTask{}
+			} else {
+				task := models.PurchaseTask{PDDProductID: product.ID, DeviceID: &d.DeviceID, ExecutionMode: models.PurchaseExecutionModeRehearsal, Status: models.PurchaseTaskStatusRunning, PDDURLSnapshot: product.URL, PDDGoodsIDSnapshot: product.GoodsID, Quantity: 1, ReferenceUnitPriceCent: 100, MinUnitPriceCent: 20, MaxUnitPriceCent: 150, Currency: "CNY", RuleType: "pddPurchase", RuleSchemaVersion: 1, RequiredCapabilitiesJSON: `[]`, RuleSnapshot: `{}`, CreateRequestID: uuid.NewString()}
+				if db.Create(&task).Error != nil {
+					t.Fatal("synthetic purchase task failed")
+				}
+				taskID = task.ID
+				taskModel = &models.PurchaseTask{}
+			}
+			resetTx := db.Begin()
+			defer resetTx.Rollback()
+			if resetTx.Clauses(clause.Locking{Strength: "UPDATE"}).First(taskModel, taskID).Error != nil {
+				t.Fatal("reset task lock failed")
+			}
+			type scanMarker struct{}
+			deviceLocked, releaseScan := make(chan struct{}), make(chan struct{})
+			callback := "diagnostic_test_scan_lock_barrier"
+			if db.Callback().Query().After("gorm:query").Register(callback, func(tx *gorm.DB) {
+				if tx.Statement.Context.Value(scanMarker{}) == true && tx.Statement.Table == "agent_device" {
+					if _, ok := tx.Statement.Clauses["FOR"]; ok {
+						close(deviceLocked)
+						<-releaseScan
+					}
+				}
+			}) != nil {
+				t.Fatal("register scan barrier failed")
+			}
+			defer db.Callback().Query().Remove(callback)
+			scanDone, resetDone := make(chan error, 1), make(chan error, 1)
+			go func() {
+				_, err := s.MarkStaleDevicesOffline(context.WithValue(context.Background(), scanMarker{}, true), DefaultOfflineThreshold)
+				scanDone <- err
+			}()
+			select {
+			case <-deviceLocked:
+			case <-time.After(5 * time.Second):
+				close(releaseScan)
+				t.Fatal("scan device lock not reached")
+			}
+			go func() {
+				var device models.AgentDevice
+				err := resetTx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&device, d.DeviceID).Error
+				resetTx.Rollback()
+				resetDone <- err
+			}()
+			close(releaseScan)
+			scanErr, resetErr := <-scanDone, <-resetDone
+			if resetErr != nil {
+				var mysqlErr *driver.MySQLError
+				if errors.As(resetErr, &mysqlErr) {
+					t.Fatalf("reset lock failed mysql_errno=%d", mysqlErr.Number)
+				}
+				t.Fatal("reset lock failed")
+			}
+			if scanErr != nil {
+				t.Fatal("scan must skip busy task without returning contention")
+			}
+			var eventCount int64
+			db.Model(&models.AgentDeviceStatusEvent{}).Where("device_id = ?", d.DeviceID).Count(&eventCount)
+			if eventCount != 0 {
+				t.Fatal("busy task created event")
+			}
+			var device models.AgentDevice
+			db.First(&device, d.DeviceID)
+			if device.Status != models.DeviceStatusOnline {
+				t.Fatal("busy task changed status")
+			}
+			db.Callback().Query().Remove(callback)
+			n, err := s.MarkStaleDevicesOffline(context.Background(), DefaultOfflineThreshold)
+			if err != nil || n != 1 {
+				t.Fatal("scan did not retry after reset released locks")
+			}
+		})
+	}
+	t.Run("history_timeout_is_bounded_on_real_lock", func(t *testing.T) {
+		s, _, testDeviceToken := seed(t)
+		// Hold the diagnostic table's insert gap; liveness updates remain free.
+		lock := db.Begin()
+		defer lock.Rollback()
+		if lock.Exec("SELECT id FROM agent_heartbeat_log WHERE id > 0 FOR UPDATE").Error != nil {
+			t.Fatal("history lock failed")
+		}
+		started := time.Now()
+		res, err := s.Heartbeat(context.Background(), HeartbeatRequest{RequestID: uuid.NewString()}, testDeviceToken)
+		t.Logf("heartbeat with locked history table elapsed=%s", time.Since(started))
+		if err != nil || !res.Online || time.Since(started) > time.Second {
+			t.Fatal("history lock changed heartbeat outcome or exceeded budget")
+		}
+	})
+	t.Run("strict_cleanup", func(t *testing.T) {
+		s, d, _ := seed(t)
+		boundary := models.AgentHeartbeatLog{DeviceID: d.DeviceID, ReceivedAt: s.Now().Add(-7 * 24 * time.Hour), RequestID: uuid.NewString(), AgentVersion: "test", ClientReportStatus: "none"}
+		expired := boundary
+		expired.ReceivedAt = expired.ReceivedAt.Add(-time.Second)
+		db.Create(&boundary)
+		db.Create(&expired)
+		n, err := s.CleanupHeartbeatHistory(context.Background())
+		if err != nil || n != 1 {
+			t.Fatalf("cleanup=%d failed=%v", n, err != nil)
+		}
+		history := make([]models.AgentHeartbeatLog, 5001)
+		events := make([]models.AgentDeviceStatusEvent, 5001)
+		for i := range history {
+			history[i] = models.AgentHeartbeatLog{DeviceID: d.DeviceID, ReceivedAt: s.Now().Add(-31 * 24 * time.Hour), ClientReportStatus: "none"}
+			events[i] = models.AgentDeviceStatusEvent{DeviceID: d.DeviceID, OccurredAt: s.Now().Add(-31 * 24 * time.Hour)}
+		}
+		if db.CreateInBatches(&history, 500).Error != nil || db.CreateInBatches(&events, 500).Error != nil {
+			t.Fatal("synthetic cleanup batch seed failed")
+		}
+		n, err = s.CleanupHeartbeatHistory(context.Background())
+		if err != nil || n != 5000 {
+			t.Fatalf("history cleanup batch=%d failed=%v", n, err != nil)
+		}
+		n, err = s.CleanupDeviceStatusEvents(context.Background())
+		if err != nil || n != 5000 {
+			t.Fatalf("event cleanup batch=%d failed=%v", n, err != nil)
+		}
+		var remaining int64
+		db.Model(&models.AgentHeartbeatLog{}).Where("device_id = ?", d.DeviceID).Count(&remaining)
+		if remaining != 2 {
+			t.Fatalf("history boundary/remaining=%d", remaining)
+		}
+	})
+}

server/app/goauto/device/diagnostics_test.go

@@ -0,0 +1,434 @@
+package device
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+
+	"go-admin/app/goauto/models"
+
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+func TestHeartbeatDiagnosticsHistoryAndReportIsolation(t *testing.T) {
+	db := openTestDatabase(t)
+	service := newTestService(t, db)
+	_, registered := registerHeartbeatDevice(t, service)
+	gin.SetMode(gin.TestMode)
+	router := gin.New()
+	router.POST("/heartbeat", Handler{DB: db}.Heartbeat)
+	for _, tc := range []struct{ name, report, status string }{
+		{"missing", "", "none"},
+		{"accepted", `,"clientReport":{"snapshotSeq":1,"failedRounds":0,"latestFailureAt":null,"latestFailureStep":null,"latestFailureCategory":null,"latestFailureDurationMs":null,"previousSyncDurationMs":25,"hasInterruptedRound":false}`, "accepted"},
+		{"wrong_type", `,"clientReport":"secret-not-stored"`, "client_report_invalid"},
+		{"unknown_field", `,"clientReport":{"url":"secret-not-stored"}`, "client_report_invalid"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			id := uuid.NewString()
+			body := fmt.Sprintf(`{"requestId":%q,"currentTaskId":null%s}`, id, tc.report)
+			for i := 0; i < 2; i++ {
+				req := httptest.NewRequest(http.MethodPost, "/heartbeat", strings.NewReader(body))
+				req.Header.Set("Authorization", "Bearer "+testDeviceToken)
+				res := httptest.NewRecorder()
+				router.ServeHTTP(res, req)
+				if res.Code != 200 {
+					t.Fatalf("heartbeat status=%d body=%s", res.Code, res.Body.String())
+				}
+				var envelope struct {
+					Data map[string]any `json:"data"`
+				}
+				_ = json.Unmarshal(res.Body.Bytes(), &envelope)
+				if envelope.Data["acceptsClientReport"] != true {
+					t.Fatal("capability missing")
+				}
+			}
+			var rows []struct {
+				DeviceID           uint64
+				ClientReportStatus string
+				ClientReportJSON   *string
+			}
+			if err := db.Table("agent_heartbeat_log").Where("request_id = ?", id).Find(&rows).Error; err != nil {
+				t.Fatal(err)
+			}
+			if len(rows) != 1 || rows[0].DeviceID != registered.DeviceID || rows[0].ClientReportStatus != tc.status || (rows[0].ClientReportJSON != nil) != (tc.status == "accepted") {
+				t.Fatalf("history=%+v", rows)
+			}
+		})
+	}
+}
+
+func TestDisableWritesOneAtomicStatusEvent(t *testing.T) {
+	db := openTestDatabase(t)
+	s := newTestService(t, db)
+	_, d := registerHeartbeatDevice(t, s)
+	for i := 0; i < 2; i++ {
+		if err := s.Disable(context.Background(), d.DeviceID); err != nil {
+			t.Fatal(err)
+		}
+	}
+	var events []models.AgentDeviceStatusEvent
+	if err := db.Find(&events).Error; err != nil {
+		t.Fatal(err)
+	}
+	if len(events) != 1 || events[0].Reason != "disabled" || events[0].FromStatus != "online" || events[0].ToStatus != "disabled" {
+		t.Fatalf("events=%+v", events)
+	}
+}
+
+func TestStatusEventFailureRollsBackAndCanRetry(t *testing.T) {
+	for _, action := range []string{"timeout", "resumed", "disabled"} {
+		t.Run(action, func(t *testing.T) {
+			db := openTestDatabase(t)
+			s := newTestService(t, db)
+			_, d := registerHeartbeatDevice(t, s)
+			status := models.DeviceStatusOnline
+			if action == "resumed" {
+				status = models.DeviceStatusOffline
+			}
+			old := s.Now().Add(-time.Minute)
+			if err := db.Model(&models.AgentDevice{}).Where("id = ?", d.DeviceID).Updates(map[string]any{"status": status, "last_heartbeat_at": old}).Error; err != nil {
+				t.Fatal(err)
+			}
+			var task models.CollectionTask
+			if action == "timeout" || action == "disabled" {
+				product := models.PDDProduct{GoodsID: "1001", URL: "https://example.invalid/test"}
+				rule := models.CollectionRule{Name: "test", ContentJSON: `{}`}
+				if err := db.Create(&product).Error; err != nil {
+					t.Fatal(err)
+				}
+				if err := db.Create(&rule).Error; err != nil {
+					t.Fatal(err)
+				}
+				task = newHeartbeatTask(product, rule, d.DeviceID)
+				if err := db.Create(&task).Error; err != nil {
+					t.Fatal(err)
+				}
+			}
+			operation := func() error {
+				switch action {
+				case "timeout":
+					_, err := s.MarkStaleDevicesOffline(context.Background(), DefaultOfflineThreshold)
+					return err
+				case "disabled":
+					return s.Disable(context.Background(), d.DeviceID)
+				default:
+					_, err := s.Heartbeat(context.Background(), HeartbeatRequest{RequestID: uuid.NewString()}, testDeviceToken)
+					return err
+				}
+			}
+			callback := "diagnostic_event_failure"
+			if err := db.Callback().Create().Before("gorm:create").Register(callback, func(tx *gorm.DB) {
+				if tx.Statement.Table == "agent_device_status_event" {
+					tx.AddError(errors.New("injected private error"))
+				}
+			}); err != nil {
+				t.Fatal(err)
+			}
+			if err := operation(); err == nil {
+				t.Fatal("event failure must abort transaction")
+			}
+			var stored models.AgentDevice
+			if err := db.First(&stored, d.DeviceID).Error; err != nil {
+				t.Fatal(err)
+			}
+			if stored.Status != status || !stored.LastHeartbeatAt.Equal(old) {
+				t.Fatalf("state escaped rollback=%+v", stored.Status)
+			}
+			if task.ID != 0 {
+				var storedTask models.CollectionTask
+				if err := db.First(&storedTask, task.ID).Error; err != nil {
+					t.Fatal(err)
+				}
+				if storedTask.Status != models.TaskStatusRunning || storedTask.DeviceRunSlot == nil {
+					t.Fatal("task changes escaped rollback")
+				}
+			}
+			_ = db.Callback().Create().Remove(callback)
+			if err := operation(); err != nil {
+				t.Fatal(err)
+			}
+			var n int64
+			db.Model(&models.AgentDeviceStatusEvent{}).Count(&n)
+			if n != 1 {
+				t.Fatalf("events=%d", n)
+			}
+		})
+	}
+}
+
+func TestOfflineEventCountsPerDeviceIncludingUnknownBoundary(t *testing.T) {
+	db := openTestDatabase(t)
+	s := newTestService(t, db)
+	ids := make([]uint64, 3)
+	for i := range ids {
+		s.GenerateToken = func() (string, error) { return fmt.Sprintf("test-token-%d", i), nil }
+		_, registered := registerHeartbeatDevice(t, s)
+		ids[i] = registered.DeviceID
+		if err := db.Model(&models.AgentDevice{}).Where("id = ?", ids[i]).Update("last_heartbeat_at", s.Now().Add(-time.Minute)).Error; err != nil {
+			t.Fatal(err)
+		}
+	}
+	product := models.PDDProduct{GoodsID: "1002", URL: "https://example.invalid/test"}
+	rule := models.CollectionRule{Name: "test", ContentJSON: `{}`}
+	if err := db.Create(&product).Error; err != nil {
+		t.Fatal(err)
+	}
+	if err := db.Create(&rule).Error; err != nil {
+		t.Fatal(err)
+	}
+	collection := newHeartbeatTask(product, rule, ids[0])
+	if err := db.Create(&collection).Error; err != nil {
+		t.Fatal(err)
+	}
+	for i, status := range []string{models.PurchaseTaskStatusRunning, models.PurchaseTaskStatusOrderSubmitStarted} {
+		task := newHeartbeatPurchaseTask(product, ids[i], status)
+		if err := db.Create(&task).Error; err != nil {
+			t.Fatal(err)
+		}
+		attempt := newRunningPurchaseAttempt(task.ID, ids[i])
+		if err := db.Create(&attempt).Error; err != nil {
+			t.Fatal(err)
+		}
+	}
+	if n, err := s.MarkStaleDevicesOffline(context.Background(), DefaultOfflineThreshold); err != nil || n != 3 {
+		t.Fatalf("scan=%d %v", n, err)
+	}
+	var events []models.AgentDeviceStatusEvent
+	if err := db.Order("device_id").Find(&events).Error; err != nil {
+		t.Fatal(err)
+	}
+	if len(events) != 3 || events[0].FailedTaskCount != 2 || events[0].OrderResultUnknownCount != 0 || events[1].FailedTaskCount != 0 || events[1].OrderResultUnknownCount != 1 || events[2].FailedTaskCount != 0 || events[2].OrderResultUnknownCount != 0 {
+		t.Fatalf("events=%+v", events)
+	}
+}
+
+func TestHeartbeatHistoryOnlyForSuccessfulMainRequest(t *testing.T) {
+	db := openTestDatabase(t)
+	s := newTestService(t, db)
+	registerHeartbeatDevice(t, s)
+	if _, err := s.Heartbeat(context.Background(), HeartbeatRequest{RequestID: uuid.NewString()}, "wrong-token"); err == nil {
+		t.Fatal("bad token accepted")
+	}
+	if _, err := s.Heartbeat(context.Background(), HeartbeatRequest{RequestID: "invalid"}, testDeviceToken); err == nil {
+		t.Fatal("bad request accepted")
+	}
+	id := uint64(999)
+	if _, err := s.Heartbeat(context.Background(), HeartbeatRequest{RequestID: uuid.NewString(), CurrentTaskID: &id}, testDeviceToken); err == nil {
+		t.Fatal("task mismatch accepted")
+	}
+	var count int64
+	if err := db.Model(&models.AgentHeartbeatLog{}).Count(&count).Error; err != nil {
+		t.Fatal(err)
+	}
+	if count != 0 {
+		t.Fatal("failed request stored history")
+	}
+}
+
+func TestHeartbeatHistoryBoundedIndependentAndBestEffort(t *testing.T) {
+	db := openTestDatabase(t)
+	s := newTestService(t, db)
+	_, d := registerHeartbeatDevice(t, s)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	callback := "history_wait_for_deadline"
+	if err := db.Callback().Create().Before("gorm:create").Register(callback, func(tx *gorm.DB) {
+		if tx.Statement.Table != "agent_heartbeat_log" {
+			return
+		}
+		// We are already outside the core transaction; cancellation must not
+		// cancel the independent history context.
+		cancel()
+		if tx.Statement.Context.Err() != nil {
+			t.Error("history inherited request cancellation")
+		}
+		deadline, ok := tx.Statement.Context.Deadline()
+		if !ok || time.Until(deadline) > 201*time.Millisecond {
+			t.Error("missing bounded deadline")
+		}
+		var current models.AgentDevice
+		if err := db.First(&current, d.DeviceID).Error; err != nil || current.LastHeartbeatAt == nil {
+			t.Error("core was not committed before history")
+		}
+		<-tx.Statement.Context.Done()
+		tx.AddError(tx.Statement.Context.Err())
+	}); err != nil {
+		t.Fatal(err)
+	}
+	started := time.Now()
+	res, err := s.Heartbeat(ctx, HeartbeatRequest{RequestID: uuid.NewString()}, testDeviceToken)
+	if err != nil || !res.Online || time.Since(started) > time.Second {
+		t.Fatalf("best effort changed result: %v", err)
+	}
+	_ = db.Callback().Create().Remove(callback)
+	if err := db.Migrator().DropTable(&models.AgentHeartbeatLog{}); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := s.Heartbeat(context.Background(), HeartbeatRequest{RequestID: uuid.NewString()}, testDeviceToken); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestClientReportWhitelistBounds(t *testing.T) {
+	valid := `{"snapshotSeq":1,"failedRounds":1,"latestFailureAt":"2026-10-10T00:00:00Z","latestFailureStep":"heartbeat","latestFailureCategory":"network","latestFailureDurationMs":12,"previousSyncDurationMs":null,"hasInterruptedRound":false}`
+	for _, tc := range []struct{ name, raw, status string }{
+		{"accepted", valid, "accepted"}, {"none", "", "none"}, {"null", "null", "client_report_invalid"}, {"array", "[]", "client_report_invalid"},
+		{"sequence", strings.Replace(valid, `"snapshotSeq":1`, `"snapshotSeq":0`, 1), "client_report_invalid"},
+		{"duration", strings.Replace(valid, `"latestFailureDurationMs":12`, `"latestFailureDurationMs":86400001`, 1), "client_report_invalid"},
+		{"unknown_step", strings.Replace(valid, `"heartbeat"`, `"http://private"`, 1), "client_report_invalid"},
+		{"inconsistent", strings.Replace(valid, `"failedRounds":1`, `"failedRounds":0`, 1), "client_report_invalid"},
+		{"unknown", strings.Replace(valid, `"snapshotSeq"`, `"privateText"`, 1), "client_report_invalid"},
+		{"null_bool", strings.Replace(valid, `"hasInterruptedRound":false`, `"hasInterruptedRound":null`, 1), "client_report_invalid"},
+		{"case_alias_cannot_replace_missing_required", `{"snapshotSeq":1,"failedRounds":0,"latestFailureAt":null,"latestFailureStep":null,"latestFailureCategory":null,"SNAPSHOTSEQ":2,"previousSyncDurationMs":null,"hasInterruptedRound":false}`, "client_report_invalid"},
+		{"oversize", strings.Repeat(" ", 2049) + valid, "client_report_invalid"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			value, status := validateHeartbeatClientReport(json.RawMessage(tc.raw))
+			if status != tc.status || (status != "accepted" && value != nil) {
+				t.Fatalf("status=%s valuePresent=%v", status, value != nil)
+			}
+		})
+	}
+}
+
+func TestDiagnosticsCleanupIsBoundedAndStrictlyExpired(t *testing.T) {
+	db := openTestDatabase(t)
+	s := newTestService(t, db)
+	now := s.Now()
+	old := now.Add(-31 * 24 * time.Hour)
+	heartbeats := make([]models.AgentHeartbeatLog, 5001)
+	events := make([]models.AgentDeviceStatusEvent, 5001)
+	for i := range heartbeats {
+		heartbeats[i] = models.AgentHeartbeatLog{DeviceID: 1, ReceivedAt: old, RequestID: uuid.NewString(), AgentVersion: "test", ClientReportStatus: "none"}
+		events[i] = models.AgentDeviceStatusEvent{DeviceID: 1, OccurredAt: old, FromStatus: "online", ToStatus: "offline", Reason: "heartbeat_timeout"}
+	}
+	if err := db.CreateInBatches(&heartbeats, 100).Error; err != nil {
+		t.Fatal(err)
+	}
+	if err := db.CreateInBatches(&events, 100).Error; err != nil {
+		t.Fatal(err)
+	}
+	boundaryHeartbeat := models.AgentHeartbeatLog{DeviceID: 1, ReceivedAt: now.Add(-7 * 24 * time.Hour), RequestID: uuid.NewString(), AgentVersion: "test", ClientReportStatus: "none"}
+	boundaryEvent := models.AgentDeviceStatusEvent{DeviceID: 1, OccurredAt: now.Add(-30 * 24 * time.Hour), FromStatus: "online", ToStatus: "offline", Reason: "heartbeat_timeout"}
+	db.Create(&boundaryHeartbeat)
+	db.Create(&boundaryEvent)
+	n, err := s.CleanupHeartbeatHistory(context.Background())
+	if err != nil || n != 5000 {
+		t.Fatalf("heartbeat cleanup=%d %v", n, err)
+	}
+	n, err = s.CleanupDeviceStatusEvents(context.Background())
+	if err != nil || n != 5000 {
+		t.Fatalf("event cleanup=%d %v", n, err)
+	}
+	var count int64
+	db.Model(&models.AgentHeartbeatLog{}).Count(&count)
+	if count != 2 {
+		t.Fatalf("remaining=%d", count)
+	}
+	db.Model(&models.AgentDeviceStatusEvent{}).Count(&count)
+	if count != 2 {
+		t.Fatalf("remaining=%d", count)
+	}
+	n, err = s.CleanupHeartbeatHistory(context.Background())
+	if err != nil || n != 1 {
+		t.Fatalf("strict heartbeat cleanup=%d %v", n, err)
+	}
+	n, err = s.CleanupDeviceStatusEvents(context.Background())
+	if err != nil || n != 1 {
+		t.Fatalf("strict event cleanup=%d %v", n, err)
+	}
+}
+
+func TestDiagnosticsCleanupRunsOnSeparateSchedulesAndStops(t *testing.T) {
+	db := openTestDatabase(t)
+	s := newTestService(t, db)
+	old := s.Now().Add(-31 * 24 * time.Hour)
+	history := models.AgentHeartbeatLog{ReceivedAt: old, ClientReportStatus: "none"}
+	event := models.AgentDeviceStatusEvent{OccurredAt: old}
+	if err := db.Create(&history).Error; err != nil {
+		t.Fatal(err)
+	}
+	if err := db.Create(&event).Error; err != nil {
+		t.Fatal(err)
+	}
+	heartbeats, events := make(chan time.Time), make(chan time.Time)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		runDiagnosticsCleanup(ctx, s, heartbeats, events, func(err error) { t.Error(err) })
+	}()
+	heartbeats <- s.Now()
+	// A second tick synchronizes completion of the first cleanup.
+	heartbeats <- s.Now()
+	var n int64
+	db.Model(&models.AgentHeartbeatLog{}).Count(&n)
+	if n != 0 {
+		t.Fatal("hourly history cleanup did not run")
+	}
+	db.Model(&models.AgentDeviceStatusEvent{}).Count(&n)
+	if n != 1 {
+		t.Fatal("hourly tick cleaned daily events")
+	}
+	events <- s.Now()
+	events <- s.Now()
+	cancel()
+	select {
+	case <-done:
+	case <-time.After(time.Second):
+		t.Fatal("cleanup did not stop")
+	}
+	db.Model(&models.AgentDeviceStatusEvent{}).Count(&n)
+	if n != 0 {
+		t.Fatal("daily event cleanup did not run")
+	}
+}
+
+func TestOfflineDiagnosticsAtomicAndResumed(t *testing.T) {
+	db := openTestDatabase(t)
+	s := newTestService(t, db)
+	_, d := registerHeartbeatDevice(t, s)
+	old := s.Now().Add(-time.Minute)
+	if err := db.Model(&models.AgentDevice{}).Where("id = ?", d.DeviceID).Update("last_heartbeat_at", old).Error; err != nil {
+		t.Fatal(err)
+	}
+	for i := 0; i < 2; i++ {
+		n, err := s.MarkStaleDevicesOffline(context.Background(), DefaultOfflineThreshold)
+		if err != nil || n != int64(1-i) {
+			t.Fatalf("scan=%d %v", n, err)
+		}
+	}
+	var events []struct {
+		Reason, FromStatus, ToStatus             string
+		LastHeartbeatAt                          *time.Time
+		FailedTaskCount, OrderResultUnknownCount int64
+	}
+	if err := db.Table("agent_device_status_event").Find(&events).Error; err != nil {
+		t.Fatal(err)
+	}
+	if len(events) != 1 || events[0].Reason != "heartbeat_timeout" || events[0].FromStatus != "online" || events[0].ToStatus != "offline" || events[0].LastHeartbeatAt == nil || !events[0].LastHeartbeatAt.Equal(old) {
+		t.Fatalf("events=%+v", events)
+	}
+	req := HeartbeatRequest{RequestID: uuid.NewString()}
+	for i := 0; i < 2; i++ {
+		if _, err := s.Heartbeat(context.Background(), req, testDeviceToken); err != nil {
+			t.Fatal(err)
+		}
+	}
+	events = nil
+	if err := db.Table("agent_device_status_event").Order("id").Find(&events).Error; err != nil {
+		t.Fatal(err)
+	}
+	if len(events) != 2 || events[1].Reason != "heartbeat_resumed" {
+		t.Fatalf("events=%+v", events)
+	}
+}

server/app/goauto/device/heartbeat.go

@@ -2,14 +2,19 @@ package device
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"time"
 
 	"go-admin/app/goauto/models"
 
+	log "github.com/go-admin-team/go-admin-core/logger"
+	mysqlDriver "github.com/go-sql-driver/mysql"
 	"github.com/google/uuid"
 	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/logger"
 )
 
 const (
@@ -18,9 +23,10 @@ const (
 )
 
 type HeartbeatRequest struct {
-	RequestID     string   `json:"requestId"`
-	CurrentTaskID *uint64  `json:"currentTaskId"`
-	Capabilities  []string `json:"capabilities,omitempty"`
+	RequestID     string          `json:"requestId"`
+	CurrentTaskID *uint64         `json:"currentTaskId"`
+	Capabilities  []string        `json:"capabilities,omitempty"`
+	ClientReport  json.RawMessage `json:"clientReport,omitempty"`
 }
 
 type HeartbeatResponse struct {
@@ -32,6 +38,7 @@ type HeartbeatResponse struct {
 	ServerTime               string  `json:"serverTime"`
 	HeartbeatIntervalSeconds int     `json:"heartbeatIntervalSeconds"`
 	Replayed                 bool    `json:"replayed,omitempty"`
+	AcceptsClientReport      bool    `json:"acceptsClientReport"`
 }
 
 func (service *Service) Heartbeat(ctx context.Context, request HeartbeatRequest, presentedToken string) (HeartbeatResponse, error) {
@@ -50,10 +57,12 @@ func (service *Service) Heartbeat(ctx context.Context, request HeartbeatRequest,
 		interval = DefaultHeartbeatIntervalSeconds
 	}
 	var response HeartbeatResponse
+	var history models.AgentHeartbeatLog
+	var resumed *models.AgentDeviceStatusEvent
 	err = service.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
 		var device models.AgentDevice
 		digest := tokenDigest(presentedToken)
-		if err := tx.Where("token_digest = ? AND token_revoked_at IS NULL", digest).First(&device).Error; err != nil {
+		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).Where("token_digest = ? AND token_revoked_at IS NULL", digest).First(&device).Error; err != nil {
 			if errors.Is(err, gorm.ErrRecordNotFound) {
 				return tokenInvalidError()
 			}
@@ -93,14 +102,30 @@ func (service *Service) Heartbeat(ctx context.Context, request HeartbeatRequest,
 			if result.RowsAffected == 0 {
 				return tokenInvalidError()
 			}
+			if device.Status == models.DeviceStatusOffline {
+				resumed = &models.AgentDeviceStatusEvent{DeviceID: device.ID, OccurredAt: now, FromStatus: device.Status, ToStatus: models.DeviceStatusOnline, Reason: "heartbeat_resumed", LastHeartbeatAt: device.LastHeartbeatAt}
+				if err := insertDeviceStatusEvent(tx, resumed); err != nil {
+					return err
+				}
+			}
 		}
 		response = HeartbeatResponse{
 			RequestID: request.RequestID, DeviceID: device.ID, CurrentTaskID: runningTaskID,
 			Online: true, Busy: runningTaskID != nil, ServerTime: now.UTC().Format(time.RFC3339Nano),
-			HeartbeatIntervalSeconds: interval, Replayed: replayed,
+			HeartbeatIntervalSeconds: interval, Replayed: replayed, AcceptsClientReport: true,
 		}
+		history = models.AgentHeartbeatLog{DeviceID: device.ID, ReceivedAt: now, RequestID: request.RequestID, CurrentTaskID: request.CurrentTaskID, RunningTaskID: runningTaskID, Busy: runningTaskID != nil, AgentVersion: device.AgentVersion}
 		return nil
 	})
+	if err == nil {
+		if resumed != nil {
+			logDeviceStatusEvent(*resumed)
+		}
+		if !response.Replayed {
+			history.ClientReportJSON, history.ClientReportStatus = validateHeartbeatClientReport(request.ClientReport)
+			service.saveHeartbeatHistory(ctx, history)
+		}
+	}
 	return response, err
 }
 
@@ -115,8 +140,8 @@ func tokenInvalidError() error {
 	return &ServiceError{Code: CodeTokenInvalid, Message: "设备 Token 无效", Retryable: false}
 }
 
-// MarkStaleDevicesOffline atomically marks stale devices offline and fails any
-// running task held by those devices. It returns the number of devices changed.
+// MarkStaleDevicesOffline commits each device, its running tasks and its event
+// independently. The count always describes committed device transitions.
 func (service *Service) MarkStaleDevicesOffline(ctx context.Context, threshold time.Duration) (int64, error) {
 	if threshold <= 0 {
 		return 0, fmt.Errorf("offline threshold must be positive")
@@ -124,69 +149,152 @@ func (service *Service) MarkStaleDevicesOffline(ctx context.Context, threshold t
 	now := service.Now()
 	cutoff := now.Add(-threshold)
 	var changed int64
-	err := service.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
-		var deviceIDs []uint64
-		if err := tx.Model(&models.AgentDevice{}).
-			Where("status = ? AND COALESCE(last_heartbeat_at, created_at) < ?", models.DeviceStatusOnline, cutoff).
-			Pluck("id", &deviceIDs).Error; err != nil {
-			return internalError(err)
+	var deviceIDs []uint64
+	if err := service.DB.WithContext(ctx).Model(&models.AgentDevice{}).
+		Where("status = ? AND COALESCE(last_heartbeat_at, created_at) < ?", models.DeviceStatusOnline, cutoff).
+		Order("id").Pluck("id", &deviceIDs).Error; err != nil {
+		return 0, internalError(err)
+	}
+	if len(deviceIDs) == 0 {
+		return 0, nil
+	}
+	for _, deviceID := range deviceIDs {
+		if err := ctx.Err(); err != nil {
+			return changed, err
 		}
-		if len(deviceIDs) == 0 {
-			return nil
+		var event *models.AgentDeviceStatusEvent
+		// Expected NOWAIT contention must not be printed by GORM with SQL or
+		// parameters. The fixed warning below is the only contention log.
+		err := service.DB.WithContext(ctx).Session(&gorm.Session{Logger: logger.Default.LogMode(logger.Silent)}).Transaction(func(tx *gorm.DB) error {
+			var device models.AgentDevice
+			// The unlocked candidate list is only a hint. Lock the exact primary
+			// key without waiting, then revalidate its current state and heartbeat.
+			if err := tx.Clauses(clause.Locking{Strength: "UPDATE", Options: "NOWAIT"}).First(&device, deviceID).Error; err != nil {
+				if errors.Is(err, gorm.ErrRecordNotFound) {
+					return nil
+				}
+				return internalError(err)
+			}
+			last := device.CreatedAt
+			if device.LastHeartbeatAt != nil {
+				last = *device.LastHeartbeatAt
+			}
+			if device.Status != models.DeviceStatusOnline || !last.Before(cutoff) {
+				return nil
+			}
+			// Existing Admin reset paths lock task -> device, while collection
+			// Claim locks device -> task. Never wait for a task holding this device:
+			// contention rolls back only this device; a later scan retries it.
+			tasks, err := lockOfflineTasksNowait(tx, device.ID)
+			if err != nil {
+				return err
+			}
+			var collectionFailed int64
+			if len(tasks.CollectionIDs) > 0 {
+				result := tx.Session(&gorm.Session{SkipHooks: true}).Model(&models.CollectionTask{}).
+					Where("id IN ? AND status = ?", tasks.CollectionIDs, models.TaskStatusRunning).
+					Updates(map[string]any{
+						"status": models.TaskStatusFailed, "active_slot": gorm.Expr("NULL"), "device_run_slot": gorm.Expr("NULL"),
+						"lease_expires_at": gorm.Expr("NULL"), "error_code": "DEVICE_OFFLINE",
+						"error_message": "设备心跳超时，任务失败且不会自动重试", "finished_at": now,
+					})
+				if result.Error != nil {
+					return internalError(result.Error)
+				}
+				collectionFailed = result.RowsAffected
+			}
+			failed, unknown, err := markOfflinePurchaseTasks(tx, tasks, now)
+			if err != nil {
+				return err
+			}
+			event = &models.AgentDeviceStatusEvent{DeviceID: device.ID, OccurredAt: now, FromStatus: device.Status, ToStatus: models.DeviceStatusOffline, Reason: "heartbeat_timeout", LastHeartbeatAt: device.LastHeartbeatAt, FailedTaskCount: collectionFailed + failed, OrderResultUnknownCount: unknown}
+			result := tx.Model(&models.AgentDevice{}).Where("id = ? AND status = ?", device.ID, models.DeviceStatusOnline).
+				Update("status", models.DeviceStatusOffline)
+			if result.Error != nil {
+				return internalError(result.Error)
+			}
+			return insertDeviceStatusEvent(tx, event)
+		})
+		if err != nil {
+			if ctxErr := ctx.Err(); ctxErr != nil {
+				return changed, ctxErr
+			}
+			var mysqlErr *mysqlDriver.MySQLError
+			if errors.As(err, &mysqlErr) && mysqlErr.Number == 3572 {
+				log.Warnf("agent offline scan skipped: device_id=%d classification=lock_busy", deviceID)
+				continue
+			}
+			return changed, err
 		}
-		if err := tx.Session(&gorm.Session{SkipHooks: true}).Model(&models.CollectionTask{}).
-			Where("device_id IN ? AND status = ?", deviceIDs, models.TaskStatusRunning).
-			Updates(map[string]any{
-				"status": models.TaskStatusFailed, "active_slot": gorm.Expr("NULL"), "device_run_slot": gorm.Expr("NULL"),
-				"lease_expires_at": gorm.Expr("NULL"), "error_code": "DEVICE_OFFLINE",
-				"error_message": "设备心跳超时，任务失败且不会自动重试", "finished_at": now,
-			}).Error; err != nil {
-			return internalError(err)
+		if event != nil {
+			changed++
+			logDeviceStatusEvent(*event)
 		}
-		if err := markOfflinePurchaseTasks(tx, deviceIDs, now); err != nil {
-			return err
-		}
-		result := tx.Model(&models.AgentDevice{}).Where("id IN ? AND status = ?", deviceIDs, models.DeviceStatusOnline).
-			Update("status", models.DeviceStatusOffline)
-		if result.Error != nil {
-			return internalError(result.Error)
-		}
-		changed = result.RowsAffected
-		return nil
-	})
-	return changed, err
+	}
+	return changed, nil
 }
 
-func markOfflinePurchaseTasks(tx *gorm.DB, deviceIDs []uint64, now time.Time) error {
-	if err := markOfflinePurchaseStatus(
-		tx, deviceIDs, models.PurchaseTaskStatusRunning, models.PurchaseTaskStatusFailed,
-		"failed", "设备心跳超时，采购任务失败且不会自动重试", now,
-	); err != nil {
-		return err
+type offlineTasks struct {
+	CollectionIDs            []uint64
+	PurchaseRunningIDs       []uint64
+	PurchaseSubmitStartedIDs []uint64
+}
+
+func lockOfflineTasksNowait(tx *gorm.DB, deviceID uint64) (offlineTasks, error) {
+	var tasks offlineTasks
+	locking := clause.Locking{Strength: "UPDATE", Options: "NOWAIT"}
+	if err := tx.Model(&models.CollectionTask{}).Clauses(locking).
+		Where("device_id = ? AND status = ?", deviceID, models.TaskStatusRunning).
+		Order("id").Pluck("id", &tasks.CollectionIDs).Error; err != nil {
+		return tasks, internalError(err)
 	}
-	return markOfflinePurchaseStatus(
-		tx, deviceIDs, models.PurchaseTaskStatusOrderSubmitStarted, models.PurchaseTaskStatusOrderResultUnknown,
+	var purchases []struct {
+		ID     uint64
+		Status string
+	}
+	if err := tx.Model(&models.PurchaseTask{}).Select("id, status").Clauses(locking).
+		Where("device_id = ? AND status IN ?", deviceID, []string{models.PurchaseTaskStatusRunning, models.PurchaseTaskStatusOrderSubmitStarted}).
+		Order("id").Find(&purchases).Error; err != nil {
+		return tasks, internalError(err)
+	}
+	for _, task := range purchases {
+		if task.Status == models.PurchaseTaskStatusRunning {
+			tasks.PurchaseRunningIDs = append(tasks.PurchaseRunningIDs, task.ID)
+		} else {
+			tasks.PurchaseSubmitStartedIDs = append(tasks.PurchaseSubmitStartedIDs, task.ID)
+		}
+	}
+	return tasks, nil
+}
+
+func markOfflinePurchaseTasks(tx *gorm.DB, tasks offlineTasks, now time.Time) (int64, int64, error) {
+	failed, err := markOfflinePurchaseStatus(
+		tx, tasks.PurchaseRunningIDs, models.PurchaseTaskStatusRunning, models.PurchaseTaskStatusFailed,
+		"failed", "设备心跳超时，采购任务失败且不会自动重试", now,
+	)
+	if err != nil {
+		return 0, 0, err
+	}
+	unknown, err := markOfflinePurchaseStatus(
+		tx, tasks.PurchaseSubmitStartedIDs, models.PurchaseTaskStatusOrderSubmitStarted, models.PurchaseTaskStatusOrderResultUnknown,
 		"order_result_unknown", "设备心跳超时，订单结果未知，请人工核对，禁止自动重试", now,
 	)
+	return failed, unknown, err
 }
 
 func markOfflinePurchaseStatus(
 	tx *gorm.DB,
-	deviceIDs []uint64,
+	taskIDs []uint64,
 	fromStatus string,
 	toStatus string,
 	resultType string,
 	errorMessage string,
 	now time.Time,
-) error {
-	var taskIDs []uint64
-	if err := tx.Model(&models.PurchaseTask{}).
-		Where("device_id IN ? AND status = ?", deviceIDs, fromStatus).
-		Pluck("id", &taskIDs).Error; err != nil {
-		return internalError(err)
-	}
+) (int64, error) {
+	// Reuse the IDs and source states from the locking current read. An
+	// ordinary SELECT here could see an older REPEATABLE READ snapshot.
 	if len(taskIDs) == 0 {
-		return nil
+		return 0, nil
 	}
 	errorCode := "DEVICE_OFFLINE"
 	if err := tx.Model(&models.PurchaseTaskAttempt{}).
@@ -195,7 +303,7 @@ func markOfflinePurchaseStatus(
 			"status": models.PurchaseAttemptStatusFailed, "result_type": resultType,
 			"error_code": errorCode, "error_message": errorMessage, "finished_at": now,
 		}).Error; err != nil {
-		return internalError(err)
+		return 0, internalError(err)
 	}
 	updates := map[string]any{
 		"status": toStatus, "device_run_slot": gorm.Expr("NULL"), "account_run_slot": gorm.Expr("NULL"),
@@ -205,12 +313,13 @@ func markOfflinePurchaseStatus(
 	if toStatus == models.PurchaseTaskStatusFailed {
 		updates["active_slot"] = gorm.Expr("NULL")
 	}
-	if err := tx.Session(&gorm.Session{SkipHooks: true}).Model(&models.PurchaseTask{}).
+	result := tx.Session(&gorm.Session{SkipHooks: true}).Model(&models.PurchaseTask{}).
 		Where("id IN ? AND status = ?", taskIDs, fromStatus).
-		Updates(updates).Error; err != nil {
-		return internalError(err)
+		Updates(updates)
+	if result.Error != nil {
+		return 0, internalError(result.Error)
 	}
-	return nil
+	return result.RowsAffected, nil
 }
 
 func RunOfflineMonitor(ctx context.Context, service *Service, scanInterval, threshold time.Duration, onError func(error)) {

server/app/goauto/device/offline_mysql_test.go

@@ -0,0 +1,432 @@
+package device_test
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"go-admin/app/goauto/device"
+	"go-admin/app/goauto/models"
+	"go-admin/app/goauto/purchase"
+	"go-admin/app/goauto/task"
+
+	driver "github.com/go-sql-driver/mysql"
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+)
+
+type offlineSeed func(*testing.T) (*device.Service, device.RegisterResponse, string)
+
+func offlineCollection(t *testing.T, db *gorm.DB, deviceID uint64, status string) models.CollectionTask {
+	t.Helper()
+	product := models.PDDProduct{GoodsID: strings.ReplaceAll(uuid.NewString(), "-", ""), URL: "https://example.invalid/test"}
+	rule := models.CollectionRule{Name: "test", ContentJSON: `{"steps":[]}`}
+	if err := db.Create(&product).Error; err != nil {
+		t.Fatal("synthetic product failed")
+	}
+	if err := db.Create(&rule).Error; err != nil {
+		t.Fatal("synthetic rule failed")
+	}
+	task := models.CollectionTask{PDDProductID: &product.ID, RuleID: rule.ID, DeviceID: &deviceID, Status: status, URLSnapshot: product.URL, GoodsIDSnapshot: product.GoodsID, RuleSnapshot: rule.ContentJSON}
+	if err := db.Create(&task).Error; err != nil {
+		t.Fatal("synthetic collection task failed")
+	}
+	return task
+}
+
+func offlinePurchase(t *testing.T, db *gorm.DB, deviceID uint64, status string) models.PurchaseTask {
+	t.Helper()
+	product := models.PDDProduct{GoodsID: strings.ReplaceAll(uuid.NewString(), "-", ""), URL: "https://example.invalid/test"}
+	if err := db.Create(&product).Error; err != nil {
+		t.Fatal("synthetic product failed")
+	}
+	task := models.PurchaseTask{PDDProductID: product.ID, DeviceID: &deviceID, ExecutionMode: models.PurchaseExecutionModeRehearsal, Status: status, PDDURLSnapshot: product.URL, PDDGoodsIDSnapshot: product.GoodsID, Quantity: 1, ReferenceUnitPriceCent: 100, MinUnitPriceCent: 20, MaxUnitPriceCent: 150, Currency: "CNY", RuleType: "pddPurchase", RuleSchemaVersion: 1, RequiredCapabilitiesJSON: `[]`, RuleSnapshot: `{}`, CreateRequestID: uuid.NewString()}
+	if err := db.Create(&task).Error; err != nil {
+		t.Fatal("synthetic purchase task failed")
+	}
+	return task
+}
+
+func requireOfflineDevice(t *testing.T, db *gorm.DB, id uint64, status string, events int64) {
+	t.Helper()
+	var row models.AgentDevice
+	if db.First(&row, id).Error != nil || row.Status != status {
+		t.Fatalf("device %d status=%s want=%s", id, row.Status, status)
+	}
+	var count int64
+	if db.Model(&models.AgentDeviceStatusEvent{}).Where("device_id = ?", id).Count(&count).Error != nil || count != events {
+		t.Fatalf("device %d events=%d want=%d", id, count, events)
+	}
+}
+
+func runOfflineV4MySQLTests(t *testing.T, db *gorm.DB, seed offlineSeed) {
+	for _, busyKind := range []string{"device", "collection", "purchase"} {
+		t.Run("busy_"+busyKind+"_does_not_block_other_devices", func(t *testing.T) {
+			s, first, _ := seed(t)
+			_, busy, _ := seed(t)
+			_, last, _ := seed(t)
+			var lockedModel any
+			var lockedID uint64
+			switch busyKind {
+			case "device":
+				lockedModel = &models.AgentDevice{}
+				lockedID = busy.DeviceID
+			case "collection":
+				task := offlineCollection(t, db, busy.DeviceID, models.TaskStatusRunning)
+				lockedModel = &models.CollectionTask{}
+				lockedID = task.ID
+			case "purchase":
+				task := offlinePurchase(t, db, busy.DeviceID, models.PurchaseTaskStatusRunning)
+				lockedModel = &models.PurchaseTask{}
+				lockedID = task.ID
+			}
+			holder := db.Begin()
+			if holder.Error != nil {
+				t.Fatal("begin failed")
+			}
+			defer holder.Rollback()
+			if holder.Clauses(clause.Locking{Strength: "UPDATE"}).First(lockedModel, lockedID).Error != nil {
+				t.Fatal("synthetic lock failed")
+			}
+			ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+			defer cancel()
+			n, err := s.MarkStaleDevicesOffline(ctx, device.DefaultOfflineThreshold)
+			if err != nil || n != 2 {
+				t.Fatalf("busy %s prevented unrelated devices: changed=%d failed=%v", busyKind, n, err != nil)
+			}
+			requireOfflineDevice(t, db, first.DeviceID, models.DeviceStatusOffline, 1)
+			requireOfflineDevice(t, db, busy.DeviceID, models.DeviceStatusOnline, 0)
+			requireOfflineDevice(t, db, last.DeviceID, models.DeviceStatusOffline, 1)
+			if holder.Rollback().Error != nil {
+				t.Fatal("release failed")
+			}
+			n, err = s.MarkStaleDevicesOffline(context.Background(), device.DefaultOfflineThreshold)
+			if err != nil || n != 1 {
+				t.Fatal("busy device not retried on next scan")
+			}
+		})
+	}
+
+	for _, target := range []string{models.PurchaseTaskStatusRunning, models.PurchaseTaskStatusOrderSubmitStarted} {
+		t.Run("second_device_current_read_"+target, func(t *testing.T) {
+			s, first, _ := seed(t)
+			_, second, _ := seed(t)
+			offlinePurchase(t, db, first.DeviceID, models.PurchaseTaskStatusRunning)
+			task := offlinePurchase(t, db, second.DeviceID, models.PurchaseTaskStatusPending)
+			attempt := models.PurchaseTaskAttempt{TaskID: task.ID, AttemptID: uuid.NewString(), AttemptNumber: 1, Phase: models.PurchaseAttemptPhasePurchase, Status: models.PurchaseAttemptStatusRunning, DeviceID: &second.DeviceID, RuleSnapshotHash: "test", SpecDecisionSnapshot: `{}`}
+			if db.Create(&attempt).Error != nil {
+				t.Fatal("synthetic attempt failed")
+			}
+			callback := "v4_advance_second_device"
+			if db.Callback().Create().After("gorm:create").Register(callback, func(tx *gorm.DB) {
+				event, ok := tx.Statement.Dest.(*models.AgentDeviceStatusEvent)
+				if !ok || event.DeviceID != first.DeviceID {
+					return
+				}
+				ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+				defer cancel()
+				if err := db.WithContext(ctx).Session(&gorm.Session{SkipHooks: true}).Model(&models.PurchaseTask{}).Where("id = ?", task.ID).Updates(map[string]any{"status": target, "device_run_slot": 1}).Error; err != nil {
+					tx.AddError(errors.New("synthetic second device advancement failed"))
+				}
+			}) != nil {
+				t.Fatal("register advancement failed")
+			}
+			defer db.Callback().Create().Remove(callback)
+			n, err := s.MarkStaleDevicesOffline(context.Background(), device.DefaultOfflineThreshold)
+			if err != nil || n != 2 {
+				t.Fatalf("scan changed=%d failed=%v", n, err != nil)
+			}
+			var stored models.PurchaseTask
+			var storedAttempt models.PurchaseTaskAttempt
+			var event models.AgentDeviceStatusEvent
+			if db.First(&stored, task.ID).Error != nil || db.First(&storedAttempt, attempt.ID).Error != nil || db.Where("device_id = ?", second.DeviceID).First(&event).Error != nil {
+				t.Fatal("read outcome failed")
+			}
+			expected := models.PurchaseTaskStatusFailed
+			failed, unknown := int64(1), int64(0)
+			if target == models.PurchaseTaskStatusOrderSubmitStarted {
+				expected = models.PurchaseTaskStatusOrderResultUnknown
+				failed, unknown = 0, 1
+			}
+			if stored.Status != expected || storedAttempt.Status != models.PurchaseAttemptStatusFailed || event.FailedTaskCount != failed || event.OrderResultUnknownCount != unknown {
+				t.Fatalf("stale task snapshot: status=%s attempt=%s failed=%d unknown=%d", stored.Status, storedAttempt.Status, event.FailedTaskCount, event.OrderResultUnknownCount)
+			}
+		})
+	}
+
+	t.Run("event_failure_preserves_prior_device_commit", func(t *testing.T) {
+		s, first, _ := seed(t)
+		_, second, _ := seed(t)
+		_, last, _ := seed(t)
+		task := offlineCollection(t, db, second.DeviceID, models.TaskStatusRunning)
+		statement := fmt.Sprintf("CREATE TRIGGER v4_reject_event BEFORE INSERT ON agent_device_status_event FOR EACH ROW BEGIN IF NEW.device_id = %d THEN SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'synthetic_failure'; END IF; END", second.DeviceID)
+		if db.Exec(statement).Error != nil {
+			t.Fatal("test trigger failed")
+		}
+		defer db.Exec("DROP TRIGGER IF EXISTS v4_reject_event")
+		n, err := s.MarkStaleDevicesOffline(context.Background(), device.DefaultOfflineThreshold)
+		if err == nil || n != 1 {
+			t.Fatalf("must return earlier committed count on event failure: changed=%d failed=%v", n, err != nil)
+		}
+		requireOfflineDevice(t, db, first.DeviceID, models.DeviceStatusOffline, 1)
+		requireOfflineDevice(t, db, second.DeviceID, models.DeviceStatusOnline, 0)
+		requireOfflineDevice(t, db, last.DeviceID, models.DeviceStatusOnline, 0)
+		var stored models.CollectionTask
+		if db.First(&stored, task.ID).Error != nil || stored.Status != models.TaskStatusRunning {
+			t.Fatal("current task escaped rollback")
+		}
+		if db.Exec("DROP TRIGGER v4_reject_event").Error != nil {
+			t.Fatal("remove trigger failed")
+		}
+		n, err = s.MarkStaleDevicesOffline(context.Background(), device.DefaultOfflineThreshold)
+		if err != nil || n != 2 {
+			t.Fatal("next scan retry failed")
+		}
+	})
+
+	for _, kind := range []string{"1213", "1205", "text_3572", "cancel", "cancel_with_3572"} {
+		t.Run("non_contention_error_"+kind, func(t *testing.T) {
+			s, first, _ := seed(t)
+			_, second, _ := seed(t)
+			_, last, _ := seed(t)
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			callback := "v4_inject_non_contention"
+			if db.Callback().Query().After("gorm:query").Register(callback, func(tx *gorm.DB) {
+				row, ok := tx.Statement.Dest.(*models.AgentDevice)
+				if !ok || row.ID != second.DeviceID {
+					return
+				}
+				if _, locking := tx.Statement.Clauses["FOR"]; !locking {
+					return
+				}
+				switch kind {
+				case "1213":
+					tx.AddError(&driver.MySQLError{Number: 1213, Message: "synthetic"})
+				case "1205":
+					tx.AddError(&driver.MySQLError{Number: 1205, Message: "synthetic"})
+				case "text_3572":
+					tx.AddError(errors.New("synthetic 3572"))
+				case "cancel":
+					cancel()
+					tx.AddError(context.Canceled)
+				case "cancel_with_3572":
+					cancel()
+					tx.AddError(&driver.MySQLError{Number: 3572, Message: "synthetic"})
+				}
+			}) != nil {
+				t.Fatal("register injection failed")
+			}
+			defer db.Callback().Query().Remove(callback)
+			n, err := s.MarkStaleDevicesOffline(ctx, device.DefaultOfflineThreshold)
+			if err == nil || n != 1 {
+				t.Fatalf("non-contention error swallowed or lost prior commit: changed=%d failed=%v", n, err != nil)
+			}
+			if (kind == "cancel" || kind == "cancel_with_3572") && !errors.Is(err, context.Canceled) {
+				t.Fatal("cancellation not preserved")
+			}
+			requireOfflineDevice(t, db, first.DeviceID, models.DeviceStatusOffline, 1)
+			requireOfflineDevice(t, db, second.DeviceID, models.DeviceStatusOnline, 0)
+			requireOfflineDevice(t, db, last.DeviceID, models.DeviceStatusOnline, 0)
+		})
+	}
+
+	for _, domain := range []string{"collection_claim", "purchase_replayed_claim"} {
+		t.Run("actual_"+domain+"_does_not_deadlock_scan", func(t *testing.T) {
+			s, d, token := seed(t)
+			_, other, _ := seed(t)
+			type claimMarker struct{}
+			locked, release := make(chan struct{}), make(chan struct{})
+			var once sync.Once
+			callback := "v4_actual_claim_barrier"
+			if db.Callback().Query().After("gorm:query").Register(callback, func(tx *gorm.DB) {
+				if tx.Statement.Context.Value(claimMarker{}) != true {
+					return
+				}
+				lockTable := "agent_device"
+				if domain == "purchase_replayed_claim" {
+					lockTable = "purchase_task"
+				}
+				if tx.Statement.Table != lockTable {
+					return
+				}
+				if _, ok := tx.Statement.Clauses["FOR"]; !ok {
+					return
+				}
+				once.Do(func() { close(locked); <-release })
+			}) != nil {
+				t.Fatal("register actual claim barrier failed")
+			}
+			defer db.Callback().Query().Remove(callback)
+			ctx, cancel := context.WithTimeout(context.WithValue(context.Background(), claimMarker{}, true), 5*time.Second)
+			defer cancel()
+			done := make(chan error, 1)
+			var taskID uint64
+			if domain == "collection_claim" {
+				record := offlineCollection(t, db, d.DeviceID, models.TaskStatusPending)
+				taskID = record.ID
+				service := task.NewService(db)
+				service.Now = s.Now
+				go func() {
+					_, err := service.Claim(ctx, record.ID, task.ActionRequest{RequestID: uuid.NewString()}, token)
+					done <- err
+				}()
+			} else {
+				record := offlinePurchase(t, db, d.DeviceID, models.PurchaseTaskStatusRunning)
+				taskID = record.ID
+				requestID := uuid.NewString()
+				if db.Session(&gorm.Session{SkipHooks: true}).Model(&models.PurchaseTask{}).Where("id = ?", record.ID).Update("claim_request_id", requestID).Error != nil {
+					t.Fatal("replay fixture failed")
+				}
+				service := purchase.NewService(db)
+				service.Now = s.Now
+				go func() {
+					_, err := service.Claim(ctx, record.ID, purchase.ActionRequest{RequestID: requestID}, token)
+					done <- err
+				}()
+			}
+			select {
+			case <-locked:
+			case <-ctx.Done():
+				close(release)
+				t.Fatal("actual claim lock not reached")
+			}
+			scanCtx, stopScan := context.WithTimeout(context.Background(), 2*time.Second)
+			n, err := s.MarkStaleDevicesOffline(scanCtx, device.DefaultOfflineThreshold)
+			stopScan()
+			close(release)
+			claimErr := <-done
+			if err != nil || claimErr != nil || n != 1 {
+				t.Fatalf("claim/scan conflict: changed=%d scanFailed=%v claimFailed=%v", n, err != nil, claimErr != nil)
+			}
+			requireOfflineDevice(t, db, d.DeviceID, models.DeviceStatusOnline, 0)
+			requireOfflineDevice(t, db, other.DeviceID, models.DeviceStatusOffline, 1)
+			if domain == "collection_claim" {
+				var stored models.CollectionTask
+				if db.First(&stored, taskID).Error != nil || stored.Status != models.TaskStatusPending || stored.LeaseExpiresAt == nil || stored.ClaimRequestID == nil {
+					t.Fatal("claim partially persisted")
+				}
+			}
+		})
+	}
+
+	t.Run("real_heartbeat_started_during_scan_resumes_once", func(t *testing.T) {
+		s, d, token := seed(t)
+		type scanMarker struct{}
+		type heartbeatMarker struct{}
+		locked, release, heartbeatStarted := make(chan struct{}), make(chan struct{}), make(chan struct{})
+		scanCallback, heartbeatCallback := "v4_scan_heartbeat_barrier", "v4_heartbeat_scan_barrier"
+		if db.Callback().Query().After("gorm:query").Register(scanCallback, func(tx *gorm.DB) {
+			if tx.Statement.Context.Value(scanMarker{}) == true && tx.Statement.Table == "agent_device" {
+				if _, ok := tx.Statement.Clauses["FOR"]; ok {
+					close(locked)
+					<-release
+				}
+			}
+		}) != nil {
+			t.Fatal("register scan barrier failed")
+		}
+		defer db.Callback().Query().Remove(scanCallback)
+		if db.Callback().Query().Before("gorm:query").Register(heartbeatCallback, func(tx *gorm.DB) {
+			if tx.Statement.Context.Value(heartbeatMarker{}) == true && tx.Statement.Table == "agent_device" {
+				if _, ok := tx.Statement.Clauses["FOR"]; ok {
+					close(heartbeatStarted)
+				}
+			}
+		}) != nil {
+			t.Fatal("register heartbeat barrier failed")
+		}
+		defer db.Callback().Query().Remove(heartbeatCallback)
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+		scanDone, heartbeatDone := make(chan error, 1), make(chan error, 1)
+		go func() {
+			n, err := s.MarkStaleDevicesOffline(context.WithValue(ctx, scanMarker{}, true), device.DefaultOfflineThreshold)
+			if err == nil && n != 1 {
+				err = errors.New("wrong scan count")
+			}
+			scanDone <- err
+		}()
+		select {
+		case <-locked:
+		case <-ctx.Done():
+			close(release)
+			t.Fatal("scan lock not reached")
+		}
+		go func() {
+			_, err := s.Heartbeat(context.WithValue(ctx, heartbeatMarker{}, true), device.HeartbeatRequest{RequestID: uuid.NewString()}, token)
+			heartbeatDone <- err
+		}()
+		select {
+		case <-heartbeatStarted:
+		case <-ctx.Done():
+			close(release)
+			t.Fatal("heartbeat not started")
+		}
+		close(release)
+		if err := <-scanDone; err != nil {
+			t.Fatal("scan failed")
+		}
+		if err := <-heartbeatDone; err != nil {
+			t.Fatal("heartbeat failed")
+		}
+		requireOfflineDevice(t, db, d.DeviceID, models.DeviceStatusOnline, 2)
+	})
+
+	t.Run("explain_actual_lock_queries", func(t *testing.T) {
+		s, d, _ := seed(t)
+		offlineCollection(t, db, d.DeviceID, models.TaskStatusRunning)
+		offlinePurchase(t, db, d.DeviceID, models.PurchaseTaskStatusRunning)
+		type captured struct {
+			sql  string
+			vars []any
+		}
+		queries := map[string]captured{}
+		callback := "v4_capture_lock_sql"
+		if db.Callback().Query().After("gorm:query").Register(callback, func(tx *gorm.DB) {
+			if _, ok := tx.Statement.Clauses["FOR"]; ok {
+				queries[tx.Statement.Table] = captured{tx.Statement.SQL.String(), append([]any(nil), tx.Statement.Vars...)}
+			}
+		}) != nil {
+			t.Fatal("capture SQL failed")
+		}
+		n, err := s.MarkStaleDevicesOffline(context.Background(), device.DefaultOfflineThreshold)
+		db.Callback().Query().Remove(callback)
+		if err != nil || n != 1 {
+			t.Fatal("capture scan failed")
+		}
+		for _, table := range []string{"agent_device", "collection_task", "purchase_task"} {
+			query, ok := queries[table]
+			if !ok {
+				t.Fatalf("missing production lock query %s", table)
+			}
+			var plan []struct {
+				Type         string
+				Key          *string
+				PossibleKeys *string
+				Rows         int64
+				Extra        string
+			}
+			if db.Raw("EXPLAIN "+query.sql, query.vars...).Scan(&plan).Error != nil {
+				t.Fatal("EXPLAIN failed")
+			}
+			t.Logf("synthetic fixture only table=%s sql=%s", table, query.sql)
+			for _, row := range plan {
+				key := "NULL"
+				if row.Key != nil {
+					key = *row.Key
+				}
+				possible := "NULL"
+				if row.PossibleKeys != nil {
+					possible = *row.PossibleKeys
+				}
+				t.Logf("type=%s key=%s possible_keys=%s estimated_rows=%d extra=%s", row.Type, key, possible, row.Rows, row.Extra)
+			}
+		}
+	})
+}

server/app/goauto/device/service.go

@@ -16,6 +16,7 @@ import (
 
 	"github.com/google/uuid"
 	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
 )
 
 const DefaultHeartbeatIntervalSeconds = 15
@@ -305,7 +306,15 @@ func (service *Service) RevokeToken(ctx context.Context, deviceID uint64) error
 
 func (service *Service) deactivate(ctx context.Context, deviceID uint64, revoke bool) error {
 	now := service.Now()
-	return service.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+	var event *models.AgentDeviceStatusEvent
+	err := service.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+		var device models.AgentDevice
+		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&device, deviceID).Error; err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				return &ServiceError{Code: CodeDeviceNotFound, Message: "设备不存在", Retryable: false}
+			}
+			return internalError(err)
+		}
 		updates := map[string]any{"status": models.DeviceStatusDisabled}
 		if revoke {
 			updates["token_revoked_at"] = now
@@ -324,17 +333,26 @@ func (service *Service) deactivate(ctx context.Context, deviceID uint64, revoke
 			}
 		}
 		errorCode, errorMessage := CodeDeviceDisabled, "设备已由管理员停用"
-		if err := tx.Session(&gorm.Session{SkipHooks: true}).Model(&models.CollectionTask{}).
+		result = tx.Session(&gorm.Session{SkipHooks: true}).Model(&models.CollectionTask{}).
 			Where("device_id = ? AND status = ?", deviceID, models.TaskStatusRunning).
 			Updates(map[string]any{
 				"status": models.TaskStatusFailed, "active_slot": gorm.Expr("NULL"),
 				"device_run_slot": gorm.Expr("NULL"), "lease_expires_at": gorm.Expr("NULL"),
 				"error_code": errorCode, "error_message": errorMessage, "finished_at": now,
-			}).Error; err != nil {
-			return internalError(err)
+			})
+		if result.Error != nil {
+			return internalError(result.Error)
+		}
+		if device.Status != models.DeviceStatusDisabled {
+			event = &models.AgentDeviceStatusEvent{DeviceID: device.ID, OccurredAt: now, FromStatus: device.Status, ToStatus: models.DeviceStatusDisabled, Reason: "disabled", LastHeartbeatAt: device.LastHeartbeatAt, FailedTaskCount: result.RowsAffected}
+			return insertDeviceStatusEvent(tx, event)
 		}
 		return nil
 	})
+	if err == nil && event != nil {
+		logDeviceStatusEvent(*event)
+	}
+	return err
 }
 
 func normalizeRegisterRequest(request RegisterRequest) RegisterRequest {

server/app/goauto/migrations/migrate.go

@@ -30,6 +30,8 @@ LIMIT 1`
 func MigratedModels() []any {
 	return []any{
 		&models.AgentDevice{},
+		&models.AgentHeartbeatLog{},
+		&models.AgentDeviceStatusEvent{},
 		&models.AgentAppRelease{},
 		&models.AgentAppReleaseSetting{},
 		&models.PDDProduct{},

server/app/goauto/models/agent_diagnostics.go

@@ -0,0 +1,33 @@
+package models
+
+import "time"
+
+// AgentHeartbeatLog is diagnostic history, never a device liveness authority.
+type AgentHeartbeatLog struct {
+	ID                 uint64    `gorm:"primaryKey;autoIncrement"`
+	DeviceID           uint64    `gorm:"not null;index:ix_heartbeat_device_received,priority:1"`
+	ReceivedAt         time.Time `gorm:"not null;index:ix_heartbeat_device_received,priority:2;index:ix_heartbeat_received"`
+	RequestID          string    `gorm:"size:36;not null"`
+	CurrentTaskID      *uint64
+	RunningTaskID      *uint64
+	Busy               bool    `gorm:"not null"`
+	AgentVersion       string  `gorm:"size:32;not null"`
+	ClientReportJSON   *string `gorm:"type:text"`
+	ClientReportStatus string  `gorm:"size:32;not null;check:ck_heartbeat_report_status,client_report_status IN ('none','accepted','client_report_invalid')"`
+}
+
+func (AgentHeartbeatLog) TableName() string { return "agent_heartbeat_log" }
+
+type AgentDeviceStatusEvent struct {
+	ID                      uint64    `gorm:"primaryKey;autoIncrement"`
+	DeviceID                uint64    `gorm:"not null"`
+	OccurredAt              time.Time `gorm:"not null;index:ix_device_event_occurred"`
+	FromStatus              string    `gorm:"size:16;not null"`
+	ToStatus                string    `gorm:"size:16;not null"`
+	Reason                  string    `gorm:"size:32;not null"`
+	LastHeartbeatAt         *time.Time
+	FailedTaskCount         int64 `gorm:"not null"`
+	OrderResultUnknownCount int64 `gorm:"not null"`
+}
+
+func (AgentDeviceStatusEvent) TableName() string { return "agent_device_status_event" }

server/app/goauto/purchase/admin_query.go

@@ -25,6 +25,46 @@ type AdminListRequest struct {
 	ShopeeOrderNo  string
 	ShopeeOrderNos []string
 	PDDOrderNo     string
+	// OrderSubmittedFrom/To are inclusive YYYY-MM-DD days (UTC+8, same as the
+	// SYB products createdFrom/createdTo filter) over order_submitted_at.
+	OrderSubmittedFrom string
+	OrderSubmittedTo   string
+}
+
+// adminOrderDayLocation matches the SYB products page's createdFrom/createdTo
+// day boundary (sybimport.sybStockLocation) so both pages filter the same way.
+var adminOrderDayLocation = time.FixedZone("SYB UTC+8", 8*60*60)
+
+// adminOrderSubmittedRange returns [start, endExclusive); a nil bound means
+// that side is open. Both days are inclusive for the caller.
+func adminOrderSubmittedRange(from, to string) (*time.Time, *time.Time, error) {
+	from, to = strings.TrimSpace(from), strings.TrimSpace(to)
+	parse := func(value, label string) (*time.Time, error) {
+		if value == "" {
+			return nil, nil
+		}
+		parsed, err := time.ParseInLocation("2006-01-02", value, adminOrderDayLocation)
+		if err != nil {
+			return nil, fail(CodeInvalidRequest, label+" 必须是 YYYY-MM-DD")
+		}
+		return &parsed, nil
+	}
+	start, err := parse(from, "orderSubmittedFrom")
+	if err != nil {
+		return nil, nil, err
+	}
+	endDay, err := parse(to, "orderSubmittedTo")
+	if err != nil {
+		return nil, nil, err
+	}
+	if start != nil && endDay != nil && start.After(*endDay) {
+		return nil, nil, fail(CodeInvalidRequest, "orderSubmittedFrom 不能晚于 orderSubmittedTo")
+	}
+	if endDay != nil {
+		end := endDay.AddDate(0, 0, 1)
+		endDay = &end
+	}
+	return start, endDay, nil
 }
 
 type AdminTaskItem struct {
@@ -175,7 +215,17 @@ func (s *Service) AdminList(ctx context.Context, req AdminListRequest) (AdminLis
 	if req.TaskType != "" && req.TaskType != models.PurchaseTaskTypeSYBOrder && req.TaskType != models.PurchaseTaskTypeStock {
 		return AdminListResponse{}, fail(CodeInvalidRequest, "taskType 无效")
 	}
+	submittedFrom, submittedTo, err := adminOrderSubmittedRange(req.OrderSubmittedFrom, req.OrderSubmittedTo)
+	if err != nil {
+		return AdminListResponse{}, err
+	}
 	query := s.DB.WithContext(ctx).Model(&models.PurchaseTask{})
+	if submittedFrom != nil {
+		query = query.Where("order_submitted_at >= ?", *submittedFrom)
+	}
+	if submittedTo != nil {
+		query = query.Where("order_submitted_at < ?", *submittedTo)
+	}
 	if req.TaskID > 0 {
 		query = query.Where("id = ?", req.TaskID)
 	}

server/app/goauto/purchase/admin_submitted_range_test.go

@@ -0,0 +1,129 @@
+package purchase
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	jwt "github.com/go-admin-team/go-admin-core/sdk/pkg/jwtauth"
+	"github.com/google/uuid"
+	"go-admin/app/goauto/models"
+	"go-admin/app/goauto/purchasecontract"
+)
+
+// #372: order_submitted_at day filter, inclusive on both ends, UTC+8 days.
+func TestAdminOrderSubmittedRange(t *testing.T) {
+	db := testDB(t)
+	f := seed(t, db, []string{purchasecontract.CapabilityPurchaseRehearsalV1}, true)
+	s := testService(db)
+	base := createAdminQueryTask(t, s, f)
+	loc := time.FixedZone("UTC+8", 8*3600)
+	at := func(day string, h, m int) *time.Time {
+		d, _ := time.ParseInLocation("2006-01-02", day, loc)
+		v := d.Add(time.Duration(h)*time.Hour + time.Duration(m)*time.Minute)
+		return &v
+	}
+	cases := []struct {
+		name   string
+		status string
+		at     *time.Time
+	}{
+		{"before", models.PurchaseTaskStatusOrderCreated, at("2026-10-01", 23, 59)},
+		{"first-day-start", models.PurchaseTaskStatusOrderCreated, at("2026-10-02", 0, 0)},
+		{"middle", models.PurchaseTaskStatusOrderCreated, at("2026-10-03", 12, 0)},
+		{"last-day-end", models.PurchaseTaskStatusOrderCreated, at("2026-10-04", 23, 59)},
+		{"after", models.PurchaseTaskStatusOrderCreated, at("2026-10-05", 0, 0)},
+		{"middle-failed", models.PurchaseTaskStatusFailed, at("2026-10-03", 13, 0)},
+		{"no-time", models.PurchaseTaskStatusOrderCreated, nil},
+	}
+	for _, tc := range cases {
+		row := base
+		row.ID = 0
+		row.CreateRequestID = uuid.NewString()
+		row.ShopeeOrderNoSnapshot = tc.name
+		row.Status = tc.status
+		row.OrderSubmittedAt = tc.at
+		if err := db.Create(&row).Error; err != nil {
+			t.Fatal(err)
+		}
+	}
+	names := func(req AdminListRequest) map[string]bool {
+		t.Helper()
+		out, err := s.AdminList(context.Background(), req)
+		if err != nil {
+			t.Fatal(err)
+		}
+		got := map[string]bool{}
+		for _, item := range out.Items {
+			got[item.ShopeeOrderNoSnapshot] = true
+		}
+		if int(out.Total) != len(got) {
+			t.Fatalf("total %d != items %d", out.Total, len(got))
+		}
+		return got
+	}
+	both := names(AdminListRequest{OrderSubmittedFrom: "2026-10-02", OrderSubmittedTo: "2026-10-04"})
+	if len(both) != 4 || !both["first-day-start"] || !both["middle"] || !both["last-day-end"] || !both["middle-failed"] {
+		t.Fatalf("both days must be inclusive: %v", both)
+	}
+	combined := names(AdminListRequest{OrderSubmittedFrom: "2026-10-02", OrderSubmittedTo: "2026-10-04", Status: models.PurchaseTaskStatusOrderCreated})
+	if len(combined) != 3 || combined["middle-failed"] {
+		t.Fatalf("must combine with status: %v", combined)
+	}
+	if only := names(AdminListRequest{OrderSubmittedFrom: "2026-10-04"}); len(only) != 2 || !only["last-day-end"] || !only["after"] {
+		t.Fatalf("from only: %v", only)
+	}
+	if only := names(AdminListRequest{OrderSubmittedTo: "2026-10-02"}); len(only) != 2 || !only["before"] || !only["first-day-start"] {
+		t.Fatalf("to only: %v", only)
+	}
+	if one := names(AdminListRequest{OrderSubmittedFrom: "2026-10-03", OrderSubmittedTo: "2026-10-03"}); len(one) != 2 {
+		t.Fatalf("single day: %v", one)
+	}
+	if none := names(AdminListRequest{}); !none["no-time"] {
+		t.Fatalf("no filter must keep rows without order time: %v", none)
+	}
+}
+
+func TestAdminOrderSubmittedRangeInvalid(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	db := testDB(t)
+	f := seed(t, db, []string{purchasecontract.CapabilityPurchaseRehearsalV1}, true)
+	s := testService(db)
+	createAdminQueryTask(t, s, f)
+	for _, req := range []AdminListRequest{
+		{OrderSubmittedFrom: "2026/10/02"},
+		{OrderSubmittedTo: "10-02"},
+		{OrderSubmittedFrom: "2026-13-01"},
+		{OrderSubmittedFrom: "2026-10-05", OrderSubmittedTo: "2026-10-04"},
+	} {
+		if _, err := s.AdminList(context.Background(), req); code(err) != CodeInvalidRequest {
+			t.Fatalf("%+v: expected invalid request, got %v", req, err)
+		}
+	}
+	for _, query := range []string{"orderSubmittedFrom=abc", "orderSubmittedTo=2026-02-30"} {
+		w := httptest.NewRecorder()
+		c, _ := gin.CreateTestContext(w)
+		c.Set("JWT_PAYLOAD", jwt.MapClaims{"rolekey": "purchaser"})
+		c.Request = httptest.NewRequest(http.MethodGet, "/api/admin/v1/purchase-tasks?"+query, nil)
+		(Handler{DB: db}).AdminList(c)
+		if !strings.Contains(w.Body.String(), CodeInvalidRequest) {
+			t.Fatalf("handler accepted %s: %s", query, w.Body.String())
+		}
+	}
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Set("JWT_PAYLOAD", jwt.MapClaims{"rolekey": "purchaser"})
+	c.Request = httptest.NewRequest(http.MethodGet, "/api/admin/v1/purchase-tasks?orderSubmittedFrom=2026-10-01&orderSubmittedTo=2026-10-02", nil)
+	(Handler{DB: db}).AdminList(c)
+	var result struct {
+		Data AdminListResponse `json:"data"`
+	}
+	if err := json.Unmarshal(w.Body.Bytes(), &result); err != nil || w.Code != http.StatusOK {
+		t.Fatalf("valid range: %d %s", w.Code, w.Body.String())
+	}
+}

server/app/goauto/purchase/handler.go

@@ -52,10 +52,12 @@ func (h Handler) AdminList(c *gin.Context) {
 	response, err := service.AdminList(c.Request.Context(), AdminListRequest{
 		Page: page, PageSize: pageSize, TaskID: taskID, SYBProductID: sybProductID,
 		Status: strings.TrimSpace(c.Query("status")), ExecutionMode: strings.TrimSpace(c.Query("executionMode")),
-		TaskType:       strings.TrimSpace(c.Query("taskType")),
-		ShopeeOrderNo:  strings.TrimSpace(c.Query("shopeeOrderNo")),
-		ShopeeOrderNos: c.Request.URL.Query()["shopeeOrderNos"],
-		PDDOrderNo:     strings.TrimSpace(c.Query("pddOrderNo")),
+		TaskType:           strings.TrimSpace(c.Query("taskType")),
+		ShopeeOrderNo:      strings.TrimSpace(c.Query("shopeeOrderNo")),
+		ShopeeOrderNos:     c.Request.URL.Query()["shopeeOrderNos"],
+		PDDOrderNo:         strings.TrimSpace(c.Query("pddOrderNo")),
+		OrderSubmittedFrom: c.Query("orderSubmittedFrom"),
+		OrderSubmittedTo:   c.Query("orderSubmittedTo"),
 	})
 	if err != nil {
 		writeError(c, err)

server/app/goauto/returnmatch/service.go

@@ -495,9 +495,12 @@ type ListFilter struct {
 // sn, spec) so it never has to issue a second request per row.
 type ListItem struct {
 	models.ReturnMatch
-	OrderSN         string     `json:"orderSn,omitempty"`
-	Image           string     `json:"image,omitempty"`
-	VariationName   string     `json:"variationName,omitempty"`
+	OrderSN       string `json:"orderSn,omitempty"`
+	Image         string `json:"image,omitempty"`
+	VariationName string `json:"variationName,omitempty"`
+	// YeekeQuantity is the yeeke return item's own quantity (read-only, #372
+	// export); it comes from the same join and is never used for matching.
+	YeekeQuantity   int64      `json:"yeekeQuantity"`
 	DestroyDeadline *time.Time `json:"destroyDeadline,omitempty"`
 	// SyncStatus/MissingSince (#338) surface the yeeke return item's own
 	// current availability ("ok"/"missing") so the SYB products match column
@@ -538,6 +541,7 @@ func (s *Service) List(ctx context.Context, filter ListFilter) ([]ListItem, erro
 		OrderSN          string
 		Image            string
 		VariationName    string
+		Quantity         int64
 		DestroyDeadLine  *time.Time
 		SyncStatus       string
 		MissingSince     *time.Time
@@ -545,7 +549,7 @@ func (s *Service) List(ctx context.Context, filter ListFilter) ([]ListItem, erro
 		PackageMissingAt *time.Time `gorm:"column:package_missing_since"`
 	}
 	if err := s.DB.WithContext(ctx).Table("yeeke_return_item AS i").
-		Select("i.id AS id, p.order_sn AS order_sn, i.image AS image, i.variation_name AS variation_name, p.destroy_dead_line AS destroy_dead_line, "+
+		Select("i.id AS id, p.order_sn AS order_sn, i.image AS image, i.variation_name AS variation_name, i.quantity AS quantity, p.destroy_dead_line AS destroy_dead_line, "+
 			"i.sync_status AS sync_status, i.missing_since AS missing_since, p.sync_status AS package_sync_status, p.missing_since AS package_missing_since").
 		Joins("JOIN yeeke_return_package AS p ON p.id = i.package_id").
 		Where("i.id IN ?", returnIDs).
@@ -556,6 +560,7 @@ func (s *Service) List(ctx context.Context, filter ListFilter) ([]ListItem, erro
 		OrderSN         string
 		Image           string
 		VariationName   string
+		Quantity        int64
 		DestroyDeadLine *time.Time
 		SyncStatus      string
 		MissingSince    *time.Time
@@ -569,13 +574,14 @@ func (s *Service) List(ctx context.Context, filter ListFilter) ([]ListItem, erro
 		if j.PackageSyncStat != "ok" {
 			syncStatus, missingSince = j.PackageSyncStat, j.PackageMissingAt
 		}
-		byID[j.ID] = extraFields{j.OrderSN, j.Image, j.VariationName, j.DestroyDeadLine, syncStatus, missingSince}
+		byID[j.ID] = extraFields{j.OrderSN, j.Image, j.VariationName, j.Quantity, j.DestroyDeadLine, syncStatus, missingSince}
 	}
 	for i := range items {
 		if extra, ok := byID[items[i].YeekeReturnItemID]; ok {
 			items[i].OrderSN = extra.OrderSN
 			items[i].Image = extra.Image
 			items[i].VariationName = extra.VariationName
+			items[i].YeekeQuantity = extra.Quantity
 			items[i].DestroyDeadline = extra.DestroyDeadLine
 			items[i].SyncStatus = extra.SyncStatus
 			items[i].MissingSince = extra.MissingSince

server/app/goauto/returnmatch/service_test.go

@@ -2,6 +2,7 @@ package returnmatch
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"strings"
@@ -484,3 +485,27 @@ func TestList_EnrichesWithYeekeReturnDisplayFields(t *testing.T) {
 		t.Fatalf("expected enriched list item: %+v", items)
 	}
 }
+
+// #372: List exposes the yeeke return item's quantity (read-only export field).
+func TestList_ExposesYeekeQuantity(t *testing.T) {
+	db := testDB(t)
+	s := NewService(db)
+	s.Now = func() time.Time { return time.Date(2026, 9, 24, 0, 0, 0, 0, time.UTC) }
+	syb := seedSYB(t, db, "SYB-Q", 1, "白色", "L", time.Date(2026, 9, 1, 0, 0, 0, 0, time.UTC))
+	deadline := time.Date(2026, 10, 1, 0, 0, 0, 0, time.UTC)
+	item := seedReturn(t, db, "白色,L", &deadline)
+	if err := db.Model(&models.YeekeReturnItem{}).Where("id = ?", item.ID).Update("quantity", 3).Error; err != nil {
+		t.Fatal(err)
+	}
+	if resp, err := s.BatchMatch(context.Background(), BatchMatchRequest{SYBProductIDs: []uint64{syb.ID}}); err != nil || resp.MatchedCount != 1 {
+		t.Fatalf("setup failed: %v %+v", err, resp)
+	}
+	items, err := s.List(context.Background(), ListFilter{SYBProductIDs: []uint64{syb.ID}})
+	if err != nil || len(items) != 1 || items[0].YeekeQuantity != 3 {
+		t.Fatalf("expected yeekeQuantity 3: %+v %v", items, err)
+	}
+	raw, _ := json.Marshal(items[0])
+	if !strings.Contains(string(raw), `"yeekeQuantity":3`) {
+		t.Fatalf("json missing yeekeQuantity: %s", raw)
+	}
+}

server/cmd/api/server.go

@@ -129,6 +129,9 @@ func run() error {
 	defer stopOfflineMonitors()
 	for _, db := range sdk.Runtime.GetDb() {
 		service := goautodevice.NewService(db)
+		go goautodevice.RunDiagnosticsCleanup(offlineMonitorContext, service,
+			func(err error) { log.Error("device diagnostics cleanup failed") },
+		)
 		go goautopurchase.RunFailureSnapshotCleanup(
 			offlineMonitorContext, goautopurchase.NewService(db), time.Hour,
 			func(err error) { log.Error("purchase failure snapshot cleanup failed") },

server/cmd/migrate/migration/version-local/1791600000000_agent_diagnostics.go

@@ -0,0 +1,29 @@
+package version_local
+
+import (
+	"runtime"
+
+	"go-admin/app/goauto/models"
+	"go-admin/cmd/migrate/migration"
+	common "go-admin/common/models"
+
+	"gorm.io/gorm"
+)
+
+func init() {
+	_, file, _, _ := runtime.Caller(0)
+	migration.Migrate.SetVersion(migration.GetFilename(file), MigrateAgentDiagnostics)
+}
+
+// MigrateAgentDiagnostics only adds #378 diagnostic tables. MySQL DDL commits
+// implicitly: idempotent table creation allows recovery after a partial up.
+func MigrateAgentDiagnostics(db *gorm.DB, version string) error {
+	for _, model := range []any{&models.AgentHeartbeatLog{}, &models.AgentDeviceStatusEvent{}} {
+		if !db.Migrator().HasTable(model) {
+			if err := db.Migrator().CreateTable(model); err != nil {
+				return err
+			}
+		}
+	}
+	return db.Where("version = ?", version).FirstOrCreate(&common.Migration{Version: version}).Error
+}

server/cmd/migrate/migration/version-local/1791600000000_agent_diagnostics_test.go

@@ -0,0 +1,48 @@
+package version_local
+
+import (
+	"go-admin/app/goauto/models"
+	common "go-admin/common/models"
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+	"testing"
+)
+
+func TestAgentDiagnosticsMigrationAppendAndRollback(t *testing.T) {
+	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := db.AutoMigrate(&common.Migration{}); err != nil {
+		t.Fatal(err)
+	}
+	for i := 0; i < 2; i++ {
+		if err := MigrateAgentDiagnostics(db, "test378"); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, model := range []any{&models.AgentHeartbeatLog{}, &models.AgentDeviceStatusEvent{}} {
+		if !db.Migrator().HasTable(model) {
+			t.Fatalf("missing table %T", model)
+		}
+	}
+	for _, idx := range []struct {
+		model any
+		name  string
+	}{{&models.AgentHeartbeatLog{}, "ix_heartbeat_device_received"}, {&models.AgentHeartbeatLog{}, "ix_heartbeat_received"}, {&models.AgentDeviceStatusEvent{}, "ix_device_event_occurred"}} {
+		if !db.Migrator().HasIndex(idx.model, idx.name) {
+			t.Fatalf("missing index %s", idx.name)
+		}
+	}
+	// Existing migration runner only supports up. Rollback is an explicit,
+	// operator-authorized removal of these two new diagnostic tables/version.
+	if err := db.Migrator().DropTable(&models.AgentHeartbeatLog{}, &models.AgentDeviceStatusEvent{}); err != nil {
+		t.Fatal(err)
+	}
+	if err := db.Where("version = ?", "test378").Delete(&common.Migration{}).Error; err != nil {
+		t.Fatal(err)
+	}
+	if err := MigrateAgentDiagnostics(db, "test378"); err != nil {
+		t.Fatal(err)
+	}
+}

web/src/utils/list-export.js

@@ -0,0 +1,148 @@
+// #372: export every page of an admin list (current filters) to xlsx.
+// Pure helpers with injected dependencies so they can be unit tested without a
+// browser; the pages inject the API calls and the Export2Excel saver.
+
+export const EXPORT_MAX_ROWS = 5000
+
+const pad = (value, width = 2) => String(value).padStart(width, '0')
+
+// YYYY-MM-DD HH:mm:ss in the browser's local time zone; empty for blank/invalid.
+export function formatExportTime(value) {
+  if (!value) return ''
+  const date = new Date(value)
+  if (Number.isNaN(date.getTime())) return ''
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`
+}
+
+// YYYYMMDD-HHmmss for file names.
+export function formatExportStamp(date = new Date()) {
+  return `${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(date.getDate())}-${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`
+}
+
+// Cents -> yuan text with two decimals; null/undefined/'' stay empty.
+export function centToYuan(cent) {
+  if (cent === null || cent === undefined || cent === '') return ''
+  const value = Number(cent)
+  if (!Number.isFinite(value)) return ''
+  const sign = value < 0 ? '-' : ''
+  const abs = Math.abs(Math.round(value))
+  return `${sign}${Math.floor(abs / 100)}.${pad(abs % 100)}`
+}
+
+// Cents -> yuan number (1230 -> 12.3) for numeric Excel cells; null/undefined/''/NaN stay empty, 0 stays 0.
+export function centToYuanNumber(cent) {
+  if (cent === null || cent === undefined || cent === '') return ''
+  const value = Number(cent)
+  if (!Number.isFinite(value)) return ''
+  return Math.round(value) / 100
+}
+
+// yeeke only has one variation_name ("color,size"); split at the first English
+// or Chinese comma. Without a comma the whole text is the color.
+export function splitYeekeVariation(name) {
+  const text = String(name ?? '').trim()
+  if (!text) return { color: '', size: '' }
+  const index = text.search(/[,，]/)
+  if (index < 0) return { color: text, size: '' }
+  return { color: text.slice(0, index).trim(), size: text.slice(index + 1).trim() }
+}
+
+const blank = value => (value === null || value === undefined ? '' : value)
+
+// Column indexes written as numbers; the saver shows them as 0.00.
+export const PURCHASE_EXPORT_NUMBER_COLS = [8]
+export const SYB_PRODUCT_EXPORT_NUMBER_COLS = [3]
+
+export const PURCHASE_EXPORT_HEADER = ['SYB订单号', '虾皮商品ID', '颜色', '尺码', '数量', '状态', 'PDD单号', '下单时间', '价格（元）']
+
+// statusLabel: the page's own status -> Chinese label function.
+export function purchaseExportRow(task, statusLabel = value => value) {
+  return [
+    blank(task.shopeeOrderNoSnapshot), blank(task.shopeeItemIdSnapshot), blank(task.targetColorSnapshot), blank(task.targetSizeSnapshot),
+    blank(task.quantity), task.status ? statusLabel(task.status) : '', blank(task.pddOrderNo),
+    formatExportTime(task.orderSubmittedAt), centToYuanNumber(task.pddOrderAmountCent)
+  ]
+}
+
+export const SYB_PRODUCT_EXPORT_HEADER = ['SYB订单', '店铺', '虾皮商品ID', 'SYB售价（TWD）', 'SYB颜色', 'SYB尺码', 'SYB数量', 'yeeke颜色', 'yeeke尺码', 'yeeke数量', '匹配时间']
+
+export const isActiveReturnMatch = match => Boolean(match) && (match.status === 'matched' || match.status === 'confirmed')
+
+// match: the active (matched/confirmed) return match of this product, or null.
+export function sybProductExportRow(product, match) {
+  const active = isActiveReturnMatch(match) ? match : null
+  const yeeke = active ? splitYeekeVariation(active.variationName) : { color: '', size: '' }
+  return [
+    blank(product.orderCode), blank(product.shopName), blank(product.shopeeItemId), centToYuanNumber(product.unitPriceCent), blank(product.targetColor), blank(product.targetSize), blank(product.quantity),
+    yeeke.color, yeeke.size, active ? blank(active.yeekeQuantity) : '', active ? formatExportTime(active.matchedAt) : ''
+  ]
+}
+
+export function exportFailureMessage(result, maxRows = EXPORT_MAX_ROWS) {
+  switch (result.reason) {
+    case 'empty': return '当前筛选没有数据，未生成文件'
+    case 'too_many': return `共 ${result.total} 条，超过 ${maxRows} 条上限，请缩小筛选范围`
+    case 'page_failed': return `导出失败：第 ${result.page} 页读取失败，未生成文件`
+    case 'enrich_failed': return '导出失败：匹配信息读取失败，未生成文件'
+    default: return '导出失败，未生成文件'
+  }
+}
+
+function chunk(items, size) {
+  const result = []
+  for (let i = 0; i < items.length; i += size) result.push(items.slice(i, i + size))
+  return result
+}
+
+// Reads page 1 for the total, refuses above maxRows, then reads the remaining
+// pages. Any failure returns { ok: false } and nothing is saved.
+//   fetchPage(page, pageSize) -> { items, total }
+//   enrich(items) -> decorated items of the same length (optional, per batch)
+//   mapRow(item) -> array of cells
+//   save({ header, data, filename }) -> writes the file (only after success)
+export async function runListExport({
+  fetchPage, pageSize, maxRows = EXPORT_MAX_ROWS, enrich = null, enrichBatchSize = 200,
+  header, mapRow, filename, save, numberFormatCols = [], onProgress = () => {}
+}) {
+  let first
+  try {
+    first = await fetchPage(1, pageSize)
+  } catch (error) {
+    return { ok: false, reason: 'page_failed', page: 1, error }
+  }
+  const total = Number(first?.total) || 0
+  if (total === 0) return { ok: false, reason: 'empty', total: 0 }
+  if (total > maxRows) return { ok: false, reason: 'too_many', total }
+  const pages = Math.ceil(total / pageSize)
+  const enrichSteps = enrich ? Math.ceil(total / enrichBatchSize) : 0
+  const steps = pages + enrichSteps
+  let done = 1
+  onProgress(done, steps)
+  let items = [...(first.items || [])]
+  for (let page = 2; page <= pages; page++) {
+    let response
+    try {
+      response = await fetchPage(page, pageSize)
+    } catch (error) {
+      return { ok: false, reason: 'page_failed', page, error }
+    }
+    items = items.concat(response?.items || [])
+    onProgress(++done, steps)
+  }
+  if (enrich) {
+    const decorated = []
+    for (const part of chunk(items, enrichBatchSize)) {
+      try {
+        decorated.push(...await enrich(part))
+      } catch (error) {
+        return { ok: false, reason: 'enrich_failed', error }
+      }
+      onProgress(++done, steps)
+    }
+    items = decorated
+  }
+  if (items.length === 0) return { ok: false, reason: 'empty', total: 0 }
+  const data = items.map(mapRow)
+  await save({ header, data, filename: `${filename}_${formatExportStamp()}`, numberFormatCols })
+  return { ok: true, total, rows: data.length }
+}

web/src/utils/save-excel.js

@@ -0,0 +1,5 @@
+// Loads the xlsx writer on demand so the list pages do not pull it into their chunk.
+export async function saveExcel(file) {
+  const { export_json_to_excel: exportJsonToExcel } = await import('@/vendor/Export2Excel')
+  exportJsonToExcel(file)
+}

web/src/vendor/Export2Excel.js

@@ -85,7 +85,11 @@ function sheet_from_array_of_arrays(data, opts) {
         r: R
       });
 
-      if (typeof cell.v === 'number') cell.t = 'n';
+      if (typeof cell.v === 'number') {
+        cell.t = 'n';
+        // optional display format for chosen columns (#372); unset keeps the old output
+        if (opts && opts.numberFormatCols && opts.numberFormatCols.indexOf(C) >= 0) cell.z = '0.00';
+      }
       else if (typeof cell.v === 'boolean') cell.t = 'b';
       else if (cell.v instanceof Date) {
         cell.t = 'n';
@@ -151,7 +155,8 @@ export function export_json_to_excel({
   filename,
   merges = [],
   autoWidth = true,
-  bookType = 'xlsx'
+  bookType = 'xlsx',
+  numberFormatCols = []
 } = {}) {
   /* original data */
   filename = filename || 'excel-list'
@@ -164,7 +169,7 @@ export function export_json_to_excel({
 
   var ws_name = "SheetJS";
   var wb = new Workbook(),
-    ws = sheet_from_array_of_arrays(data);
+    ws = sheet_from_array_of_arrays(data, { numberFormatCols: numberFormatCols });
 
   if (merges.length > 0) {
     if (!ws['!merges']) ws['!merges'] = [];

web/src/views/goauto/collection-tasks/index.vue

@@ -10,6 +10,7 @@
           <el-form-item label="Goods ID"><el-input v-model="query.goodsId" clearable placeholder="输入 goods_id" @keyup.enter="handleQuery" /></el-form-item>
           <el-form-item label="状态"><el-select v-model="query.status" clearable placeholder="全部状态" style="width:160px"><el-option v-for="item in statuses" :key="item.value" :label="item.label" :value="item.value" /></el-select></el-form-item>
           <el-form-item label="来源"><el-select v-model="query.source" clearable placeholder="全部来源" style="width:160px"><el-option v-for="item in sources" :key="item.value" :label="item.label" :value="item.value" /></el-select></el-form-item>
+          <el-form-item label="设备"><el-select v-model="query.deviceId" clearable filterable placeholder="全部设备" style="width:160px"><el-option v-for="item in deviceFilterOptions" :key="item.id" :label="item.name" :value="item.id" /></el-select></el-form-item>
           <el-form-item>
             <el-button type="primary" :icon="Search" @click="handleQuery">查询</el-button>
             <el-button :icon="RefreshLeft" @click="resetQuery">重置</el-button>
@@ -103,35 +104,39 @@ export default {
   name: 'GoAutoCollectionTasks', setup() { return { Plus, RefreshLeft, Search } },
   data() {
     return {
-      loading: false, tasks: [], total: 0, query: { page: 1, pageSize: 20, goodsId: '', status: '', source: '' },
+      loading: false, tasks: [], total: 0, query: { page: 1, pageSize: 20, goodsId: '', status: '', source: '', deviceId: null },
       statuses: [{ value: 'pending', label: '待执行' }, { value: 'running', label: '执行中' }, { value: 'completed', label: '已完成' }, { value: 'completed_partial', label: '部分完成' }, { value: 'failed', label: '失败' }, { value: 'cancelled', label: '已取消' }],
       sources: [{ value: 'admin', label: '手动创建' }, { value: 'agent_current_page', label: '拍照临时采集' }, { value: 'image_search', label: '图搜采集' }],
       createDialog: { open: false, saving: false }, form: { pddProductId: null, ruleId: null, deviceId: null },
       formRules: { pddProductId: [{ required: true, message: '请选择 PDD 商品', trigger: 'change' }], ruleId: [{ required: true, message: '请选择采集规则', trigger: 'change' }] },
       options: { products: [], rules: [], devices: [] }, detail: { open: false, loading: false, data: null },
-      pendingCancelCount: 0,
+      pendingCancelCount: 0, deviceFilterOptions: [],
       cancelBatch: { open: false, previewLoading: false, submitting: false, preview: [], previewTotal: 0 }
     }
   },
-  created() { this.getList(); this.refreshPendingCancelCount() },
+  created() { this.getList(); this.refreshPendingCancelCount(); this.loadDeviceFilterOptions() },
   watch: {
     // `[必须]` 取消范围必须与眼前的列表一致，三个筛选项都要联动。少了 Goods ID
     // 那一维，按 goods_id 筛出两条、按钮却显示并取消三十几条——那正是当初
     // 放弃「两个固定按钮」、改用「筛选 + 一个按钮」想避免的事（#298）。
     'query.source'() { this.refreshPendingCancelCount() },
     'query.status'() { this.refreshPendingCancelCount() },
-    'query.goodsId'() { this.refreshPendingCancelCount() }
+    'query.goodsId'() { this.refreshPendingCancelCount() },
+    'query.deviceId'() { this.refreshPendingCancelCount() }
   },
   methods: {
-    async getList() { this.loading = true; try { const r = await listCollectionTasks(this.query); this.tasks = r.data.items; this.total = r.data.total } finally { this.loading = false } },
-    handleQuery() { this.query.page = 1; this.getList() }, resetQuery() { this.query = { page: 1, pageSize: 20, goodsId: '', status: '', source: '' }; this.getList() },
+    // 设备下拉含已停用设备；加载失败只留空下拉，不影响列表查询。
+    async loadDeviceFilterOptions() { try { const r = await listDevices({ page: 1, pageSize: 100 }); this.deviceFilterOptions = r.data.items } catch { this.deviceFilterOptions = [] } },
+    async getList() { this.loading = true; try { const r = await listCollectionTasks({ ...this.query, deviceId: this.query.deviceId || undefined }); this.tasks = r.data.items; this.total = r.data.total } finally { this.loading = false } },
+    handleQuery() { this.query.page = 1; this.getList() }, resetQuery() { this.query = { page: 1, pageSize: 20, goodsId: '', status: '', source: '', deviceId: null }; this.getList() },
     statusLabel(value) { return this.statuses.find(item => item.value === value)?.label || value }, statusType(value) { return { pending: 'info', running: 'warning', completed: 'success', completed_partial: 'warning', failed: 'danger', cancelled: 'info' }[value] || 'info' },
     sourceLabel(value) { return this.sources.find(item => item.value === value)?.label || value || '' },
     isTerminal(value) { return ['completed', 'completed_partial', 'failed'].includes(value) }, specsText(specs) { return Object.entries(specs || {}).map(([key, value]) => `${key}: ${value}`).join(' / ') },
     // 取消范围只对「状态筛选为空或恰好是待执行」才有意义：其它状态下这个筛选
     // 条件里不可能存在待执行任务，角标应该直接显示 0 并禁用按钮，而不是拿一个
     // 与实际可取消数量无关的数字误导采购员。
-    cancelScopeStatus() { return this.query.status === '' || this.query.status === 'pending' ? 'pending' : null },
+    // 批量取消接口不支持设备维度；选了设备筛选时禁用，避免取消范围超出眼前列表。
+    cancelScopeStatus() { if (this.query.deviceId) return null; return this.query.status === '' || this.query.status === 'pending' ? 'pending' : null },
     async refreshPendingCancelCount() {
       const status = this.cancelScopeStatus()
       if (!status) { this.pendingCancelCount = 0; return }

web/src/views/goauto/purchase-tasks/index.vue

@@ -16,7 +16,8 @@
           <el-form-item label="状态"><el-select v-model="query.status" clearable placeholder="全部状态" style="width:160px"><el-option v-for="item in statuses" :key="item.value" :label="item.label" :value="item.value" /></el-select></el-form-item>
           <el-form-item label="SYB 商品"><el-input v-model="query.sybProductId" class="syb-input" clearable placeholder="商品 ID" @keyup.enter="search" /></el-form-item>
           <el-form-item label="PDD 订单号"><el-input v-model="query.pddOrderNo" class="order-input" clearable placeholder="订单号" @keyup.enter="search" /></el-form-item>
-          <el-form-item><el-button type="primary" :icon="Search" :disabled="Boolean(orderFilter.error)" @click="search">查询</el-button><el-button :icon="RefreshLeft" @click="reset">重置</el-button></el-form-item>
+          <el-form-item label="下单日期"><el-date-picker v-model="query.orderSubmittedRange" type="daterange" value-format="YYYY-MM-DD" range-separator="至" start-placeholder="开始日期" end-placeholder="结束日期" clearable style="width:260px" /></el-form-item>
+          <el-form-item><el-button type="primary" :icon="Search" :disabled="Boolean(orderFilter.error)" @click="search">查询</el-button><el-button :icon="RefreshLeft" @click="reset">重置</el-button><el-button :disabled="exporting || Boolean(orderFilter.error)" @click="exportExcel">{{ exporting ? `导出中 ${exportProgress.done}/${exportProgress.steps}` : '导出' }}</el-button></el-form-item>
         </el-form>
         <div class="batch-actions"><span class="selected-copy">已选择 <strong>{{ retrySelection.length }}</strong> 条</span><el-button type="warning" :disabled="retryCandidates.length === 0" :loading="retryDialog.saving" @click="openRetryDialog">重试（{{ retryCandidates.length }}）</el-button><el-button type="primary" plain :disabled="orderWritebackCandidates.length === 0" :loading="orderWriteback.saving" @click="submitOrderWriteback(orderWritebackCandidates)">批量回填 SYB（{{ orderWritebackCandidates.length }}）</el-button></div>
 
@@ -154,6 +155,8 @@ import { ElMessage, ElMessageBox } from 'element-plus'
 import { RefreshLeft, Search } from '@element-plus/icons-vue'
 import { authorizeRepurchase, cancelPurchaseTask, choosePurchaseMatching, getPurchaseTask, listPurchaseTasks, requeuePurchaseMatching, resolveUnknownPurchaseTask, retryPurchaseTasksBatch, reviewPurchasePayment, selectPurchaseWriteback, writebackPurchaseOrderNumbers } from '@/api/goauto/purchase-tasks'
 import { createRequestId } from '@/utils/request-id'
+import { saveExcel } from '@/utils/save-excel'
+import { EXPORT_MAX_ROWS, PURCHASE_EXPORT_HEADER, PURCHASE_EXPORT_NUMBER_COLS, exportFailureMessage, purchaseExportRow, runListExport } from '@/utils/list-export'
 import { listFailureSnapshots } from '@/api/goauto/purchase-failure-snapshots'
 import FailureSnapshotCell from './FailureSnapshotCell.vue'
 
@@ -169,9 +172,10 @@ export default {
   data() {
     return {
       loading: false, loadError: '', tasks: [], total: 0, statuses: [...statusOptions, { value: 'syb_writeback_succeeded', label: '已回填 SYB' }],
+      exporting: false, exportProgress: { done: 0, steps: 0 },
       detailSession: 0, snapshots: { items: {}, loading: false, error: false },
       orderWriteback: { open: false, saving: false, items: [] },
-      query: { page: 1, pageSize: 20, taskId: '', taskType: '', shopeeOrderNo: '', status: '', executionMode: 'live', sybProductId: '', pddOrderNo: '' },
+      query: { page: 1, pageSize: 20, taskId: '', taskType: '', shopeeOrderNo: '', status: '', executionMode: 'live', sybProductId: '', pddOrderNo: '', orderSubmittedRange: [] },
 	  detail: { open: false, loading: false, task: null, attempts: [], matching: null },
 	  matchingAction: { saving: false }, matchingDialog: { open: false, saving: false, color: '', size: '' },
 	  retrySelection: [],
@@ -227,14 +231,34 @@ export default {
       try { const r = await listPurchaseTasks(this.cleanQuery()); this.tasks = r.data.items || []; this.total = r.data.total || 0; this.retrySelection = []; this.$nextTick(() => this.$refs.taskTable?.clearSelection()) } catch (error) { this.tasks = []; this.total = 0; this.loadError = error?.message || '采购任务加载失败，请稍后重试' } finally { this.loading = false }
     },
     cleanQuery() {
-      const params = Object.fromEntries(Object.entries(this.query).filter(([key, value]) => key !== 'shopeeOrderNo' && value !== ''))
+      const params = Object.fromEntries(Object.entries(this.query).filter(([key, value]) => key !== 'shopeeOrderNo' && key !== 'orderSubmittedRange' && value !== ''))
+      const [orderSubmittedFrom, orderSubmittedTo] = this.query.orderSubmittedRange || []
+      if (orderSubmittedFrom) params.orderSubmittedFrom = orderSubmittedFrom
+      if (orderSubmittedTo) params.orderSubmittedTo = orderSubmittedTo
       const values = this.orderFilter.values
       if (values.length === 1) params.shopeeOrderNo = values[0]
       else if (values.length > 1) params.shopeeOrderNos = values
       return params
     },
     search() { this.query.page = 1; this.load() },
-    reset() { this.query = { page: 1, pageSize: 20, taskId: '', taskType: '', shopeeOrderNo: '', status: '', executionMode: 'live', sybProductId: '', pddOrderNo: '' }; this.load() },
+    reset() { this.query = { page: 1, pageSize: 20, taskId: '', taskType: '', shopeeOrderNo: '', status: '', executionMode: 'live', sybProductId: '', pddOrderNo: '', orderSubmittedRange: [] }; this.load() },
+    // #372: export every page of the filters as they are at click time (params are copied once).
+    async exportExcel() {
+      if (this.exporting || this.orderFilter.error) return
+      const filters = this.cleanQuery(); delete filters.page; delete filters.pageSize
+      this.exporting = true; this.exportProgress = { done: 0, steps: 0 }
+      try {
+        const result = await runListExport({
+          pageSize: 100, maxRows: EXPORT_MAX_ROWS, header: PURCHASE_EXPORT_HEADER, numberFormatCols: PURCHASE_EXPORT_NUMBER_COLS, filename: '采购导出',
+          fetchPage: async(pageNo, size) => { const r = await listPurchaseTasks({ ...filters, page: pageNo, pageSize: size }); return { items: r.data.items || [], total: r.data.total || 0 } },
+          mapRow: task => purchaseExportRow(task, this.statusLabel),
+          save: saveExcel,
+          onProgress: (done, steps) => { this.exportProgress = { done, steps } }
+        })
+        if (!result.ok) ElMessage.warning(exportFailureMessage(result, EXPORT_MAX_ROWS))
+        else ElMessage.success(`已导出 ${result.rows} 条；导出期间数据变化可能有少量差异`)
+      } catch (error) { ElMessage.error('导出失败，未生成文件') } finally { this.exporting = false }
+    },
     clearSnapshots() { this.detailSession++; this.snapshots = { items: {}, loading: false, error: false } },
     async loadSnapshots() {
       if (!this.isSnapshotAdmin || !this.detail.open || !this.detail.task || this.snapshots.loading) return

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

@@ -26,7 +26,7 @@
             <el-form-item label="解析状态"><el-select v-model="query.parseStatus" clearable placeholder="全部" style="width: 110px"><el-option label="成功" value="success" /><el-option label="失败" value="failed" /></el-select></el-form-item>
             <el-form-item label="处理阶段"><el-select v-model="query.processStage" clearable placeholder="全部" style="width: 132px" @change="onProcessStageChange"><el-option v-for="item in processStageOptions" :key="item.value" :label="item.label" :value="item.value" /></el-select></el-form-item>
             <el-form-item label="采购类型"><el-select v-model="query.purchaseType" style="width: 132px"><el-option label="需 PDD 采购" value="pdd" /><el-option label="无需 PDD 采购" value="excluded" /><el-option label="全部" value="all" /></el-select></el-form-item>
-            <el-form-item class="toolbar-actions"><el-button type="primary" :icon="Search" @click="search">查询</el-button><el-button :icon="RefreshLeft" @click="reset">重置</el-button><el-tooltip v-if="canPurchase" :content="aiMatchButtonReason" :disabled="!aiMatchButtonReason" placement="top"><span class="action-button-wrap"><el-button :loading="specMatchLoading" :disabled="purchaseReadinessLoading || specMatchLoading || aiMatchCandidates.length === 0 || aiMatchButtonOverLimit" @click="runBatchSpecMatch">AI 匹配<span class="action-count">{{ aiMatchCandidates.length }}</span></el-button></span></el-tooltip><el-tooltip v-if="canPurchase" :content="imageSearchButtonReason" :disabled="!imageSearchButtonReason" placement="top"><span class="action-button-wrap"><el-button type="success" plain :disabled="imageSearchRows.length === 0 || imageSearchButtonOverLimit" @click="openImageSearchBatch">图搜采集<span class="action-count">{{ imageSearchRows.length }}</span></el-button></span></el-tooltip><el-tooltip v-if="canPurchase" :content="collectionButtonReason" :disabled="!collectionButtonReason" placement="top"><span class="action-button-wrap"><el-button type="primary" :loading="purchaseReadinessLoading" :disabled="purchaseReadinessLoading || specMatchLoading || collectionCandidates.length === 0 || collectionButtonOverLimit" @click="openCollectionBatch">创建采集<span class="action-count action-count-primary">{{ collectionCandidates.length }}</span></el-button></span></el-tooltip><el-tooltip v-if="canPurchase" :content="purchaseButtonReason" :disabled="!purchaseButtonReason" placement="top"><span class="action-button-wrap"><el-button type="primary" :loading="purchaseReadinessLoading" :disabled="purchaseReadinessLoading || specMatchLoading || purchaseCandidates.length === 0 || purchaseButtonOverLimit" @click="openPurchaseBatch">创建采购<span class="action-count action-count-primary">{{ purchaseCandidates.length }}</span></el-button></span></el-tooltip><el-tooltip v-if="canPurchase" :content="returnMatchButtonReason" :disabled="!returnMatchButtonReason" placement="top"><span class="action-button-wrap"><el-button :loading="returnMatchBatchLoading" :disabled="purchaseReadinessLoading || returnMatchBatchLoading || returnConfirmBatchLoading || returnCancelBatchLoading || returnTransitionLoading || matchDetail.saving || returnMatchCandidateIds.length === 0 || returnMatchButtonOverLimit" @click="runBatchMatchReturns">匹配退货<span class="action-count">{{ returnMatchCandidateIds.length }}</span></el-button></span></el-tooltip><el-tooltip v-if="canPurchase" :content="returnCancelButtonReason" :disabled="!returnCancelButtonReason" placement="top"><span class="action-button-wrap"><el-button :loading="returnCancelBatchLoading" :disabled="Boolean(returnCancelButtonReason)" @click="runBatchCancelReturns">取消匹配<span class="action-count">{{ returnCancelCandidates.length }}</span></el-button></span></el-tooltip><el-tooltip v-if="canPurchase" :content="returnConfirmButtonReason" :disabled="!returnConfirmButtonReason" placement="top"><span class="action-button-wrap"><el-button type="success" plain :loading="returnConfirmBatchLoading" :disabled="Boolean(returnConfirmButtonReason)" @click="runBatchConfirmReturns">使用退货<span class="action-count">{{ returnConfirmCandidates.length }}</span></el-button></span></el-tooltip></el-form-item>
+            <el-form-item class="toolbar-actions"><el-button type="primary" :icon="Search" @click="search">查询</el-button><el-button :icon="RefreshLeft" @click="reset">重置</el-button><el-button :disabled="exporting" @click="exportExcel">{{ exporting ? `导出中 ${exportProgress.done}/${exportProgress.steps}` : '导出' }}</el-button><el-tooltip v-if="canPurchase" :content="aiMatchButtonReason" :disabled="!aiMatchButtonReason" placement="top"><span class="action-button-wrap"><el-button :loading="specMatchLoading" :disabled="purchaseReadinessLoading || specMatchLoading || aiMatchCandidates.length === 0 || aiMatchButtonOverLimit" @click="runBatchSpecMatch">AI 匹配<span class="action-count">{{ aiMatchCandidates.length }}</span></el-button></span></el-tooltip><el-tooltip v-if="canPurchase" :content="imageSearchButtonReason" :disabled="!imageSearchButtonReason" placement="top"><span class="action-button-wrap"><el-button type="success" plain :disabled="imageSearchRows.length === 0 || imageSearchButtonOverLimit" @click="openImageSearchBatch">图搜采集<span class="action-count">{{ imageSearchRows.length }}</span></el-button></span></el-tooltip><el-tooltip v-if="canPurchase" :content="collectionButtonReason" :disabled="!collectionButtonReason" placement="top"><span class="action-button-wrap"><el-button type="primary" :loading="purchaseReadinessLoading" :disabled="purchaseReadinessLoading || specMatchLoading || collectionCandidates.length === 0 || collectionButtonOverLimit" @click="openCollectionBatch">创建采集<span class="action-count action-count-primary">{{ collectionCandidates.length }}</span></el-button></span></el-tooltip><el-tooltip v-if="canPurchase" :content="purchaseButtonReason" :disabled="!purchaseButtonReason" placement="top"><span class="action-button-wrap"><el-button type="primary" :loading="purchaseReadinessLoading" :disabled="purchaseReadinessLoading || specMatchLoading || purchaseCandidates.length === 0 || purchaseButtonOverLimit" @click="openPurchaseBatch">创建采购<span class="action-count action-count-primary">{{ purchaseCandidates.length }}</span></el-button></span></el-tooltip><el-tooltip v-if="canPurchase" :content="returnMatchButtonReason" :disabled="!returnMatchButtonReason" placement="top"><span class="action-button-wrap"><el-button :loading="returnMatchBatchLoading" :disabled="purchaseReadinessLoading || returnMatchBatchLoading || returnConfirmBatchLoading || returnCancelBatchLoading || returnTransitionLoading || matchDetail.saving || returnMatchCandidateIds.length === 0 || returnMatchButtonOverLimit" @click="runBatchMatchReturns">匹配退货<span class="action-count">{{ returnMatchCandidateIds.length }}</span></el-button></span></el-tooltip><el-tooltip v-if="canPurchase" :content="returnCancelButtonReason" :disabled="!returnCancelButtonReason" placement="top"><span class="action-button-wrap"><el-button :loading="returnCancelBatchLoading" :disabled="Boolean(returnCancelButtonReason)" @click="runBatchCancelReturns">取消匹配<span class="action-count">{{ returnCancelCandidates.length }}</span></el-button></span></el-tooltip><el-tooltip v-if="canPurchase" :content="returnConfirmButtonReason" :disabled="!returnConfirmButtonReason" placement="top"><span class="action-button-wrap"><el-button type="success" plain :loading="returnConfirmBatchLoading" :disabled="Boolean(returnConfirmButtonReason)" @click="runBatchConfirmReturns">使用退货<span class="action-count">{{ returnConfirmCandidates.length }}</span></el-button></span></el-tooltip></el-form-item>
           </div>
           <div class="search-row search-row-secondary">
             <el-form-item label="创建时间"><el-date-picker v-model="query.createdAtRange" type="daterange" value-format="YYYY-MM-DD" range-separator="至" start-placeholder="开始日期" end-placeholder="结束日期" clearable /></el-form-item>
@@ -395,6 +395,8 @@ import { createPurchaseTasksBatch, matchPurchaseSpecsBatch, previewPurchaseTasks
 import { batchCreateCollectionTasks, batchCreateImageSearchCollectionTasks } from '@/api/goauto/collection-tasks'
 import { listCollectionRules } from '@/api/goauto/collection-rules'
 import { listReturnMatches, batchMatchReturns, getReturnMatch, confirmReturnMatch, cancelReturnMatch, remarkReturnMatch } from '@/api/goauto/return-matches'
+import { saveExcel } from '@/utils/save-excel'
+import { EXPORT_MAX_ROWS, SYB_PRODUCT_EXPORT_HEADER, SYB_PRODUCT_EXPORT_NUMBER_COLS, exportFailureMessage, isActiveReturnMatch, runListExport, sybProductExportRow } from '@/utils/list-export'
 import { createRequestId } from '@/utils/request-id'
 import { readPurchaseDevice, rememberPurchaseDevice } from '@/utils/purchase-device-preference'
 import ShopeeProductDetailDrawer from '../shopee-products/ShopeeProductDetailDrawer.vue'
@@ -430,6 +432,8 @@ export default {
       collectionBatchData: { ruleId: null, deviceId: null },
       collectionBatchRules: { ruleId: [{ required: true, message: '请选择采集规则', trigger: 'change' }] },
       query: { page: 1, pageSize: 200, shopIds: [], orderCodesText: '', parseStatus: '', processStage: '', purchaseType: 'pdd', createdAtRange: [] },
+      exporting: false,
+      exportProgress: { done: 0, steps: 0 },
       returnMatchByProductId: {},
       returnMatchLoading: false,
       returnMatchBatchLoading: false,
@@ -529,6 +533,34 @@ export default {
       }
     },
     search() { this.query.page = 1; this.load() },
+    // #372: export every page of the filters as they are at click time (params are copied once);
+    // return matches are read per batch of product ids, never per row.
+    async exportExcel() {
+      if (this.exporting) return
+      const orderCodes = this.normalizedOrderCodes()
+      if (orderCodes === null) return
+      const [createdFrom = '', createdTo = ''] = this.query.createdAtRange || []
+      const filters = { shopIds: [...this.query.shopIds], orderCodes: orderCodes.join(','), parseStatus: this.query.parseStatus, processStage: this.query.processStage, purchaseType: this.query.purchaseType, createdFrom, createdTo }
+      this.exporting = true; this.exportProgress = { done: 0, steps: 0 }
+      try {
+        const result = await runListExport({
+          pageSize: 500, maxRows: EXPORT_MAX_ROWS, header: SYB_PRODUCT_EXPORT_HEADER, numberFormatCols: SYB_PRODUCT_EXPORT_NUMBER_COLS, filename: 'SYB商品导出',
+          fetchPage: async(page, size) => { const r = await listSybProducts({ ...filters, page, pageSize: size }, { suppressErrorMessage: true }); return { items: r.data.items || [], total: r.data.total || 0 } },
+          enrichBatchSize: 200,
+          enrich: async items => {
+            const r = await listReturnMatches({ sybProductId: items.map(item => item.id) }, { suppressErrorMessage: true })
+            const byProduct = {}
+            for (const match of (r.data?.items || [])) if (isActiveReturnMatch(match) && !byProduct[match.sybProductId]) byProduct[match.sybProductId] = match
+            return items.map(item => ({ item, match: byProduct[item.id] || null }))
+          },
+          mapRow: ({ item, match }) => sybProductExportRow(item, match),
+          save: saveExcel,
+          onProgress: (done, steps) => { this.exportProgress = { done, steps } }
+        })
+        if (!result.ok) ElMessage.warning(exportFailureMessage(result, EXPORT_MAX_ROWS))
+        else ElMessage.success(`已导出 ${result.rows} 条；导出期间数据变化可能有少量差异`)
+      } catch (error) { ElMessage.error('导出失败，未生成文件') } finally { this.exporting = false }
+    },
     reset() { this.query = { page: 1, pageSize: 200, shopIds: [], orderCodesText: '', parseStatus: '', processStage: '', purchaseType: 'pdd', createdAtRange: [] }; this.load() },
     onPagination() {
       // Both controls may emit after a size change clamps the old page. Coalesce

web/tests/unit/list-export.test.cjs

@@ -0,0 +1,187 @@
+const { test } = require('node:test')
+const assert = require('node:assert/strict')
+const fs = require('node:fs')
+const path = require('node:path')
+
+const source = fs.readFileSync(path.join(__dirname, '../../src/utils/list-export.js'), 'utf8')
+const lib = new Function(source.replace(/^export /gm, '') + `
+return { EXPORT_MAX_ROWS, formatExportTime, formatExportStamp, centToYuan, splitYeekeVariation, purchaseExportRow, PURCHASE_EXPORT_HEADER,
+  sybProductExportRow, SYB_PRODUCT_EXPORT_HEADER, centToYuanNumber, PURCHASE_EXPORT_NUMBER_COLS, SYB_PRODUCT_EXPORT_NUMBER_COLS, exportFailureMessage, runListExport }`)()
+
+test('time and stamp use local time, empty and invalid stay empty', () => {
+  const date = new Date(2026, 9, 9, 8, 5, 3)
+  assert.equal(lib.formatExportTime(date.toISOString()), '2026-10-09 08:05:03')
+  assert.equal(lib.formatExportTime(null), '')
+  assert.equal(lib.formatExportTime(''), '')
+  assert.equal(lib.formatExportTime('not a date'), '')
+  assert.equal(lib.formatExportStamp(date), '20261009-080503')
+})
+
+test('cent to yuan keeps two decimals and leaves empty values empty', () => {
+  assert.equal(lib.centToYuan(12345), '123.45')
+  assert.equal(lib.centToYuan(5), '0.05')
+  assert.equal(lib.centToYuan(1000), '10.00')
+  assert.equal(lib.centToYuan(0), '0.00')
+  for (const value of [null, undefined, '']) assert.equal(lib.centToYuan(value), '')
+})
+
+test('yeeke variation splits at the first English or Chinese comma, none puts all in color', () => {
+  assert.deepEqual(lib.splitYeekeVariation('白色,L【建議65-75公斤】'), { color: '白色', size: 'L【建議65-75公斤】' })
+  assert.deepEqual(lib.splitYeekeVariation('黑色+白色，簡約,L'), { color: '黑色+白色', size: '簡約,L' })
+  assert.deepEqual(lib.splitYeekeVariation('均碼'), { color: '均碼', size: '' })
+  assert.deepEqual(lib.splitYeekeVariation(''), { color: '', size: '' })
+  assert.deepEqual(lib.splitYeekeVariation(undefined), { color: '', size: '' })
+})
+
+test('purchase row maps columns in order with status label, amount and blanks', () => {
+  assert.equal(lib.PURCHASE_EXPORT_HEADER.length, 9)
+  const row = lib.purchaseExportRow({
+    shopeeOrderNoSnapshot: '001', shopeeItemIdSnapshot: '5020', targetColorSnapshot: '白色', targetSizeSnapshot: 'L', quantity: 2,
+    status: 'order_created', pddOrderNo: 'PDD-1', orderSubmittedAt: new Date(2026, 9, 9, 1, 2, 3).toISOString(), pddOrderAmountCent: 3990,
+    receiverName: 'must not leak', address: 'must not leak'
+  }, value => ({ order_created: '订单已创建' })[value])
+  assert.deepEqual(row, ['001', '5020', '白色', 'L', 2, '订单已创建', 'PDD-1', '2026-10-09 01:02:03', 39.9])
+  assert.deepEqual(lib.purchaseExportRow({ quantity: 1 }), ['', '', '', '', 1, '', '', '', ''])
+  assert.equal(lib.purchaseExportRow({ shopeeOrderNoSnapshot: 'A', status: 'failed', pddOrderAmountCent: null })[8], '')
+  assert.equal(lib.purchaseExportRow({ pddOrderAmountCent: undefined })[8], '')
+  assert.equal(typeof row[8], 'number')
+  assert.equal(lib.purchaseExportRow({ pddOrderAmountCent: 0 })[8], 0)
+  assert.deepEqual(lib.PURCHASE_EXPORT_NUMBER_COLS, [8])
+  assert.equal(lib.PURCHASE_EXPORT_HEADER[8], '价格（元）')
+})
+
+test('cent to yuan number is numeric, zero stays zero, empty stays empty', () => {
+  assert.equal(lib.centToYuanNumber(1230), 12.3)
+  assert.equal(lib.centToYuanNumber(0), 0)
+  assert.equal(lib.centToYuanNumber('1230'), 12.3)
+  for (const value of [null, undefined, '', 'abc']) assert.equal(lib.centToYuanNumber(value), '')
+})
+
+test('syb product row uses only an active match and ignores cancelled ones', () => {
+  const product = { orderCode: 'O1', shopName: 'shop-a', shopeeItemId: '99', unitPriceCent: 1230, targetColor: '白色', targetSize: 'L', quantity: 1 }
+  const matchedAt = new Date(2026, 9, 9, 9, 0, 0).toISOString()
+  assert.deepEqual(lib.SYB_PRODUCT_EXPORT_HEADER, ['SYB订单', '店铺', '虾皮商品ID', 'SYB售价（TWD）', 'SYB颜色', 'SYB尺码', 'SYB数量', 'yeeke颜色', 'yeeke尺码', 'yeeke数量', '匹配时间'])
+  assert.deepEqual(lib.SYB_PRODUCT_EXPORT_NUMBER_COLS, [3])
+  assert.deepEqual(lib.sybProductExportRow(product, { status: 'confirmed', variationName: '白色，L', yeekeQuantity: 3, matchedAt }),
+    ['O1', 'shop-a', '99', 12.3, '白色', 'L', 1, '白色', 'L', 3, '2026-10-09 09:00:00'])
+  assert.deepEqual(lib.sybProductExportRow(product, { status: 'matched', variationName: '均碼', yeekeQuantity: 1, matchedAt }).slice(7, 10), ['均碼', '', 1])
+  assert.deepEqual(lib.sybProductExportRow(product, { status: 'cancelled', variationName: 'x', yeekeQuantity: 1, matchedAt }), ['O1', 'shop-a', '99', 12.3, '白色', 'L', 1, '', '', '', ''])
+  assert.deepEqual(lib.sybProductExportRow(product, null), ['O1', 'shop-a', '99', 12.3, '白色', 'L', 1, '', '', '', ''])
+  assert.equal(lib.sybProductExportRow({ ...product, unitPriceCent: 0 }, null)[3], 0)
+  for (const value of [null, undefined]) assert.equal(lib.sybProductExportRow({ ...product, unitPriceCent: value }, null)[3], '')
+  for (const value of [null, undefined]) assert.equal(lib.sybProductExportRow({ ...product, shopName: value }, null)[1], '')
+})
+
+// Runs the real Export2Excel writer with file-saver stubbed and reads the xlsx back.
+function writeWorkbook(options) {
+  const XLSX = require('xlsx')
+  const src = fs.readFileSync(path.join(__dirname, '../../src/vendor/Export2Excel.js'), 'utf8')
+    .replace(/^import .*$/gm, '').replace(/^export function/gm, 'function')
+  let blobParts
+  class FakeBlob { constructor(parts) { blobParts = parts } }
+  new Function('XLSX', 'saveAs', 'Blob', 'opts', src + '\nexport_json_to_excel(opts)')(XLSX, () => {}, FakeBlob, options)
+  return XLSX.read(blobParts[0], { type: 'array', cellNF: true }).Sheets.SheetJS
+}
+
+test('excel writer makes numeric cells, 0.00 format only for requested columns', () => {
+  const header = ['a', 'b']
+  const data = [[12.3, 12.3], [0, 0], ['', '']]
+  const withFmt = writeWorkbook({ header, data, filename: 't', numberFormatCols: [0] })
+  assert.equal(withFmt.A2.t, 'n'); assert.equal(withFmt.A2.v, 12.3); assert.equal(withFmt.A2.z, '0.00')
+  assert.equal(withFmt.A3.t, 'n'); assert.equal(withFmt.A3.v, 0)
+  assert.equal(withFmt.B2.t, 'n'); assert.notEqual(withFmt.B2.z, '0.00')
+  const plain = writeWorkbook({ header, data, filename: 't' })
+  assert.equal(plain.A2.t, 'n'); assert.notEqual(plain.A2.z, '0.00')
+})
+
+test('real export row types and format end up in the sheet', () => {
+  const header = lib.SYB_PRODUCT_EXPORT_HEADER
+  const rows = [
+    lib.sybProductExportRow({ orderCode: 'O1', shopName: 'shop-a', unitPriceCent: 1230 }, null),
+    lib.sybProductExportRow({ orderCode: 'O2', unitPriceCent: 0 }, null),
+    lib.sybProductExportRow({ orderCode: 'O3', unitPriceCent: null }, null)
+  ]
+  const sheet = writeWorkbook({ header, data: rows, filename: 't', numberFormatCols: lib.SYB_PRODUCT_EXPORT_NUMBER_COLS })
+  assert.equal(sheet.B1.v, '店铺')
+  assert.equal(sheet.B2.t, 's'); assert.equal(sheet.B2.v, 'shop-a'); assert.notEqual(sheet.B2.z, '0.00')
+  assert.equal(sheet.D1.v, 'SYB售价（TWD）')
+  assert.equal(sheet.D2.t, 'n'); assert.equal(sheet.D2.v, 12.3); assert.equal(sheet.D2.z, '0.00')
+  assert.equal(sheet.D3.t, 'n'); assert.equal(sheet.D3.v, 0)
+  assert.equal(sheet.D4.v, ''); assert.notEqual(sheet.D4.t, 'n')
+})
+
+function harness(total, options = {}) {
+  const calls = []; const saved = []; const progress = []
+  const pageSize = options.pageSize || 100
+  const run = () => lib.runListExport({
+    pageSize, header: ['id'], filename: '测试', mapRow: item => [item.id],
+    fetchPage: async (page, size) => {
+      calls.push(page)
+      if (options.failPage === page) throw new Error('boom')
+      const start = (page - 1) * size
+      return { total, items: Array.from({ length: Math.max(0, Math.min(size, total - start)) }, (_, i) => ({ id: start + i + 1 })) }
+    },
+    save: async file => { saved.push(file) }, onProgress: (done, steps) => progress.push([done, steps]), ...options.extra
+  })
+  return { run, calls, saved, progress }
+}
+
+test('reads every page, reports progress, saves once with a timestamped name', async () => {
+  const h = harness(250)
+  const result = await h.run()
+  assert.deepEqual(result, { ok: true, total: 250, rows: 250 })
+  assert.deepEqual(h.calls, [1, 2, 3])
+  assert.deepEqual(h.progress, [[1, 3], [2, 3], [3, 3]])
+  assert.equal(h.saved.length, 1)
+  assert.equal(h.saved[0].data.length, 250)
+  assert.deepEqual(h.saved[0].data[249], [250])
+  assert.match(h.saved[0].filename, /^测试_\d{8}-\d{6}$/)
+})
+
+test('exactly 5000 rows are allowed, 5001 is refused after reading only page 1', async () => {
+  const ok = harness(5000, { pageSize: 500 })
+  assert.equal((await ok.run()).ok, true)
+  assert.equal(ok.calls.length, 10)
+  const over = harness(5001, { pageSize: 500 })
+  const result = await over.run()
+  assert.deepEqual(result, { ok: false, reason: 'too_many', total: 5001 })
+  assert.deepEqual(over.calls, [1])
+  assert.equal(over.saved.length, 0)
+  assert.equal(lib.exportFailureMessage(result), '共 5001 条，超过 5000 条上限，请缩小筛选范围')
+})
+
+test('empty result does not save', async () => {
+  const h = harness(0)
+  const result = await h.run()
+  assert.deepEqual(result, { ok: false, reason: 'empty', total: 0 })
+  assert.equal(h.saved.length, 0)
+  assert.match(lib.exportFailureMessage(result), /没有数据/)
+})
+
+test('a failing page stops the export without saving', async () => {
+  const h = harness(450, { failPage: 3 })
+  const result = await h.run()
+  assert.equal(result.ok, false)
+  assert.equal(result.reason, 'page_failed')
+  assert.equal(result.page, 3)
+  assert.deepEqual(h.calls, [1, 2, 3])
+  assert.equal(h.saved.length, 0)
+  assert.equal(lib.exportFailureMessage(result), '导出失败：第 3 页读取失败，未生成文件')
+  const first = harness(10, { failPage: 1 })
+  assert.equal((await first.run()).page, 1)
+  assert.equal(first.saved.length, 0)
+})
+
+test('enrich runs per batch (not per row), counts in progress, and a failure saves nothing', async () => {
+  const batches = []
+  const h = harness(450, { pageSize: 200, extra: { enrichBatchSize: 200, enrich: async items => { batches.push(items.length); return items.map(item => ({ ...item, id: item.id * 10 })) } } })
+  const result = await h.run()
+  assert.equal(result.ok, true)
+  assert.deepEqual(batches, [200, 200, 50])
+  assert.deepEqual(h.saved[0].data[0], [10])
+  assert.deepEqual(h.progress[h.progress.length - 1], [6, 6])
+  const bad = harness(450, { pageSize: 200, extra: { enrich: async () => { throw new Error('boom') } } })
+  const failed = await bad.run()
+  assert.equal(failed.reason, 'enrich_failed')
+  assert.equal(bad.saved.length, 0)
+})