fix(android): verify scoped final purchase spec evidence (#374)

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

@@ -167,6 +167,8 @@ data class ParsedPddScreen(
     val quantityInputCount: Int = 0,
     /** #331: address entry, payment entry and quantity input share one bounded panel container. */
     val requiredEvidenceSameContainer: Boolean = false,
+    /** Only populated by the final-confirmation opt-in; existing selectedSummary behavior is unchanged. */
+    val finalSelectionSummaries: List<String> = emptyList(),
 ) {
     /** The three #331 required spec-panel items are all visible. */
     val hasRequiredPanelEvidence: Boolean get() = hasAddressEntry && hasPaymentEntry && hasQuantityInput
@@ -265,7 +267,7 @@ object PddScreenParser {
     /** Whole-sheet containers are clickable too; a real entry row stays well below this share of the screen height. */
     private const val ENTRY_ROW_MAX_HEIGHT_PERCENT = 30
 
-    fun parse(snapshot: UiSnapshot, config: PddCollectorConfig, goodsId: String, evidence: PageEvidence?, purchaseContext: PurchasePanelContext? = null): ParsedPddScreen {
+    fun parse(snapshot: UiSnapshot, config: PddCollectorConfig, goodsId: String, evidence: PageEvidence?, purchaseContext: PurchasePanelContext? = null, forFinalConfirmation: Boolean = false): ParsedPddScreen {
         val visibleNodes = snapshot.nodes.filter { it.visible }
         val visible = visibleNodes.mapNotNull { node ->
             val descendants = descendants(node, visibleNodes)
@@ -422,9 +424,12 @@ object PddScreenParser {
                         )
                     }
                     .toList()
-                    .groupBy(VisibleSpecValue::rawText)
-                    .map { (_, sameLabel) ->
-                        sameLabel.minBy { option -> safeOptionRank(option.node, visibleNodes) }
+                    .let { physicalOptions ->
+                        // Keep optionBlock's physical parent/child aggregation in both modes.
+                        // Only final confirmation must detect separate same-label option blocks.
+                        if (forFinalConfirmation) physicalOptions else physicalOptions
+                            .groupBy(VisibleSpecValue::rawText)
+                            .map { (_, sameLabel) -> sameLabel.minBy { option -> safeOptionRank(option.node, visibleNodes) } }
                     }
                 if (values.isNotEmpty()) add(VisibleDimension(dimensionKey, heading.label, values))
             }
@@ -471,6 +476,7 @@ object PddScreenParser {
             else -> SpecPanelType.UNKNOWN
         }
         val panelOpen = specPanelType != SpecPanelType.UNKNOWN
+        var unprefixedSummaryCandidates = emptyList<String>()
         val unprefixedSummary = if (structuredSelectionPanel) {
             val quantity = quantityInputs.single()
             val knownColors = (dimensions.filter { it.key == "color" }.flatMap { it.values }.map { it.text } +
@@ -486,6 +492,7 @@ object PddScreenParser {
                         knownColors.any { SpecValueNormalizer.summaryHasExactToken(node.label, it) }
                 }.map { it.label }.distinct()
                 if (candidates.isNotEmpty()) {
+                    unprefixedSummaryCandidates = candidates
                     summary = candidates.singleOrNull()
                     break
                 }
@@ -574,6 +581,12 @@ object PddScreenParser {
             hasQuantityAdjustControls = hasQuantityAdjustControls,
             quantityInputCount = quantityInputs.size,
             requiredEvidenceSameContainer = requiredEvidenceSameContainer,
+            finalSelectionSummaries = if (forFinalConfirmation) {
+                // Use own node labels, not labels propagated into clickable ancestors.
+                (visibleNodes.map(SnapshotNode::label).filter { label ->
+                    textAliases.selection.selectedPrefixes.any { label.startsWith(it) }
+                } + unprefixedSummaryCandidates).distinct()
+            } else emptyList(),
             explicitSpecEntryCount = explicitSpecEntries.size,
             nestedSpecEntryCount = nestedSpecEntries.size,
             bottomPurchaseEntryCount = bottomSpecEntries.size,

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

@@ -321,10 +321,7 @@ class PurchaseLiveAutomation(
         val submit = finalSubmitTargets(snapshot)
         if (submit.size != 1) fail("PURCHASE_SUBMIT_TARGET_AMBIGUOUS", "创建订单按钮不是唯一目标，禁止创建订单")
         val screen = PddScreenParser.parse(snapshot, PurchaseRehearsalExecutor.DEFAULT_COLLECTOR, input.goodsId, null)
-        val selected = listOf(input.mappedColor, input.mappedSize).filter(String::isNotBlank)
-        if (selected.any { value -> screen.selectedSummary?.contains(value) != true && snapshot.nodes.none { it.visible && it.label.contains(value) } }) {
-            fail("PURCHASE_SPEC_NOT_MATCHED", "创建订单前规格复核失败")
-        }
+        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 quantities = snapshot.nodes.filter { it.visible && it.enabled && it.className?.endsWith("EditText") == true }.mapNotNull { it.label.toLongOrNull() }

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

@@ -13,6 +13,20 @@ object SpecValueNormalizer {
 
     fun normalizeSize(value: String): String = normalizeTrailingPrice(value)
 
+    /** Final purchase confirmation only: display equivalents, never semantic/content removal. */
+    fun normalizeFinalConfirmation(value: String): String = buildString {
+        value.forEach { ch ->
+            append(when (ch) {
+                '【', '〔', '［' -> '['
+                '】', '〕', '］' -> ']'
+                '（' -> '('
+                '）' -> ')'
+                in 'Ａ'..'Ｚ', in 'ａ'..'ｚ', in '０'..'９' -> (ch.code - 0xFEE0).toChar()
+                else -> if (ch.isWhitespace()) ' ' else ch
+            })
+        }
+    }.replace(Regex(" +"), " ").trim()
+
     /** The same terminal-price grammar as normalization; never reads numbers inside a spec. */
     internal fun trailingPriceAmount(value: String): java.math.BigDecimal? =
         trailingPrice.find(value)?.value?.replace(currency, "")?.trim()?.toBigDecimalOrNull()

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

@@ -0,0 +1,241 @@
+package cn.ilapage.goauto.agent
+
+import cn.ilapage.goauto.agent.automation.*
+import org.junit.Assert.*
+import org.junit.Test
+
+/** Final capture only; derived from the existing #331/#332 bounded purchase-sheet fixtures. */
+class PurchaseFinalSpecConfirmationTest {
+    @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 `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 `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 `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
+            } }
+        rejects(base)
+        rejects(base.mapNodes { if (it.path.endsWith("extra/o")) it.copy(text = "黑色") else it })
+    }
+
+    @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, "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())
+    }
+
+    @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) }
+    }
+
+    @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)
+            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.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(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 clickFresh(target: SnapshotNode): FreshActionResult = error("final confirmation must be read only")
+            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 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, "_cg374"))
+    }
+    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, 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)
+            fail("expected $expectedCode")
+        } catch (failure: PurchaseLiveException) {
+            assertEquals(expectedCode, failure.code)
+            if (expectedCode == "PURCHASE_SPEC_NOT_MATCHED") {
+                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 = "示例区示例路374号_cg374" }
+}

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

@@ -8,6 +8,15 @@ import org.junit.Assert.assertTrue
 import org.junit.Test
 
 class SpecValueNormalizerTest {
+    @Test
+    fun `final confirmation maps only display brackets alphanumerics and whitespace`() {
+        assertEquals("[白][黑][灰](薄款) RW12 XL", SpecValueNormalizer.normalizeFinalConfirmation(" 【白】〔黑〕［灰］（薄款）　ＲＷ１２\t\nXL "))
+        assertEquals("白色,加绒：XL ¥19.60 ① 2件", SpecValueNormalizer.normalizeFinalConfirmation("白色,加绒：XL ¥19.60 ① 2件"))
+        assertEquals("xl", SpecValueNormalizer.normalizeFinalConfirmation("xl"))
+        assertEquals("【白色】 ＸＬ", SpecValueNormalizer.normalizeColor("【白色】 ＸＬ"))
+        assertEquals("【白色】 ＸＬ", SpecValueNormalizer.normalizeSize("【白色】 ＸＬ"))
+    }
+
     @Test
     fun `only trailing price is removed`() {
         assertEquals("紫色", SpecValueNormalizer.normalizeColor("紫色  ¥15.78"))