fix(purchase): widen SYB writeback backoff, cover CheckSession, improve message (#330 review)

Address review findings on 01510a8:

1. BLOCKER: sessionRetryBackoff summed to 30min, shorter than the up-to-
   ~60min gap between a session dying and the next hourly SYB sync
   refreshing it. Changed to 5m/10m/15m/30m/30m (total 90min across
   maxSessionRetryAttempts=6), updated the code comment to state the
   ~90min > one hourly sync period rationale, and added
   TestSessionRetryBackoffTotalExceedsHourlySyncWindow to guard it.

2. Test gap: the CheckSession probe added inside
   restoreOrderWritebackClient was only exercised through a fake
   Factory, never through a real sybclient.Client. Added
   httptest-backed tests that run restoreOrderWritebackClient against
   an emulated /am/user/get (matching the envelope shape in
   sybclient/client.go's `envelope` type): valid session returns a
   client, mismatched username maps to ErrSessionInvalid, 5xx/timeout
   map to a non-invalid error — each asserting the syb_session row is
   left untouched. Added an end-to-end worker test using the real
   Factory against the invalid-session server, asserting
   failed/SYB_SESSION_UNAVAILABLE with a scheduled backoff and an
   intact session row.

3. sessionUnavailableMessage: renamed the default category to
   "会话恢复失败（网络/其他）" and wrapped every category in an
   actionable template ("SYB会话不可用（<类别>），将自动重试；如持续
   失败请恢复登录后重试"), still well under the 300-char column limit
   and free of raw error text/credentials.

Tests: go vet ./app/goauto/purchase/... (clean); go test
./app/goauto/purchase/... (ok, 3.4s, includes the new httptest-backed
CheckSession coverage and the backoff-window guard).

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

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

@@ -19,7 +19,7 @@ data class FinalConfirmationEvidence(
     val activityName: String,
 )
 
-data class PurchaseOrderEvidence(val orderNo: String, val submittedAt: String)
+data class PurchaseOrderEvidence(val orderNo: String, val submittedAt: String, val pddOrderAmountCent: Long? = null)
 data class PurchaseOrderReadFailure(
     val code: String,
     val message: String,
@@ -362,7 +362,17 @@ class PurchaseLiveAutomation(
         var orderDetailEntryOpened = false
         var wechatRestorePendingSamples = 0
         var consecutiveEmptySnapshots = 0
-        repeat(ORDER_RESULT_MAX_SAMPLES) { index ->
+        var unpaidStartSample: Int? = null
+        var unpaidSwipes = 0
+        repeat(ORDER_RESULT_MAX_SAMPLES + ORDER_RESULT_UNPAID_MAX_SAMPLES) { index ->
+            // The first unpaid page receives its own bounded budget, even after a long handoff.
+            // Never reset it on repeated labels or navigation back to payment.
+            val unpaidStart = unpaidStartSample
+            if ((unpaidStart == null && index >= ORDER_RESULT_MAX_SAMPLES) ||
+                (unpaidStart != null && index - unpaidStart >= ORDER_RESULT_UNPAID_MAX_SAMPLES)) {
+                val failure = orderEvidenceFailure(labels)
+                return unknown(failure.code, failure.message)
+            }
             val snapshot = driver.capture()
             if (snapshot.packageName.isNullOrBlank()) {
                 consecutiveEmptySnapshots++
@@ -430,8 +440,16 @@ class PurchaseLiveAutomation(
                 return@repeat
             }
             consecutivePaymentSamplesAfterBack = 0
-            if (unpaidContextVisible) paymentPageObserved = true
+            if (unpaidContextVisible) {
+                paymentPageObserved = true
+                if (unpaidStartSample == null) unpaidStartSample = index
+            }
             if (!orderContextVisible && !unpaidContextVisible) {
+                if (unpaidStartSample != null) {
+                    // After reaching the unpaid page only observe; never click a newly exposed control.
+                    pause(ORDER_RESULT_SAMPLE_INTERVAL_MS)
+                    return@repeat
+                }
                 val entries = orderDetailEntryTargets(snapshot)
                 if (entries.size > 1) {
                     return unknown("PURCHASE_ORDER_DETAIL_ENTRY_AMBIGUOUS", "订单详情入口不唯一，已停止只读核单")
@@ -454,7 +472,13 @@ class PurchaseLiveAutomation(
             }
             currentLabels.forEach(labels::add)
             parseOrderEvidence(labels)?.let { return it }
-            if (index > 0 && index % ORDER_RESULT_SCROLL_SAMPLE_INTERVAL == 0) {
+            if (unpaidStartSample != null && unpaidSwipes < ORDER_RESULT_UNPAID_MAX_SWIPES) {
+                unpaidSwipes++
+                driver.swipePurchase(SwipeDirection.UP, 400)
+                pause(ORDER_RESULT_UNPAID_SETTLE_MS)
+                return@repeat
+            }
+            if (unpaidStartSample == null && index > 0 && index % ORDER_RESULT_SCROLL_SAMPLE_INTERVAL == 0) {
                 driver.swipePurchase(SwipeDirection.UP, 400)
             }
             pause(ORDER_RESULT_SAMPLE_INTERVAL_MS)
@@ -728,7 +752,18 @@ class PurchaseLiveAutomation(
             runCatching { SimpleDateFormat(pattern, Locale.ROOT).apply { isLenient = false; timeZone = TimeZone.getTimeZone("Asia/Shanghai") }.parse(normalized) }.getOrNull()
         } ?: return null
         val output = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'", Locale.ROOT).apply { timeZone = TimeZone.getTimeZone("UTC") }.format(parsed)
-        return PurchaseOrderEvidence(orderNumbers.single(), output)
+        return PurchaseOrderEvidence(orderNumbers.single(), output, parsePayableAmount(labels))
+    }
+
+    private fun parsePayableAmount(labels: Collection<String>): Long? {
+        val amounts = labels.flatMap { label ->
+            PAYABLE_AMOUNT.findAll(label).map { match ->
+                runCatching { match.groupValues[1].toBigDecimal().movePointRight(2).longValueExact() }.getOrNull()
+            }.toList()
+        }
+        // Repeated parent/child labels are fine; conflicting/overflow amounts are omitted.
+        if (amounts.any { it == null }) return null
+        return amounts.distinct().singleOrNull()
     }
 
     private fun orderEvidenceFailure(labels: Collection<String>): PurchaseOrderReadFailure {
@@ -764,6 +799,7 @@ class PurchaseLiveAutomation(
         val UNPAID_MARKERS = listOf("待付款", "待支付", "去支付")
         val ORDER_DETAIL_ENTRY_MARKERS = setOf("查看订单", "订单详情")
         val ORDER_CONTEXT_MARKERS = listOf("订单编号", "订单号", "下单时间", "创建时间")
+        val PAYABLE_AMOUNT = Regex("(?<![\\p{L}])应付[ \\t:：,，]*[¥￥]?[ \\t]*(\\d+(?:\\.\\d{1,2})?)[ \\t]*元(?![0-9.])")
         val ORDER_NO = Regex("(?:订单编号|订单号)\\s*[:：]?\\s*([A-Za-z0-9-]{6,64})")
         val ORDER_TIME = Regex("(?:下单时间|创建时间)\\s*[:：]?\\s*(20[0-9]{2}[-/.年][0-9]{1,2}[-/.月][0-9]{1,2}日?\\s+[0-9]{1,2}:[0-9]{2}(?::[0-9]{2})?)")
         val ANDROID_CHOOSER_PACKAGES = setOf("android", "com.android.intentresolver")
@@ -777,7 +813,10 @@ class PurchaseLiveAutomation(
         const val ORDER_RESULT_MAX_SAMPLES = 60
         const val ORDER_RESULT_MAX_EMPTY_SAMPLES = 15
         const val ORDER_RESULT_WECHAT_RESTORE_MAX_SAMPLES = 15
-        const val ORDER_RESULT_PAYMENT_POST_BACK_MAX_SAMPLES = 3
+        const val ORDER_RESULT_PAYMENT_POST_BACK_MAX_SAMPLES = 25
+        const val ORDER_RESULT_UNPAID_MAX_SAMPLES = 30
+        const val ORDER_RESULT_UNPAID_MAX_SWIPES = 4
+        const val ORDER_RESULT_UNPAID_SETTLE_MS = 500L
         const val ORDER_RESULT_SCROLL_SAMPLE_INTERVAL = 15
         const val ORDER_RESULT_SAMPLE_INTERVAL_MS = 200L
         const val SPEC_CONFIRMATION_MAX_SAMPLES = 20

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

@@ -79,6 +79,7 @@ data class PurchaseExecutionOutcome(
     val actualUnitPriceCent: Long? = null,
     // 仅 order_result_unknown 有意义：见 PurchaseOrderReadFailure 的说明（#302）。
     val paymentPageObserved: Boolean = false,
+    val pddOrderAmountCent: Long? = null,
 )
 
 class PurchaseRehearsalExecutor(
@@ -154,7 +155,7 @@ class PurchaseRehearsalExecutor(
                 }
                 PurchaseActionType.READ_ORDER_RESULT -> {
                     if (!irreversibleStarted) failure("PURCHASE_RULE_INVALID", "尚未进入创建订单边界")
-                    else live.readOrderResult()?.let { PurchaseExecutionOutcome("order_created", message = "订单已创建，等待人工检查和支付", pddOrderNo = it.orderNo, orderSubmittedAt = it.submittedAt, actualUnitPriceCent = observedPrice) }
+                    else live.readOrderResult()?.let { PurchaseExecutionOutcome("order_created", message = "订单已创建，等待人工检查和支付", pddOrderNo = it.orderNo, orderSubmittedAt = it.submittedAt, actualUnitPriceCent = observedPrice, pddOrderAmountCent = it.pddOrderAmountCent) }
                         ?: live.lastOrderReadFailure.let { readFailure ->
                             PurchaseExecutionOutcome(
                                 "order_result_unknown",

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

@@ -724,7 +724,7 @@ class AgentForegroundService : Service() {
                             paymentPageObserved = readFailure?.paymentPageObserved ?: false,
                         )
                     } else {
-                        PurchaseExecutionOutcome("order_created", message = "订单已创建，等待人工检查和支付", pddOrderNo = evidence.orderNo, orderSubmittedAt = evidence.submittedAt)
+                        PurchaseExecutionOutcome("order_created", message = "订单已创建，等待人工检查和支付", pddOrderNo = evidence.orderNo, orderSubmittedAt = evidence.submittedAt, pddOrderAmountCent = evidence.pddOrderAmountCent)
                     }
                     val requestId = UUID.randomUUID().toString()
                     purchaseStore.completeAndEnqueue(interrupted.taskId, interrupted.attemptId, requestId, purchaseResultPayload(requestId, interrupted.attemptId, outcome))

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

@@ -24,5 +24,8 @@ internal fun purchaseResultPayload(
         outcome.pddOrderNo?.let { put("pddOrderNo", it) }
         outcome.orderSubmittedAt?.let { put("orderSubmittedAt", it) }
         outcome.actualUnitPriceCent?.let { put("actualUnitPriceCent", it) }
+        if (outcome.resultType == "order_created") {
+            outcome.pddOrderAmountCent?.let { put("pddOrderAmountCent", it) }
+        }
     }
     .toString()

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

@@ -18,6 +18,104 @@ import org.junit.Assert.assertTrue
 import org.junit.Test
 
 class PurchaseLiveAutomationTest {
+    @Test
+    fun `two second payment transition and two needed scrolls yield order and payable amount without clicks`() {
+        val driver = ReadOnlyOrderDriver(paymentMs = 2500)
+        val order = PurchaseLiveAutomation(driver, pause = { driver.elapsed += it }).readOrderResult()
+        assertEquals("PDD-DEMO-325", order?.orderNo)
+        assertEquals("2026-09-19T03:21:43Z", order?.submittedAt)
+        assertEquals(1300L, order?.pddOrderAmountCent)
+        assertEquals(1, driver.backs)
+        assertEquals(2, driver.swipes)
+        assertEquals(0, driver.clicks)
+    }
+
+    @Test
+    fun `unpaid page arriving near original limit gets independent read budget`() {
+        val driver = ReadOnlyOrderDriver(preludeSamples = 58)
+        val order = PurchaseLiveAutomation(driver, pause = { driver.elapsed += it }).readOrderResult()
+        assertEquals("PDD-DEMO-325", order?.orderNo)
+        assertTrue(driver.captures > 60)
+        assertEquals(2, driver.swipes)
+        assertEquals(0, driver.clicks)
+    }
+
+    @Test
+    fun `unpaid scrolling is immediate and bounded when order never becomes visible`() {
+        val driver = ReadOnlyOrderDriver(requiredSwipes = 100)
+        val automation = PurchaseLiveAutomation(driver, pause = { driver.elapsed += it })
+        assertEquals(null, automation.readOrderResult())
+        assertEquals(4, driver.swipes)
+        assertEquals(0L, driver.firstSwipeAt)
+        assertTrue(driver.captures <= 30)
+        assertEquals(0, driver.clicks)
+    }
+
+    @Test
+    fun `already visible order never scrolls and missing or conflicting payable amount never blocks order`() {
+        val cases = listOf(
+            emptyList<String>() to null,
+            listOf("拼单价¥16", "平台优惠-¥3", "实付:13元") to null,
+            listOf("应付:13元", "应付:14元") to null,
+            listOf("应付:-13元", "应付:13.123元", "预计应付:13元") to null,
+            listOf("应付:999999999999999999999元") to null,
+            listOf("应付:13.20元", "应付:13.20元") to 1320L,
+            listOf("应付:0元") to 0L,
+        )
+        for ((amounts, expected) in cases) {
+            val driver = ReadOnlyOrderDriver(requiredSwipes = 0, amounts = amounts)
+            val order = PurchaseLiveAutomation(driver, pause = {}).readOrderResult()
+            assertEquals("PDD-DEMO-325", order?.orderNo)
+            assertEquals(expected, order?.pddOrderAmountCent)
+            assertEquals(0, driver.swipes)
+            assertEquals(0, driver.clicks)
+        }
+    }
+
+    private class ReadOnlyOrderDriver(
+        val paymentMs: Long = 0,
+        val preludeSamples: Int = 0,
+        val requiredSwipes: Int = 2,
+        val amounts: List<String> = listOf("拼单价¥16", "平台优惠-¥3", "已优惠3元使用3元平台无门槛券,应付:,13元,(免运费)"),
+    ) : PurchaseUiDriver by LiveDriver() {
+        var elapsed = 0L
+        var captures = 0
+        var backs = 0
+        var swipes = 0
+        var clicks = 0
+        var firstSwipeAt: Long? = null
+        override fun capture(): UiSnapshot {
+            captures++
+            if (captures <= preludeSamples) return UiSnapshot(PDD, ACTIVITY, emptyList())
+            if (elapsed < paymentMs) return UiSnapshot(PDD, "com.xunmeng.pinduoduo.app_pay.core.PayActivity", listOf(node("立即支付")))
+            return UiSnapshot(PDD, ACTIVITY, buildList {
+                add(node("待付款"))
+                // Amount scrolls away before the order fields become visible.
+                if (swipes == 0) amounts.forEach { add(node(it)) }
+                add(node("订单号：PDD-DEMO-325", swipes >= requiredSwipes))
+                add(node("下单时间：2026-09-19 11:21:43", swipes >= requiredSwipes))
+                add(node("去支付"))
+            })
+        }
+        override fun backPurchase(): Boolean { backs++; return true }
+        override fun swipePurchase(direction: SwipeDirection, durationMs: Long): Boolean {
+            assertEquals(SwipeDirection.UP, direction)
+            assertTrue(elapsed >= paymentMs)
+            if (firstSwipeAt == null) firstSwipeAt = elapsed
+            swipes++
+            return true
+        }
+        override fun clickFresh(target: SnapshotNode): FreshActionResult {
+            clicks++
+            throw AssertionError("Read-only unpaid branch must never click")
+        }
+        private fun node(text: String, visible: Boolean = true) = SnapshotNode(
+            text, null, text, null, null, "android.widget.TextView",
+            NodeBounds(0, 100, 500, if (visible) 180 else 100),
+            false, false, false, false, true, visible,
+        )
+    }
+
     @Test
     fun `verified spec panel advances through one exact confirm target`() {
         val driver = SpecConfirmationDriver()
@@ -358,10 +456,10 @@ class PurchaseLiveAutomationTest {
         assertEquals("PURCHASE_ORDER_PAYMENT_REPEATED", automation.lastOrderReadFailure?.code)
         assertEquals(
             "支付页安全返回后持续无订单证据，已停止自动核单" +
-                "[paymentBackAttempts=1;consecutivePaymentSamplesAfterBack=3]",
+                "[paymentBackAttempts=1;consecutivePaymentSamplesAfterBack=25]",
             automation.lastOrderReadFailure?.message,
         )
-        assertEquals(4, driver.postSubmitCaptureCount)
+        assertEquals(26, driver.postSubmitCaptureCount)
         assertEquals(1, driver.postSubmitBackCount)
         assertEquals(0, driver.genericSwipes)
         assertFalse(driver.clicked.any { it.contains("支付") })

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

@@ -8,6 +8,16 @@ import org.junit.Assert.assertFalse
 import org.junit.Test
 
 class PurchaseResultPayloadTest {
+    @Test
+    fun `created order serializes optional payable total separately from unit price`() {
+        val outcome = PurchaseExecutionOutcome("order_created", message = "test", actualUnitPriceCent = 1600, pddOrderAmountCent = 1300)
+        val payload = JSONObject(purchaseResultPayload("r", "a", outcome))
+        assertEquals(1300L, payload.getLong("pddOrderAmountCent"))
+        assertEquals(1600L, payload.getLong("actualUnitPriceCent"))
+        assertFalse(JSONObject(purchaseResultPayload("r", "a", outcome.copy(pddOrderAmountCent = null))).has("pddOrderAmountCent"))
+        assertFalse(JSONObject(purchaseResultPayload("r", "a", outcome.copy(resultType = "order_result_unknown"))).has("pddOrderAmountCent"))
+    }
+
     @Test
     fun `unknown order result keeps stable failure and verified price without order fields`() {
         val payload = JSONObject(purchaseResultPayload(

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: 53a68c1d31d5d03a53e365b407cffeaf3fc75800
-synchronized_at: 2026-09-18T07:56:48Z
+wiki_revision: 46067d78327476f14e6cfd202458a53f295bf763
+synchronized_at: 2026-09-19T07:18:28Z
 <!-- gitea-wiki-mirror:end -->
 
 # 架构与代码地图
@@ -492,3 +492,18 @@ Web 唯一展示位置为“采集采购 → SYB 同步记录”：列表状态
 - 列表遍历限定虚拟列表订单卡片的商品行，排除店铺头和支付、确认收货、退款、售后、取消、更多等动作区；详情只展开收货/订单信息。未看到明确列表末尾证据时必须标记未完整扫描，不得宣称全量。
 - 客户端密钥与冻结的 Admin Origin 只保存在扩展可信上下文；content script 无权读取。请求禁用 Cookie 与重定向，批次最多 50 条，稳定 UUID 可在 service worker 重启或超时后重放；已确认批次不重复计数。
 - 服务端 `POST /api/client/v1/purchase-tasks/order-backfill` 复用 Agent 回填事务校验，但使用独立 client principal，不伪造 Device Token 或 deviceId。Agent 路径仍严格保持设备归属校验及失败后按设备范围回读。
+
+## 下单结果读取及应付总额链路（#325）
+
+分支 fix/325-order-result，2026-09-19，尚未发布及真实下单验收。PurchaseLiveAutomation.readOrderResult 采用25次支付页返回后采样、首次待付款页独立30次采样/最多4次按需滑动；原过渡60次与总90次采样上限保留有界终止。parsePayableAmount只从本次只读标签集合提取明确应付总额。
+
+数据链路：PurchaseOrderEvidence.pddOrderAmountCent → PurchaseExecutionOutcome → service/PurchaseResultPayload.kt → purchase.ResultRequest → lifecycle.go 的 order_created 分支 → 既有 purchase_task.pdd_order_amount_cent。重启只读核单也沿用同一可选字段。复用已有结果Outbox、幂等哈希和订单号唯一性；不新增表、配置、任务或SYB金额字段。未修改我的订单回填、Chrome扩展和Web，不能将旧入口的实付含义描述为本次已改成应付。
+
+## Admin 订单资料补全与一致回填资格（#326）
+
+实现3a2472d（2026-09-19），Server/Web，未合并发布；无迁移、无Android/插件改动。
+
+- purchase/types.go ManualRequest 增加可选 pddOrderAmountCent；manual.go ResolveUnknown 复用既有行锁事务和模型单号保护，扩展为未知结果确认或已创建订单补缺。仅此操作启用新增重放内容校验和事务内 ensureOrderWriteback，其他人工付款/取消/授权流程不新增入队副作用。
+- order_writeback.go 的任务资格去掉 order_created 限制；validOrderWritebackTarget 统一有效 stock/detail 边界。OrderWritebackViews 一次批量读取关联而非逐行查询，RequestOrderWriteback 和 worker 执行前再次检查。队列结构、租约、外部写入协议不变。
+- web/src/views/goauto/purchase-tasks/index.vue 沿用原详情/弹窗/resolve-unknown API，新增缺字段补录入口、整数分转换、完整性展示及失败保留输入，不增加数据库状态或新的权限资源。旧未知结果请求不带金额继续兼容。
+- 回归：server go test -p 1 ./app/goauto/purchase ./app/goauto/clientapi ./app/goauto/sybclient；Web 生产构建及 tests/e2e/purchase-order-writeback.spec.ts 的6项隔离浏览器测试。真实SYB接口用fake/httptest替代，未执行付款、采购或线上写入。

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: f353b476add5081d4d7a1493e5454b6400518923
-synchronized_at: 2026-09-18T02:18:13Z
+wiki_revision: b6df3e2d3d497827c9f3cc5b5ec859d5bda3c1f2
+synchronized_at: 2026-09-19T07:39:56Z
 <!-- gitea-wiki-mirror:end -->
 
 # 业务规则与术语
@@ -332,7 +332,7 @@ synchronized_at: 2026-09-18T02:18:13Z
 - 一个 PDD 商品可能被多个虾皮商品共用，因此规格匹配按受影响的每个虾皮商品分项记录。主表只表达总体进度；Agent 展示和“继续采购”资格必须读取当前任务对应虾皮商品的分项状态。
 - 选错替代商品时，连续执行 B→C 不等于撤销 A→B，因为 B 可能还关联其他虾皮商品。正确纠错语义是把原 A→B 记录置为 `superseded`，再建立 A→C，并只处理原记录分项中冻结的影响集合。
 - 创建请求按 `create_request_id` 幂等；重放时源商品、替代商品、来源类型、来源任务、采集证据和发起设备必须一致，否则返回幂等冲突，不能静默覆盖。
-- `created_by_device_id` 只代表 Agent 设备。当前系统没有设备到采购员账号的绑定，多人多机场景若需要个人责任追踪，必须另建工单实现设备绑定操作员。
+- `created_by_device_id` 只代表 Agent 设备。设备可由管理员绑定到一个采购员账号；一个采购员可拥有多台设备，一台设备最多归属一个采购员，也允许暂不归属。SYB 商品一键关联/替换按当前采购员选择的归属设备读取该设备最新临时采集，不使用其他账号或其他设备的全局最新记录。
 
 
 ## PDD 商品替换生效与规格匹配（#131）
@@ -630,3 +630,35 @@ Web 唯一展示位置为“采集采购 → SYB 同步记录”：列表状态
 订单回填状态独立于采购成功、支付复核及物流 writeback_status。实付金额只存 Admin，SYB cost=0 为接口固定参数，不以金额推断付款。SYB 接口会同时更新采购状态/平台/时间，不能视作纯展示修改。
 
 采购管理增加独立状态列、批量回填和详情补偿；复用既有访问权限，不增支付确认或审批。批量受理与最终成功分开展示；重试采购和回填分别筛选勾选项。远端无原子CAS，对系统外人工并发修改/超长延迟请求不能承诺绝对互斥；有冲突应人工核对，禁止强制覆盖。
+## Agent 回填订单入口兼容（#307）
+
+- 打开我的订单后最多采样8次，每次间隔1秒，连续两次订单导航结构一致才继续；登录/风控仍立即停止，超时给出明确原因。
+- 保留全部标签selected=true的原路径。PDD不提供selected属性时，要求订单标题、唯一全部标签以及同排至少两个订单状态标签；仅该安全导航标签允许一次中心手势，不扩大到订单卡片、地址、支付或其他操作。
+- 本轮主动点击全部后复核订单导航结构；本轮上下文不能跨扫描复用，出现其他已选中订单状态时停止。卡片识别与支付禁令保持不变。
+- 回填结束/失败通过现有通知与Toast显示脱敏原因；详细结果仍在Agent采购页。本变更不调整服务端回填接口、采集或采购流程。
+
+## 下单后待付款核单与应付金额（#325）
+
+实现分支 fix/325-order-result，2026-09-19；未部署、未真机验收。下单点击及不可逆边界不改。已知 PayActivity 允许一次原有 Back，随后从3次放宽为25次200ms采样（约5秒等待，不含页面捕获耗时），持续无证据仍为 PURCHASE_ORDER_PAYMENT_REPEATED。微信恢复、系统选择器、空窗口和陌生应用的既有边界保留。
+
+过渡阶段最多60次采样。首次识别到待付款证据后单独分配30次采样预算，不被之前绕路消耗，不因文字反复出现重置；核单总采样上限90次。缺少唯一订单号或时间时立即向上滑动读取下方内容，最多4次、手势400ms、每次后等500ms；读全立即停止，已有完整字段不滑动。该待付款读取分支不点击任何控件，也不点击付款。纯支付页不使用该滑动分支；出现可读待付款证据优先于复用的 Activity 名称。按采样间隔约18秒加有限手势/额外等待，实际耗时还含capture等调用；未改变2分钟任务租约或5分钟唤醒锁，也不宣称新增了执行器总体墙钟超时机制。
+
+应付金额从同一订单的可见标签集合中读取，兼容“应付:,13元”等标点；不跨无关联节点拼接，不读拼单价、优惠或实付。父子重复同金额去重，多值/缺失/无效/溢出省略，不因金额失败丢弃订单号与时间。仅存Admin，不推断支付、不改SYB金额、不修改地址行为。历史回填及界面语义未在本单统一，详见API契约#325补充。
+
+## 采购订单资料完整性及简化单号回填（#326）
+
+用户2026-09-19确认内部系统简化流程，原型v1通过。实现3a2472d，尚未发布或真实SYB验收。
+
+采购任务保存 PDD 订单号、下单时间和订单金额即为资料完整，不检查是否已付款；金额0元有效。复用 pddOrderNo/orderSubmittedAt/pddOrderAmountCent，金额以人民币分存储。order_created 不改义，仍是已创建订单事实；缺金额展示“订单信息待补全”，不能当作采购失败再次下单。页面统一称“订单金额”，其来源可能是#325应付或既有回填实付，不能将历史值统一称已付金额。
+
+Admin 复用未知结果处理弹窗增加金额输入，并为 live 已创建且缺资料任务提供“补全订单信息”；已有字段只读、缺项可填。保存中禁用提交，失败保留输入；沿用既有权限，不增加审批。非执行中的未知结果人工确认与已有订单资料补全都会事务内保证单号回填记录，不修改支付复核或触发设备操作。
+
+SYB 回填与资料完整性独立：正式SYB任务已有单号且仍关联有效明细即可入队，不要求 order_created 状态、时间、金额、付款确认或地址后缀。只有订单号上传SYB；沿用同号成功、异号冲突不覆盖及既有在途防重复规则，不倒扫历史任务。历史补偿仍手动勾选，已成功或在途任务不可重复发起。
+
+自动下单读取和Admin补录是后续目标来源；本单尚未删除插件或Agent我的订单回填，不能宣称上游地址后缀已取消或历史错误归属已修复。金额缺失不得自动采购，订单号唯一归属保护和永久不付款规则不变。
+
+## 采购管理已回填 SYB 筛选（#327）
+
+实现368f2c2，2026-09-19，尚未发布。采购管理现有“状态”下拉框增加“已回填 SYB”，用户选择后点击原查询按钮，按PDD单号回填队列成功记录筛选；不是新的采购任务状态，也不表示物流回填成功或已付款。
+
+筛选后仍展示原采购状态与独立SYB单号回填状态，已成功任务不因查询而允许重复回填。清空或重置恢复原列表，查询回到第一页，其他条件继续叠加。沿用既有下拉框、空/加载/失败状态及权限，不新增页面、审批、数据字段或外部动作。

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: 6e5ab1f9c569067f1b98795cbd6c20c2f2421e57
-synchronized_at: 2026-09-18T07:57:55Z
+wiki_revision: 275caa306765440b0888dea701198d45481bfb40
+synchronized_at: 2026-09-19T07:40:19Z
 <!-- gitea-wiki-mirror:end -->
 
 <!-- gitea-wiki-mirror:start -->
@@ -1350,7 +1350,7 @@ Android 仅人工“回填”扫描识别单节点“实付”标签，兼容实
 
 实现绑定 e89de1a（2026-09-18，feat/305-syb-order-writeback），已完成代码及隔离测试；未合并、未部署、未执行业务库迁移或真实 SYB 写入。
 
-- 普通 Agent order_created 结果和人工 order-backfill 首次成功/同单号 already_backfilled 共用事务内 ensureOrderWriteback。仅 live + syb_order + order_created + 有效 PDD 单号与 SYB stock/detail 关联时建立唯一 pending 记录；网络写入由事务外 worker 执行。不改变 Agent 请求/响应字段；金额缺失/冲突不阻止单号入队，不依赖 paymentReviewStatus。
+- 普通 Agent order_created 结果和人工 order-backfill 首次成功/同单号 already_backfilled 共用事务内 ensureOrderWriteback。仅 live + syb_order + 有效 PDD 单号与 SYB stock/detail 关联时建立唯一 pending 记录（#326 起不限制任务状态）；网络写入由事务外 worker 执行。不改变 Agent 请求/响应字段；金额缺失/冲突不阻止单号入队，不依赖 paymentReviewStatus。
 - POST /api/admin/v1/purchase-tasks/syb-order-writeback：沿用管理员/采购员采购管理权限；body 为 {requestId: UUID, purchaseTaskIds: 正整数数组}，1～100条，不允许重复ID。单条补偿也使用本接口。
 - 返回 HTTP 200、{code:200,data:{items:[{taskId,result,reason?}]}}；result 为 pending/succeeded/skipped/conflict。pending 仅表示受理，不代表远端已写入。无资格或不存在的条目独立 skipped，其他条目继续；数据库事务故障整次命令回滚。服务端校验与冲突错误沿用采购错误信封。
 - requestId 持久幂等：对排序后的 ID 集合取摘要，相同 requestId/集合返回原接受结果，即使后台状态已推进；改变集合返回422。查询当前完成状态应重新GET，不能以重放响应判断最终成功。
@@ -1369,3 +1369,33 @@ Android 仅人工“回填”扫描识别单节点“实付”标签，兼容实
 - 客户端入口不要求任务归属某一 Android 设备，但仍复用任务状态、订单号唯一、同批冲突、金额和时间校验。Agent 入口继续要求认证设备归属，两个入口的错误回读范围不得互相扩大。
 - `order_created` 且订单号相同只补空金额和空下单时间；已有金额或时间不覆盖。补入页面时间时保存 `backfill:page:` 来源标记并返回 `timeSource=page`；历史已有时间且无来源仍返回 `existing_unknown`。
 - 扩展必须冻结启动时的 Origin、客户端身份和天数窗口；禁止 content script 接触密钥。网络超时或服务端逐项 `retryable=true` 时使用原稳定批次 UUID 重试，只有通过数量、索引和字段完整性校验的响应才确认批次。
+
+## 下单结果可选应付总额（#325）
+
+实现分支 fix/325-order-result，2026-09-19；未部署、未真机下单验收。POST /api/agent/v1/purchase-tasks/:taskId/result 的 resultType=order_created 新增可省略/可空 int64 字段 pddOrderAmountCent，人民币分，语义为本次待付款页明确“应付”的订单总额。actualUnitPriceCent 仍为商品单价。仅在唯一订单号和下单时间完整时随成功结果发送，金额缺失/冲突/无效/溢出时 Agent 省略金额，不影响订单事实。服务端拒绝负数或其他 resultType 携带非空金额，字符串/小数/溢出按现有严格 JSON 解码失败。
+
+服务端只为已成功确认且无订单号占用冲突的任务补写空 pdd_order_amount_cent；省略、null 或已有非空值均不清空/覆盖。字段纳入现有结果哈希，相同 requestId/attempt/载荷幂等，不同载荷拒绝。不改支付状态，不传金额到 SYB。原列已存在，无追加迁移；新 Agent 上报前须先发布此 Server，旧 Server 不接受新结果字段。
+
+本单不修改 #306 人工订单回填、#316 Chrome 回填、Web“实付价格”显示或历史值：这些路径仍沿用原语义，不能据此宣称全局金额已统一为应付。此节仅定义新增采购结果入口。
+
+## Admin 订单资料补全与字段型 SYB 入队（#326）
+
+实现提交 3a2472d，2026-09-19，feat/326-order-information；隔离测试及构建通过，未合并 main、未发布、未执行真实 SYB 写入。
+
+复用 POST /api/admin/v1/purchase-tasks/:id/resolve-unknown 及其原有管理员/采购员权限：live 的 order_result_unknown 可人工确认订单或取消；live 的 order_created 可补全订单信息，但不能通过此接口改成 cancelled。status=order_created 时沿用 pddOrderNo、orderSubmittedAt，增加可选非负整数分 pddOrderAmountCent，复用原数据库列。订单号非空、无首尾空白/换行且不超过100字符，时间须为有效非零时间；旧客户端省略金额仍接受并保留已有值。新 Admin 补录表单要求金额，0元合法，最多两位小数，转换为整数分后提交。
+
+已保存非空字段只补缺，不覆盖不同单号、时间或金额；订单号唯一归属仍由原模型保护。相同 requestId/已保存内容重放不重复保存，改变处理结果或已保存字段返回原采购冲突错误。前端网络失败保留输入及相同载荷的 requestId；修改载荷使用新 requestId。复用原审计字段 UnknownResolveRequestID，无新增表或持久化状态。
+
+资料完整性由订单号、有效下单时间和非空非负订单金额推导，页面显示“信息完整”或“订单信息待补全”。order_created 仍表示已创建订单，缺金额不转 failed，不代表已付款，不重新采购。
+
+人工确认/补录订单在同一事务中 ensureOrderWriteback；原 Agent order_created 与插件/Agent order-backfill 保持兼容。SYB 回填仅要求 live + syb_order + 非空订单号 + 有效关联 stock/detail；不检查任务状态、时间、金额、支付复核或地址后缀。列表批量读取有效关联，提交与 worker 校验相同目标范围。既有 pending/running/succeeded 不重复入队，conflict 不覆盖，unknown 保留原回读及租约规则。字段补全不恢复已失败队列，失败队列仍通过原“回填 SYB 单号”补偿操作处理。
+
+仅回填单号，cost=0/created为空；金额、时间只存 Admin。旧物流 paid 候选流程不改，Android 与 Chrome 上传定位契约未改；今后停用插件和 Agent 回填须另行实施。本次无需数据库迁移；先发布新 Server 再发布发送金额字段的新 Web。
+
+## Admin 采购列表已回填单号筛选（#327）
+
+实现368f2c2（2026-09-19），feat/327-syb-writeback-filter；测试和构建通过，未合并发布。
+
+GET /api/admin/v1/purchase-tasks 的既有 status 参数新增查询专用值 syb_writeback_succeeded。该值按独立 purchase_order_writeback.status=succeeded 且 purchase_task_id 对应当前采购任务过滤，不查询旧物流 writeback_status，不新增或改写任务状态。原 status 合法值及其他参数行为保持不变。
+
+匹配成功回填的历史任务，不额外要求当前采购状态为 order_created；返回的 task.status 仍为真实采购状态。无单号队列及 pending/running/failed/unknown/conflict 不命中。count及分页共用子查询过滤，可与 taskId、executionMode、taskType、sybProductId、shopeeOrderNo、pddOrderNo 组合；status为空恢复不限制状态。权限与返回信封不变，不写入数据、不触发采购或SYB请求。先发布Server再发布新增筛选值的Web，无数据库迁移或Android变更。

server/app/goauto/device/handler.go

@@ -11,6 +11,7 @@ import (
 
 	"github.com/gin-gonic/gin"
 	"github.com/go-admin-team/go-admin-core/sdk/pkg"
+	jwt "github.com/go-admin-team/go-admin-core/sdk/pkg/jwtauth"
 	"gorm.io/gorm"
 )
 
@@ -29,6 +30,14 @@ func (handler Handler) List(context *gin.Context) {
 		writeError(context, internalError(err))
 		return
 	}
+	if role, _ := jwt.ExtractClaims(context)["rolekey"].(string); role != "admin" {
+		id := currentUserID(context)
+		if id > 0 {
+			request.OwnerUserID = &id
+		} else {
+			request.OwnerUserID = new(uint64)
+		}
+	}
 	response, err := NewService(db).List(context.Request.Context(), request)
 	if err != nil {
 		writeError(context, err)
@@ -37,6 +46,63 @@ func (handler Handler) List(context *gin.Context) {
 	context.JSON(http.StatusOK, gin.H{"code": http.StatusOK, "data": response})
 }
 
+func currentUserID(c *gin.Context) uint64 {
+	value, ok := c.Get("userId")
+	if !ok {
+		return 0
+	}
+	switch id := value.(type) {
+	case int:
+		return uint64(id)
+	case int64:
+		return uint64(id)
+	case uint64:
+		return id
+	case float64:
+		return uint64(id)
+	}
+	return 0
+}
+
+func (handler Handler) Owners(context *gin.Context) {
+	db, err := handler.database(context)
+	if err != nil {
+		writeError(context, internalError(err))
+		return
+	}
+	rows, err := NewService(db).Owners(context.Request.Context())
+	if err != nil {
+		writeError(context, err)
+		return
+	}
+	context.JSON(http.StatusOK, gin.H{"code": http.StatusOK, "data": rows})
+}
+
+func (handler Handler) SetOwner(context *gin.Context) {
+	deviceID, err := strconv.ParseUint(context.Param("deviceId"), 10, 64)
+	if err != nil || deviceID == 0 {
+		writeError(context, invalidRequest("deviceId 无效"))
+		return
+	}
+	var req struct {
+		OwnerUserID *uint64 `json:"ownerUserId"`
+	}
+	if err := decodeJSON(context, &req); err != nil {
+		writeError(context, invalidRequest("请求 JSON 无效"))
+		return
+	}
+	db, err := handler.database(context)
+	if err != nil {
+		writeError(context, internalError(err))
+		return
+	}
+	if err := NewService(db).SetOwner(context.Request.Context(), deviceID, req.OwnerUserID); err != nil {
+		writeError(context, err)
+		return
+	}
+	context.JSON(http.StatusOK, gin.H{"code": http.StatusOK, "data": gin.H{"deviceId": deviceID, "ownerUserId": req.OwnerUserID}})
+}
+
 func (handler Handler) Register(context *gin.Context) {
 	request, err := decodeRegisterRequest(context)
 	if err != nil {

server/app/goauto/device/list.go

@@ -13,10 +13,11 @@ import (
 )
 
 type ListRequest struct {
-	Page     int
-	PageSize int
-	Name     string
-	Status   string
+	Page        int
+	PageSize    int
+	Name        string
+	Status      string
+	OwnerUserID *uint64
 }
 
 type DeviceListItem struct {
@@ -36,6 +37,8 @@ type DeviceListItem struct {
 	LastHeartbeatAt *time.Time `json:"lastHeartbeatAt"`
 	CreatedAt       time.Time  `json:"createdAt"`
 	UpdatedAt       time.Time  `json:"updatedAt"`
+	OwnerUserID     *uint64    `json:"ownerUserId"`
+	OwnerName       string     `json:"ownerName"`
 }
 
 type DeviceListResponse struct {
@@ -68,6 +71,9 @@ func (service *Service) List(ctx context.Context, request ListRequest) (DeviceLi
 	if request.Status != "" {
 		query = query.Where("status = ?", request.Status)
 	}
+	if request.OwnerUserID != nil {
+		query = query.Where("owner_user_id = ?", *request.OwnerUserID)
+	}
 	var total int64
 	if err := query.Count(&total).Error; err != nil {
 		return DeviceListResponse{}, internalError(err)
@@ -100,8 +106,8 @@ func (service *Service) List(ctx context.Context, request ListRequest) (DeviceLi
 			AndroidVersion: record.AndroidVersion, AgentVersion: record.AgentVersion, PDDVersion: record.PDDVersion,
 			Capabilities: capabilities,
 			Status:       record.Status, LastHeartbeatAt: record.LastHeartbeatAt,
-			TokenRevoked: record.TokenRevokedAt != nil,
-			CreatedAt:    record.CreatedAt, UpdatedAt: record.UpdatedAt,
+			TokenRevoked: record.TokenRevokedAt != nil, OwnerUserID: record.OwnerUserID,
+			CreatedAt: record.CreatedAt, UpdatedAt: record.UpdatedAt,
 		}
 		if taskID, busy := currentTasks[record.ID]; busy {
 			item.Busy = true

server/app/goauto/device/owner.go

@@ -0,0 +1,63 @@
+package device
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"go-admin/app/goauto/models"
+	"gorm.io/gorm"
+)
+
+type DeviceOwnerItem struct {
+	UserID   uint64 `json:"userId"`
+	Username string `json:"username"`
+	NickName string `json:"nickName"`
+}
+
+func (service *Service) Owners(ctx context.Context) ([]DeviceOwnerItem, error) {
+	var rows []DeviceOwnerItem
+	if err := service.DB.WithContext(ctx).Table("sys_user u").Select("u.user_id AS user_id, u.username, u.nick_name").Joins("JOIN sys_role r ON r.role_id = u.role_id").Where("u.status <> ? AND r.role_key <> ?", "1", "admin").Order("u.user_id").Scan(&rows).Error; err != nil {
+		return nil, internalError(err)
+	}
+	return rows, nil
+}
+
+func (service *Service) SetOwner(ctx context.Context, deviceID uint64, owner *uint64) error {
+	if deviceID == 0 {
+		return invalidRequest("deviceId 无效")
+	}
+	if owner != nil && *owner == 0 {
+		return invalidRequest("ownerUserId 无效")
+	}
+	if owner != nil {
+		var count int64
+		if err := service.DB.WithContext(ctx).Table("sys_user u").Joins("JOIN sys_role r ON r.role_id = u.role_id").Where("u.user_id = ? AND u.status <> ? AND r.role_key <> ?", *owner, "1", "admin").Count(&count).Error; err != nil {
+			return internalError(err)
+		}
+		if count != 1 {
+			return invalidRequest("采购员不存在或不可分配")
+		}
+	}
+	result := service.DB.WithContext(ctx).Model(&models.AgentDevice{}).Where("id = ?", deviceID).Update("owner_user_id", owner)
+	if result.Error != nil {
+		return internalError(result.Error)
+	}
+	if result.RowsAffected == 0 {
+		return gorm.ErrRecordNotFound
+	}
+	return nil
+}
+
+func parseOwnerID(value string) (*uint64, error) {
+	value = strings.TrimSpace(value)
+	if value == "" {
+		return nil, nil
+	}
+	id, err := strconv.ParseUint(value, 10, 64)
+	if err != nil || id == 0 {
+		return nil, fmt.Errorf("ownerUserId 无效")
+	}
+	return &id, nil
+}

server/app/goauto/device/router.go

@@ -21,6 +21,8 @@ func InitRouter(engine *gin.Engine, authMiddleware *jwt.GinJWTMiddleware) {
 
 	admin := engine.Group("/api/admin/v1/devices").Use(authMiddleware.MiddlewareFunc()).Use(middleware.AuthCheckRole())
 	admin.GET("", handler.List)
+	admin.GET("/owners", middleware.RequireRoleKey("admin"), handler.Owners)
+	admin.PATCH("/:deviceId/owner", middleware.RequireRoleKey("admin"), handler.SetOwner)
 	admin.POST("/:deviceId/disable", middleware.RequireRoleKey("admin"), handler.Disable)
 	admin.POST("/:deviceId/identity-reset", middleware.RequireRoleKey("admin"), handler.ResetIdentity)
 	admin.POST("/:deviceId/token/revoke", middleware.RequireRoleKey("admin"), handler.RevokeToken)

server/app/goauto/models/schema.go

@@ -38,6 +38,7 @@ type AgentDevice struct {
 	AndroidVersion         string     `json:"androidVersion" gorm:"size:32;not null"`
 	AgentVersion           string     `json:"agentVersion" gorm:"size:32;not null"`
 	PDDVersion             string     `json:"pddVersion" gorm:"size:32;not null"`
+	OwnerUserID            *uint64    `json:"ownerUserId" gorm:"column:owner_user_id;index"`
 	CapabilitiesJSON       string     `json:"-" gorm:"size:4096;not null;default:'[]'"`
 	Status                 string     `json:"status" gorm:"size:16;not null;index;check:ck_agent_device_status,status IN ('online','offline','disabled')"`
 	TokenDigest            string     `json:"-" gorm:"size:64;not null;uniqueIndex:ux_agent_device_token_digest"`

server/app/goauto/product/handler.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/gin-gonic/gin"
 	"github.com/go-admin-team/go-admin-core/sdk/pkg"
+	jwt "github.com/go-admin-team/go-admin-core/sdk/pkg/jwtauth"
 	"gorm.io/gorm"
 )
 
@@ -30,9 +31,16 @@ func (handler Handler) List(c *gin.Context) {
 	if !ok {
 		return
 	}
-	response, err := service.List(c.Request.Context(), ListRequest{
+	request := ListRequest{
 		Page: page, PageSize: pageSize, GoodsID: c.Query("goodsId"), Keyword: c.Query("keyword"), Status: strings.TrimSpace(c.Query("status")),
-	})
+	}
+	claims := jwt.ExtractClaims(c)
+	if role, _ := claims["rolekey"].(string); role != "admin" {
+		id, _ := claims["identity"].(float64)
+		owner := uint64(id)
+		request.CollectionOwnerUserID = &owner
+	}
+	response, err := service.List(c.Request.Context(), request)
 	if err != nil {
 		writeError(c, err)
 		return

server/app/goauto/product/service.go

@@ -64,10 +64,11 @@ type UpdateRequest struct {
 }
 
 type ListRequest struct {
-	Page, PageSize int
-	Keyword        string
-	GoodsID        string
-	Status         string
+	Page, PageSize        int
+	Keyword               string
+	GoodsID               string
+	Status                string
+	CollectionOwnerUserID *uint64
 }
 
 type ProductView struct {
@@ -266,6 +267,9 @@ func (service *Service) List(ctx context.Context, request ListRequest) (ListResp
 		}
 		query = query.Where("status = ?", request.Status)
 	}
+	if request.CollectionOwnerUserID != nil {
+		query = query.Where("EXISTS (SELECT 1 FROM collection_task ct JOIN agent_device ad ON ad.id = ct.device_id WHERE ct.pdd_product_id = pdd_product.id AND ct.source = ? AND ct.status IN ? AND ad.owner_user_id = ?)", models.CollectionTaskSourceAgentCurrentPage, []string{models.TaskStatusCompleted, models.TaskStatusCompletedPartial}, *request.CollectionOwnerUserID)
+	}
 	var total int64
 	if err := query.Count(&total).Error; err != nil {
 		return ListResponse{}, internalError(err)

server/app/goauto/product/service_test.go

@@ -205,6 +205,44 @@ func TestListMarksProductsUnavailableForCollection(t *testing.T) {
 	}
 }
 
+func TestListFiltersManualAssociationProductsByOwnedCollectionDevice(t *testing.T) {
+	db := openProductDatabase(t)
+	service := NewService(db)
+	rule := models.CollectionRule{Name: "owned-rule", ContentJSON: `{}`}
+	if err := db.Create(&rule).Error; err != nil {
+		t.Fatal(err)
+	}
+	products := []models.PDDProduct{{GoodsID: "910001", URL: "https://mobile.yangkeduo.com/goods.html?goods_id=910001", Status: "active"}, {GoodsID: "910002", URL: "https://mobile.yangkeduo.com/goods.html?goods_id=910002", Status: "active"}, {GoodsID: "910003", URL: "https://mobile.yangkeduo.com/goods.html?goods_id=910003", Status: "active"}}
+	if err := db.Create(&products).Error; err != nil {
+		t.Fatal(err)
+	}
+	owned := models.AgentDevice{InstallID: "owned-manual-list", Name: "owned", Manufacturer: "test", Model: "test", AndroidVersion: "14", AgentVersion: "1", PDDVersion: "1", Status: models.DeviceStatusOffline, TokenDigest: "owned-digest", TokenIssuedAt: time.Now(), OwnerUserID: ptrUint64(41)}
+	other := models.AgentDevice{InstallID: "other-manual-list", Name: "other", Manufacturer: "test", Model: "test", AndroidVersion: "14", AgentVersion: "1", PDDVersion: "1", Status: models.DeviceStatusOffline, TokenDigest: "other-digest", TokenIssuedAt: time.Now(), OwnerUserID: ptrUint64(42)}
+	if err := db.Create(&owned).Error; err != nil {
+		t.Fatal(err)
+	}
+	if err := db.Create(&other).Error; err != nil {
+		t.Fatal(err)
+	}
+	for _, task := range []models.CollectionTask{{PDDProductID: &products[0].ID, DeviceID: &owned.ID, Source: models.CollectionTaskSourceAgentCurrentPage, Status: models.TaskStatusCompleted}, {PDDProductID: &products[1].ID, DeviceID: &other.ID, Source: models.CollectionTaskSourceAgentCurrentPage, Status: models.TaskStatusCompleted}, {PDDProductID: &products[2].ID, DeviceID: &owned.ID, Source: models.CollectionTaskSourceAdmin, Status: models.TaskStatusCompleted}} {
+		task.RuleID = rule.ID
+		task.URLSnapshot = products[0].URL
+		task.RuleSnapshot = rule.ContentJSON
+		if err := db.Create(&task).Error; err != nil {
+			t.Fatal(err)
+		}
+	}
+	got, err := service.List(context.Background(), ListRequest{Page: 1, PageSize: 20, CollectionOwnerUserID: ptrUint64(41)})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(got.Items) != 1 || got.Items[0].GoodsID != products[0].GoodsID {
+		t.Fatalf("unexpected owned products: %+v", got.Items)
+	}
+}
+
+func ptrUint64(value uint64) *uint64 { return &value }
+
 func TestListDisablesCollectionWhenNoRuleExists(t *testing.T) {
 	db := openProductDatabase(t)
 	product := models.PDDProduct{GoodsID: "444444", URL: "https://mobile.yangkeduo.com/goods.html?goods_id=444444", Status: "active"}

server/app/goauto/purchase/admin_query.go

@@ -109,6 +109,9 @@ type AdminDetailResponse struct {
 	Matching MatchingView       `json:"matching"`
 }
 
+// Query-only value: never a PurchaseTask status or a logistics writeback state.
+const adminStatusSYBWritebackSucceeded = "syb_writeback_succeeded"
+
 func (s *Service) AdminList(ctx context.Context, req AdminListRequest) (AdminListResponse, error) {
 	if req.Page < 1 {
 		req.Page = 1
@@ -119,7 +122,7 @@ func (s *Service) AdminList(ctx context.Context, req AdminListRequest) (AdminLis
 	if req.PageSize > 100 {
 		req.PageSize = 100
 	}
-	if req.Status != "" && !validPurchaseStatus(req.Status) {
+	if req.Status != "" && req.Status != adminStatusSYBWritebackSucceeded && !validPurchaseStatus(req.Status) {
 		return AdminListResponse{}, fail(CodeInvalidRequest, "status 无效")
 	}
 	if req.ExecutionMode != "" && req.ExecutionMode != models.PurchaseExecutionModeRehearsal && req.ExecutionMode != models.PurchaseExecutionModeLive {
@@ -132,7 +135,9 @@ func (s *Service) AdminList(ctx context.Context, req AdminListRequest) (AdminLis
 	if req.TaskID > 0 {
 		query = query.Where("id = ?", req.TaskID)
 	}
-	if req.Status != "" {
+	if req.Status == adminStatusSYBWritebackSucceeded {
+		query = query.Where("id IN (?)", s.DB.WithContext(ctx).Model(&models.PurchaseOrderWriteback{}).Select("purchase_task_id").Where("status = ?", "succeeded"))
+	} else if req.Status != "" {
 		query = query.Where("status = ?", req.Status)
 	}
 	if req.ExecutionMode != "" {

server/app/goauto/purchase/admin_query_test.go

@@ -105,6 +105,63 @@ func TestAdminQueryValidationAndNotFound(t *testing.T) {
 	}
 }
 
+func TestAdminListSYBWritebackSucceededFilter(t *testing.T) {
+	s, first := orderWritebackFixture(t)
+	db := s.DB
+	if err := db.Model(&models.PurchaseOrderWriteback{}).Where("purchase_task_id = ?", first.ID).Update("status", "succeeded").Error; err != nil {
+		t.Fatal(err)
+	}
+	var successIDs []uint64
+	successIDs = append(successIDs, first.ID)
+	for _, state := range []string{"succeeded", "pending", "running", "failed", "unknown", "conflict", "none"} {
+		task := first
+		task.ID = 0
+		task.Status = models.PurchaseTaskStatusCancelled
+		task.PDDOrderNo = nil
+		task.WritebackStatus = models.PurchaseWritebackStatusSucceeded // old logistics must not match
+		task.CreateRequestID = uuid.NewString()
+		task.UnknownResolveRequestID = nil
+		if err := db.Create(&task).Error; err != nil {
+			t.Fatal(err)
+		}
+		if state != "none" {
+			if err := db.Create(&models.PurchaseOrderWriteback{PurchaseTaskID: task.ID, StockID: 2, DetailID: 1, OrderNo: "FILTER-DEMO", Status: state}).Error; err != nil {
+				t.Fatal(err)
+			}
+		}
+		if state == "succeeded" {
+			successIDs = append(successIDs, task.ID)
+		}
+	}
+	for page := 1; page <= 2; page++ {
+		out, err := s.AdminList(context.Background(), AdminListRequest{Status: adminStatusSYBWritebackSucceeded, Page: page, PageSize: 1})
+		if err != nil || out.Total != 2 || len(out.Items) != 1 || out.Items[0].ID != successIDs[2-page] {
+			t.Fatalf("page %d: %+v, %v", page, out, err)
+		}
+	}
+	for _, req := range []AdminListRequest{
+		{Status: adminStatusSYBWritebackSucceeded, TaskID: first.ID},
+		{Status: models.PurchaseTaskStatusOrderCreated},
+		{Status: adminStatusSYBWritebackSucceeded, PDDOrderNo: *first.PDDOrderNo, ExecutionMode: "live", TaskType: "syb_order", SYBProductID: *first.SYBProductID},
+	} {
+		out, err := s.AdminList(context.Background(), req)
+		if err != nil || out.Total != 1 || len(out.Items) != 1 || out.Items[0].ID != first.ID {
+			t.Fatalf("combined filter: %+v %v", out, err)
+		}
+	}
+	out, err := s.AdminList(context.Background(), AdminListRequest{})
+	if err != nil || out.Total != 8 {
+		t.Fatalf("clear filter: %+v %v", out, err)
+	}
+	out, err = s.AdminList(context.Background(), AdminListRequest{Status: adminStatusSYBWritebackSucceeded, PDDOrderNo: "not-found"})
+	if err != nil || out.Total != 0 {
+		t.Fatalf("empty filter: %+v %v", out, err)
+	}
+	if validPurchaseStatus(adminStatusSYBWritebackSucceeded) {
+		t.Fatal("filter became task state")
+	}
+}
+
 func TestAdminQueryHandlersRequireOperatorRole(t *testing.T) {
 	gin.SetMode(gin.TestMode)
 	for _, path := range []string{"/api/admin/v1/purchase-tasks", "/api/admin/v1/purchase-tasks/1"} {

server/app/goauto/purchase/lifecycle.go

@@ -341,6 +341,9 @@ func (s *Service) SubmitResult(ctx context.Context, taskID uint64, req ResultReq
 		if req.ActualUnitPriceCent != nil && *req.ActualUnitPriceCent < 0 {
 			return TaskPayload{}, fail(CodeInvalidRequest, "实际单价无效")
 		}
+		if req.PDDOrderAmountCent != nil && (*req.PDDOrderAmountCent < 0 || req.ResultType != "order_created") {
+			return TaskPayload{}, fail(CodeInvalidRequest, "订单应付金额仅可随已创建订单提交且不能为负数")
+		}
 		now := s.Now()
 		next := ""
 		switch req.ResultType {
@@ -396,6 +399,9 @@ func (s *Service) SubmitResult(ctx context.Context, taskID uint64, req ResultReq
 				a.Status = models.PurchaseAttemptStatusFailed
 				a.ErrorCode, a.ErrorMessage = &failureCode, &message
 			}
+			if next == models.PurchaseTaskStatusOrderCreated && req.PDDOrderAmountCent != nil && t.PDDOrderAmountCent == nil {
+				t.PDDOrderAmountCent = req.PDDOrderAmountCent
+			}
 		case "order_result_unknown":
 			if t.ExecutionMode != models.PurchaseExecutionModeLive || t.Status != models.PurchaseTaskStatusOrderSubmitStarted {
 				return TaskPayload{}, fail(CodeStateConflict, "当前任务不能标记订单结果未知")

server/app/goauto/purchase/manual.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"strings"
+	"unicode/utf8"
 
 	"go-admin/app/goauto/models"
 	"gorm.io/gorm"
@@ -115,19 +116,31 @@ func (s *Service) Cancel(ctx context.Context, id uint64, req ManualRequest) (mod
 
 func (s *Service) ResolveUnknown(ctx context.Context, id uint64, req ManualRequest) (models.PurchaseTask, bool, error) {
 	return s.manual(ctx, id, req, func(t *models.PurchaseTask) error {
-		if t.Status != models.PurchaseTaskStatusOrderResultUnknown {
-			return fail(CodeStateConflict, "任务不是订单结果未知状态")
+		if t.ExecutionMode != models.PurchaseExecutionModeLive || (t.Status != models.PurchaseTaskStatusOrderResultUnknown && t.Status != models.PurchaseTaskStatusOrderCreated) {
+			return fail(CodeStateConflict, "仅正式采购的未知结果或已创建订单允许补录")
+		}
+		if t.Status == models.PurchaseTaskStatusOrderCreated && req.Status != models.PurchaseTaskStatusOrderCreated {
+			return fail(CodeStateConflict, "已创建订单仅允许补全订单信息")
 		}
 		if req.Status != models.PurchaseTaskStatusOrderCreated && req.Status != models.PurchaseTaskStatusCancelled {
 			return fail(CodeInvalidRequest, "人工处理结果只支持已创建订单或已取消")
 		}
 		now := s.Now()
 		if req.Status == models.PurchaseTaskStatusOrderCreated {
-			if strings.TrimSpace(req.PDDOrderNo) == "" || req.OrderSubmittedAt == nil {
+			if strings.TrimSpace(req.PDDOrderNo) == "" || strings.TrimSpace(req.PDDOrderNo) != req.PDDOrderNo || utf8.RuneCountInString(req.PDDOrderNo) > 100 || strings.ContainsAny(req.PDDOrderNo, "\r\n\t") || req.OrderSubmittedAt == nil || req.OrderSubmittedAt.IsZero() || req.OrderSubmittedAt.Year() < 1000 || req.OrderSubmittedAt.Year() > 9999 {
 				return fail(CodeInvalidRequest, "请填写订单号和下单时间")
 			}
+			if req.PDDOrderAmountCent != nil && *req.PDDOrderAmountCent < 0 {
+				return fail(CodeInvalidRequest, "订单金额不能为负数")
+			}
+			if (t.PDDOrderNo != nil && *t.PDDOrderNo != "" && *t.PDDOrderNo != req.PDDOrderNo) || (t.OrderSubmittedAt != nil && !t.OrderSubmittedAt.Equal(*req.OrderSubmittedAt)) || (t.PDDOrderAmountCent != nil && req.PDDOrderAmountCent != nil && *t.PDDOrderAmountCent != *req.PDDOrderAmountCent) {
+				return fail(CodeResultConflict, "已有不同订单信息，本次未覆盖")
+			}
 			t.PDDOrderNo = &req.PDDOrderNo
 			t.OrderSubmittedAt = req.OrderSubmittedAt
+			if req.PDDOrderAmountCent != nil {
+				t.PDDOrderAmountCent = req.PDDOrderAmountCent
+			}
 		} else {
 			t.CancelledAt = &now
 			t.CancelledBy = &req.OperatorID
@@ -140,12 +153,13 @@ func (s *Service) ResolveUnknown(ctx context.Context, id uint64, req ManualReque
 		t.StatusVersion++
 		t.StatusChangedAt = now
 		return nil
-	})
+	}, true)
 }
 
-func (s *Service) manual(ctx context.Context, id uint64, req ManualRequest, apply func(*models.PurchaseTask) error) (models.PurchaseTask, bool, error) {
+func (s *Service) manual(ctx context.Context, id uint64, req ManualRequest, apply func(*models.PurchaseTask) error, orderInfo ...bool) (models.PurchaseTask, bool, error) {
 	var out models.PurchaseTask
 	replayed := false
+	isOrderInfo := len(orderInfo) > 0 && orderInfo[0]
 	if strings.TrimSpace(req.RequestID) == "" || req.OperatorID == 0 {
 		return out, false, fail(CodeInvalidRequest, "requestId 或操作人无效")
 	}
@@ -157,6 +171,12 @@ func (s *Service) manual(ctx context.Context, id uint64, req ManualRequest, appl
 			return internal(e)
 		}
 		if requestAlreadyApplied(out, req.RequestID) {
+			if isOrderInfo && out.Status != req.Status {
+				return fail(CodeResultConflict, "同一requestId不能改变处理结果")
+			}
+			if isOrderInfo && req.Status == models.PurchaseTaskStatusOrderCreated && (out.PDDOrderNo == nil || *out.PDDOrderNo != req.PDDOrderNo || out.OrderSubmittedAt == nil || req.OrderSubmittedAt == nil || !out.OrderSubmittedAt.Equal(*req.OrderSubmittedAt) || (req.PDDOrderAmountCent != nil && (out.PDDOrderAmountCent == nil || *out.PDDOrderAmountCent != *req.PDDOrderAmountCent))) {
+				return fail(CodeResultConflict, "同一requestId不能改变订单信息")
+			}
 			replayed = true
 			return nil
 		}
@@ -172,6 +192,9 @@ func (s *Service) manual(ctx context.Context, id uint64, req ManualRequest, appl
 		if e := tx.Save(&out).Error; e != nil {
 			return conflictOrInternal(e)
 		}
+		if isOrderInfo && req.Status == models.PurchaseTaskStatusOrderCreated {
+			return ensureOrderWriteback(tx, out)
+		}
 		return nil
 	})
 	return out, replayed, err

server/app/goauto/purchase/order_information_test.go

@@ -0,0 +1,171 @@
+package purchase
+
+import (
+	"context"
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	"go-admin/app/goauto/models"
+	"gorm.io/gorm"
+)
+
+func TestOrderInformationManualCompletion(t *testing.T) {
+	for _, amount := range []int64{0, 1300} {
+		t.Run(taskNumber(uint64(amount)), func(t *testing.T) {
+			db := testDB(t)
+			f := seed(t, db, liveCaps(), true)
+			s := testService(db)
+			task := backfillTask(t, db, f, models.PurchaseTaskStatusOrderResultUnknown)
+			task.TaskType, task.SYBProductID = models.PurchaseTaskTypeSYBOrder, &f.syb.ID
+			if err := db.Save(&task).Error; err != nil {
+				t.Fatal(err)
+			}
+			req := ManualRequest{RequestID: uuid.NewString(), OperatorID: 1, Status: models.PurchaseTaskStatusOrderCreated, PDDOrderNo: "DEMO-MANUAL", OrderSubmittedAt: task.IrreversibleAt}
+			got, _, err := s.ResolveUnknown(context.Background(), task.ID, req)
+			if err != nil || got.Status != models.PurchaseTaskStatusOrderCreated || got.PDDOrderAmountCent != nil {
+				t.Fatalf("legacy save: %v", err)
+			}
+			row := loadOrderWriteback(t, db, task.ID)
+			if row.Status != "pending" {
+				t.Fatal(row.Status)
+			}
+			req.RequestID = uuid.NewString()
+			req.PDDOrderAmountCent = &amount
+			got, replay, err := s.ResolveUnknown(context.Background(), task.ID, req)
+			if err != nil || replay || got.PDDOrderAmountCent == nil || *got.PDDOrderAmountCent != amount {
+				t.Fatalf("fill: %v", err)
+			}
+			if got.PaymentReviewStatus != task.PaymentReviewStatus {
+				t.Fatal("payment status changed")
+			}
+			if _, replay, err = s.ResolveUnknown(context.Background(), task.ID, req); err != nil || !replay {
+				t.Fatalf("replay: %v", err)
+			}
+			req.Status = models.PurchaseTaskStatusCancelled
+			if _, _, err = s.ResolveUnknown(context.Background(), task.ID, req); code(err) != CodeResultConflict {
+				t.Fatalf("changed replay status: %v", err)
+			}
+			req.Status = models.PurchaseTaskStatusOrderCreated
+			changed := amount + 1
+			req.PDDOrderAmountCent = &changed
+			if _, _, err = s.ResolveUnknown(context.Background(), task.ID, req); code(err) != CodeResultConflict {
+				t.Fatalf("changed replay: %v", err)
+			}
+			req.RequestID = uuid.NewString()
+			if _, _, err = s.ResolveUnknown(context.Background(), task.ID, req); code(err) != CodeResultConflict {
+				t.Fatalf("overwrite: %v", err)
+			}
+			var count int64
+			db.Model(&models.PurchaseOrderWriteback{}).Where("purchase_task_id = ?", task.ID).Count(&count)
+			if count != 1 {
+				t.Fatalf("duplicate queue: %d", count)
+			}
+		})
+	}
+}
+
+func TestOrderInformationQueueFailureRollsBack(t *testing.T) {
+	db := testDB(t)
+	f := seed(t, db, liveCaps(), true)
+	s := testService(db)
+	task := backfillTask(t, db, f, models.PurchaseTaskStatusOrderResultUnknown)
+	task.TaskType, task.SYBProductID = models.PurchaseTaskTypeSYBOrder, &f.syb.ID
+	if err := db.Save(&task).Error; err != nil {
+		t.Fatal(err)
+	}
+	if err := db.Callback().Create().Before("gorm:create").Register("326_queue_failure", func(tx *gorm.DB) {
+		if _, ok := tx.Statement.Dest.(*models.PurchaseOrderWriteback); ok {
+			tx.AddError(errors.New("synthetic queue failure"))
+		}
+	}); err != nil {
+		t.Fatal(err)
+	}
+	defer db.Callback().Create().Remove("326_queue_failure")
+	amount := int64(100)
+	_, _, err := s.ResolveUnknown(context.Background(), task.ID, ManualRequest{RequestID: uuid.NewString(), OperatorID: 1, Status: models.PurchaseTaskStatusOrderCreated, PDDOrderNo: "DEMO-ROLLBACK", OrderSubmittedAt: task.IrreversibleAt, PDDOrderAmountCent: &amount})
+	if err == nil {
+		t.Fatal("expected failure")
+	}
+	got := loadBackfillTask(t, db, task.ID)
+	if got.PDDOrderNo != nil || got.PDDOrderAmountCent != nil || got.Status != task.Status {
+		t.Fatal("partial transaction saved")
+	}
+}
+
+func TestOrderWritebackFieldBasedEligibility(t *testing.T) {
+	for _, status := range []string{models.PurchaseTaskStatusOrderCreated, models.PurchaseTaskStatusFailed, models.PurchaseTaskStatusCancelled, models.PurchaseTaskStatusOrderResultUnknown} {
+		t.Run(status, func(t *testing.T) {
+			s, task := orderWritebackFixture(t)
+			task.Status = status
+			task.OrderSubmittedAt = nil
+			task.PDDOrderAmountCent = nil
+			if err := s.DB.Save(&task).Error; err != nil {
+				t.Fatal(err)
+			}
+			// Existing queued items must also pass the same relaxed worker check.
+			fake := &fakeOrderNumberClient{apply: true}
+			if _, err := wbWorker(s, fake).RunOnce(context.Background()); err != nil {
+				t.Fatal(err)
+			}
+			if fake.writes != 1 || loadOrderWriteback(t, s.DB, task.ID).Status != "succeeded" {
+				t.Fatal("status/time/amount incorrectly gated worker")
+			}
+			// A failed writeback is selectable for manual compensation.
+			s.DB.Model(&models.PurchaseOrderWriteback{}).Where("purchase_task_id = ?", task.ID).Update("status", "failed")
+			views, err := s.OrderWritebackViews(context.Background(), []models.PurchaseTask{task})
+			if err != nil || !views[task.ID].CanSubmit {
+				t.Fatalf("view: %v", err)
+			}
+			result, err := s.RequestOrderWriteback(context.Background(), OrderWritebackRequest{uuid.NewString(), []uint64{task.ID}})
+			if err != nil || result.Items[0].Result != "pending" {
+				t.Fatalf("request: %v", err)
+			}
+			s.DB.Model(&models.SYBProduct{}).Where("id = ?", *task.SYBProductID).Update("detail_id", 0)
+			views, err = s.OrderWritebackViews(context.Background(), []models.PurchaseTask{task})
+			if err != nil || views[task.ID].CanSubmit {
+				t.Fatal("invalid target selectable")
+			}
+			result, err = s.RequestOrderWriteback(context.Background(), OrderWritebackRequest{uuid.NewString(), []uint64{task.ID}})
+			if err != nil || result.Items[0].Result != "skipped" {
+				t.Fatal("invalid target accepted")
+			}
+		})
+	}
+}
+
+func TestOrderInformationRejectInvalidInputs(t *testing.T) {
+	for _, name := range []string{"negative", "zero_time", "blank_order", "running", "rehearsal"} {
+		t.Run(name, func(t *testing.T) {
+			db := testDB(t)
+			f := seed(t, db, liveCaps(), true)
+			s := testService(db)
+			task := backfillTask(t, db, f, models.PurchaseTaskStatusOrderResultUnknown)
+			amount := int64(100)
+			stamp := *task.IrreversibleAt
+			req := ManualRequest{RequestID: uuid.NewString(), OperatorID: 1, Status: models.PurchaseTaskStatusOrderCreated, PDDOrderNo: "DEMO-INVALID", OrderSubmittedAt: &stamp, PDDOrderAmountCent: &amount}
+			switch name {
+			case "negative":
+				amount = -1
+			case "zero_time":
+				stamp = time.Time{}
+			case "blank_order":
+				req.PDDOrderNo = " "
+			case "running":
+				task.Status = models.PurchaseTaskStatusRunning
+			case "rehearsal":
+				task.ExecutionMode = models.PurchaseExecutionModeRehearsal
+			}
+			if err := db.Save(&task).Error; err != nil {
+				t.Fatal(err)
+			}
+			if _, _, err := s.ResolveUnknown(context.Background(), task.ID, req); err == nil {
+				t.Fatal("invalid input accepted")
+			}
+			if loadBackfillTask(t, db, task.ID).PDDOrderNo != nil {
+				t.Fatal("invalid input persisted")
+			}
+		})
+	}
+}

server/app/goauto/purchase/order_payable_amount_test.go

@@ -0,0 +1,88 @@
+package purchase
+
+import (
+	"context"
+	"testing"
+
+	"github.com/google/uuid"
+	"go-admin/app/goauto/models"
+	"gorm.io/gorm"
+)
+
+func TestOrderResultPayableAmount(t *testing.T) {
+	ptr := func(n int64) *int64 { return &n }
+	for _, tc := range []struct {
+		name                   string
+		amount, existing, want *int64
+		result                 string
+		invalid                bool
+	}{
+		{"payable distinct from unit price", ptr(1300), nil, ptr(1300), "order_created", false},
+		{"zero", ptr(0), nil, ptr(0), "order_created", false},
+		{"old agent omitted", nil, nil, nil, "order_created", false},
+		{"omitted preserves existing", nil, ptr(1200), ptr(1200), "order_created", false},
+		{"does not overwrite existing", ptr(1300), ptr(1200), ptr(1200), "order_created", false},
+		{"negative", ptr(-1), nil, nil, "order_created", true},
+		{"unknown cannot attach amount", ptr(1300), nil, nil, "order_result_unknown", true},
+		{"failed cannot attach amount", ptr(1300), nil, nil, "failed", true},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			db := testDB(t)
+			f := seed(t, db, liveCaps(), true)
+			s := testService(db)
+			task, err := createLive(t, s, f)
+			if err != nil {
+				t.Fatal(err)
+			}
+			started := startLivePurchaseAfterProbe(t, s, f, task)
+			if _, err = s.MarkOrderSubmitStarted(context.Background(), task.ID, ActionRequest{RequestID: uuid.NewString()}, f.token); err != nil {
+				t.Fatal(err)
+			}
+			if tc.existing != nil {
+				if err = db.Session(&gorm.Session{SkipHooks: true}).Model(&models.PurchaseTask{}).Where("id = ?", task.ID).Update("pdd_order_amount_cent", *tc.existing).Error; err != nil {
+					t.Fatal(err)
+				}
+			}
+			now := s.Now()
+			req := ResultRequest{RequestID: uuid.NewString(), TaskAttemptID: started.TaskAttemptID,
+				ResultType: tc.result, PDDOrderNo: "PDD-DEMO-325", OrderSubmittedAt: &now,
+				ActualUnitPriceCent: ptr(1600), PDDOrderAmountCent: tc.amount}
+			_, err = s.SubmitResult(context.Background(), task.ID, req, f.token)
+			if tc.invalid {
+				if code(err) != CodeInvalidRequest {
+					t.Fatalf("want invalid request, got %v", err)
+				}
+			} else {
+				if err != nil {
+					t.Fatal(err)
+				}
+				replay, e := s.SubmitResult(context.Background(), task.ID, req, f.token)
+				if e != nil || !replay.Replayed {
+					t.Fatalf("replay failed: %v", e)
+				}
+				req.PDDOrderAmountCent = ptr(999)
+				if _, e = s.SubmitResult(context.Background(), task.ID, req, f.token); code(e) != CodeResultConflict {
+					t.Fatalf("changed amount replay accepted: %v", e)
+				}
+				queued := loadOrderWriteback(t, db, task.ID)
+				if queued.OrderNo != "PDD-DEMO-325" {
+					t.Fatal("SYB order number queue missing")
+				}
+			}
+			var saved models.PurchaseTask
+			if e := db.First(&saved, task.ID).Error; e != nil {
+				t.Fatal(e)
+			}
+			if (saved.PDDOrderAmountCent == nil) != (tc.want == nil) || (tc.want != nil && *saved.PDDOrderAmountCent != *tc.want) {
+				t.Fatal("unexpected saved payable amount")
+			}
+			if tc.invalid {
+				if saved.Status != models.PurchaseTaskStatusOrderSubmitStarted {
+					t.Fatal("invalid result changed status")
+				}
+			} else if saved.ActualUnitPriceCent == nil || *saved.ActualUnitPriceCent != 1600 {
+				t.Fatal("unit price changed")
+			}
+		})
+	}
+}

server/app/goauto/purchase/order_writeback.go

@@ -37,7 +37,11 @@ type OrderWritebackResponse struct {
 }
 
 func orderWritebackEligible(t models.PurchaseTask) bool {
-	return t.ExecutionMode == models.PurchaseExecutionModeLive && t.TaskType == models.PurchaseTaskTypeSYBOrder && t.Status == models.PurchaseTaskStatusOrderCreated && t.SYBProductID != nil && t.PDDOrderNo != nil && strings.TrimSpace(*t.PDDOrderNo) != ""
+	return t.ExecutionMode == models.PurchaseExecutionModeLive && t.TaskType == models.PurchaseTaskTypeSYBOrder && t.SYBProductID != nil && t.PDDOrderNo != nil && strings.TrimSpace(*t.PDDOrderNo) != ""
+}
+
+func validOrderWritebackTarget(syb models.SYBProduct) bool {
+	return syb.StockID > 0 && syb.DetailID > 0 && syb.StockID <= 1<<63-1 && syb.DetailID <= 1<<63-1
 }
 
 // Called within the same transaction as the order fact. Never contacts SYB.
@@ -52,10 +56,7 @@ func ensureOrderWriteback(tx *gorm.DB, t models.PurchaseTask) error {
 		}
 		return err
 	}
-	if syb.StockID <= 0 || syb.DetailID <= 0 {
-		return nil
-	}
-	if syb.StockID > 1<<63-1 || syb.DetailID > 1<<63-1 {
+	if !validOrderWritebackTarget(syb) {
 		return nil
 	}
 	row := models.PurchaseOrderWriteback{PurchaseTaskID: t.ID, StockID: int64(syb.StockID), DetailID: int64(syb.DetailID), OrderNo: *t.PDDOrderNo, Status: "pending"}
@@ -65,11 +66,31 @@ func ensureOrderWriteback(tx *gorm.DB, t models.PurchaseTask) error {
 func (s *Service) OrderWritebackViews(ctx context.Context, tasks []models.PurchaseTask) (map[uint64]OrderWritebackView, error) {
 	out := map[uint64]OrderWritebackView{}
 	ids := make([]uint64, 0, len(tasks))
+	var sybIDs []uint64
+	for _, t := range tasks {
+		if orderWritebackEligible(t) {
+			sybIDs = append(sybIDs, *t.SYBProductID)
+		}
+	}
+	validTargets := map[uint64]bool{}
+	if len(sybIDs) > 0 {
+		var targets []models.SYBProduct
+		if err := s.DB.WithContext(ctx).Select("id", "stock_id", "detail_id").Where("id IN ?", sybIDs).Find(&targets).Error; err != nil {
+			return nil, internal(err)
+		}
+		for _, target := range targets {
+			validTargets[target.ID] = validOrderWritebackTarget(target)
+		}
+	}
 	for _, t := range tasks {
 		ids = append(ids, t.ID)
-		v := OrderWritebackView{Status: "not_applicable", Reason: "不符合正式SYB订单回填条件"}
+		v := OrderWritebackView{Status: "not_applicable", Reason: "需要正式SYB采购任务、订单号及有效SYB明细"}
 		if orderWritebackEligible(t) {
-			v = OrderWritebackView{Status: "not_started", CanSubmit: true}
+			if validTargets[*t.SYBProductID] {
+				v = OrderWritebackView{Status: "not_started", CanSubmit: true}
+			} else {
+				v.Reason = "SYB明细关联已失效"
+			}
 		}
 		out[t.ID] = v
 	}
@@ -83,9 +104,16 @@ func (s *Service) OrderWritebackViews(ctx context.Context, tasks []models.Purcha
 	for _, r := range rows {
 		v := out[r.PurchaseTaskID]
 		v.Status = r.Status
-		v.Reason = r.ErrorMessage
+		if r.ErrorMessage != "" || v.CanSubmit || r.Status == "succeeded" {
+			v.Reason = r.ErrorMessage
+		}
 		v.CompletedAt = r.CompletedAt
-		v.CanSubmit = v.CanSubmit && (r.Status == "failed" || r.Status == "unknown") && (r.LeaseExpiresAt == nil || !r.LeaseExpiresAt.After(s.Now()))
+		// A session-class failure's LeaseExpiresAt is the automatic-retry backoff
+		// deadline (#330 修订2, order_writeback_worker.go finishSessionUnavailable),
+		// not an in-flight write lease — manual "resubmit" must stay available
+		// during that window instead of being hidden until it expires.
+		sessionBackoff := r.Status == "failed" && r.ErrorCode == "SYB_SESSION_UNAVAILABLE"
+		v.CanSubmit = v.CanSubmit && (r.Status == "failed" || r.Status == "unknown") && (sessionBackoff || r.LeaseExpiresAt == nil || !r.LeaseExpiresAt.After(s.Now()))
 		out[r.PurchaseTaskID] = v
 	}
 	return out, nil
@@ -141,6 +169,15 @@ func (s *Service) RequestOrderWriteback(ctx context.Context, req OrderWritebackR
 				out.Items = append(out.Items, a)
 				continue
 			}
+			var target models.SYBProduct
+			if err := tx.First(&target, *task.SYBProductID).Error; err != nil || !validOrderWritebackTarget(target) {
+				if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+					return err
+				}
+				a.Reason = "SYB明细关联已失效"
+				out.Items = append(out.Items, a)
+				continue
+			}
 			if err := ensureOrderWriteback(tx, task); err != nil {
 				return err
 			}
@@ -165,7 +202,12 @@ func (s *Service) RequestOrderWriteback(ctx context.Context, req OrderWritebackR
 			case row.Status == "pending":
 				a.Result, a.Reason = "pending", "已加入回填"
 			default:
-				if err := tx.Model(&row).Updates(map[string]any{"status": "pending", "write_started": false, "lease_owner": "", "lease_expires_at": nil, "error_code": "", "error_message": ""}).Error; err != nil {
+				// Manual resubmit resets attempt_count to 0 (#330 修订3) so a stale
+				// history of automatic session-class retries never eats into a
+				// fresh manual attempt budget, and clears lease_expires_at so the
+				// worker's bounded auto-retry claim (which requires it non-nil)
+				// does not race a double-claim against this manual pending row.
+				if err := tx.Model(&row).Updates(map[string]any{"status": "pending", "write_started": false, "lease_owner": "", "lease_expires_at": nil, "error_code": "", "error_message": "", "attempt_count": 0}).Error; err != nil {
 					return err
 				}
 				a.Result, a.Reason = "pending", "已加入回填，将先回读SYB"

server/app/goauto/purchase/order_writeback_session_retry_test.go

@@ -0,0 +1,391 @@
+package purchase
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	"go-admin/app/goauto/models"
+	"go-admin/app/goauto/sybclient"
+	"go-admin/config"
+	"gorm.io/gorm"
+)
+
+// wbFactoryWorker builds a worker whose Factory itself fails, exercising the
+// restoreOrderWritebackClient failure path (session unavailable) rather than
+// a remote read/write failure on an otherwise-working client.
+func wbFactoryWorker(s *Service, err error) *OrderWritebackWorker {
+	return &OrderWritebackWorker{DB: s.DB, Now: s.Now, Factory: func(context.Context, *gorm.DB) (OrderNumberClient, error) { return nil, err }}
+}
+
+func TestOrderWritebackSessionFailureSchedulesBoundedRetry(t *testing.T) {
+	s, task := orderWritebackFixture(t)
+	if ok, err := wbFactoryWorker(s, sybclient.ErrNoSession).RunOnce(context.Background()); err != nil || !ok {
+		t.Fatalf("run %v %v", ok, err)
+	}
+	row := loadOrderWriteback(t, s.DB, task.ID)
+	if row.Status != "failed" || row.ErrorCode != "SYB_SESSION_UNAVAILABLE" {
+		t.Fatalf("status=%s code=%s", row.Status, row.ErrorCode)
+	}
+	if row.ErrorMessage == "" || len(row.ErrorMessage) > 300 {
+		t.Fatalf("error message not recorded safely: %q", row.ErrorMessage)
+	}
+	if !strings.Contains(row.ErrorMessage, "会话缺失/已过期") {
+		t.Fatalf("category missing from message: %q", row.ErrorMessage)
+	}
+	if !strings.Contains(row.ErrorMessage, "将自动重试") || !strings.Contains(row.ErrorMessage, "恢复登录") {
+		t.Fatalf("message is not actionable: %q", row.ErrorMessage)
+	}
+	if row.LeaseExpiresAt == nil || !row.LeaseExpiresAt.After(s.Now()) {
+		t.Fatal("no backoff scheduled for first session-class failure")
+	}
+	if row.AttemptCount != 1 {
+		t.Fatalf("attempt_count=%d", row.AttemptCount)
+	}
+}
+
+// TestSessionRetryBackoffTotalExceedsHourlySyncWindow guards the ticket's
+// blocker: the cumulative auto-retry window must outlast one hourly sync
+// period (up to ~60 minutes from failure to the refresh that fixes it),
+// otherwise attempts run out before the session has a chance to recover.
+func TestSessionRetryBackoffTotalExceedsHourlySyncWindow(t *testing.T) {
+	if len(sessionRetryBackoff) != maxSessionRetryAttempts-1 {
+		t.Fatalf("expected %d backoff steps for %d attempts, got %d", maxSessionRetryAttempts-1, maxSessionRetryAttempts, len(sessionRetryBackoff))
+	}
+	var total time.Duration
+	for _, d := range sessionRetryBackoff {
+		total += d
+	}
+	if total <= time.Hour {
+		t.Fatalf("total backoff %s must exceed one hourly sync period", total)
+	}
+}
+
+func TestOrderWritebackSessionFailureNotReclaimedBeforeBackoffExpires(t *testing.T) {
+	s, _ := orderWritebackFixture(t)
+	if _, err := wbFactoryWorker(s, sybclient.ErrNoSession).RunOnce(context.Background()); err != nil {
+		t.Fatal(err)
+	}
+	f := &fakeOrderNumberClient{apply: true}
+	if ok, err := wbWorker(s, f).RunOnce(context.Background()); err != nil || ok {
+		t.Fatalf("claimed before backoff expired: ok=%v err=%v", ok, err)
+	}
+	if f.writes != 0 {
+		t.Fatal("wrote while still inside backoff window")
+	}
+}
+
+// loadOrderWriteback in order_writeback_test.go takes (t, db, id); provide a
+// small adapter so this file reads naturally when task id is already in hand.
+func loadOrderWritebackByTask(t *testing.T, s *Service, id uint64) models.PurchaseOrderWriteback {
+	return loadOrderWriteback(t, s.DB, id)
+}
+
+func TestOrderWritebackSessionFailureReclaimedAfterBackoffExpires(t *testing.T) {
+	s, task := orderWritebackFixture(t)
+	if _, err := wbFactoryWorker(s, sybclient.ErrNoSession).RunOnce(context.Background()); err != nil {
+		t.Fatal(err)
+	}
+	row := loadOrderWritebackByTask(t, s, task.ID)
+	s.Now = func() time.Time { return row.LeaseExpiresAt.Add(time.Second) }
+	f := &fakeOrderNumberClient{apply: true}
+	if ok, err := wbWorker(s, f).RunOnce(context.Background()); err != nil || !ok {
+		t.Fatalf("not reclaimed after backoff expired: ok=%v err=%v", ok, err)
+	}
+	if f.writes != 1 {
+		t.Fatal("did not write after successful reclaim")
+	}
+	after := loadOrderWritebackByTask(t, s, task.ID)
+	if after.Status != "succeeded" {
+		t.Fatalf("status=%s", after.Status)
+	}
+}
+
+func TestOrderWritebackSessionFailureStopsRetryingAtMaxAttempts(t *testing.T) {
+	s, task := orderWritebackFixture(t)
+	now := s.Now()
+	for i := 0; i < maxSessionRetryAttempts; i++ {
+		s.Now = func() time.Time { return now }
+		if ok, err := wbFactoryWorker(s, sybclient.ErrNoSession).RunOnce(context.Background()); err != nil || !ok {
+			t.Fatalf("attempt %d: ok=%v err=%v", i+1, ok, err)
+		}
+		row := loadOrderWritebackByTask(t, s, task.ID)
+		if row.AttemptCount != i+1 {
+			t.Fatalf("attempt %d: attempt_count=%d", i+1, row.AttemptCount)
+		}
+		if i+1 < maxSessionRetryAttempts {
+			if row.LeaseExpiresAt == nil {
+				t.Fatalf("attempt %d: no backoff scheduled", i+1)
+			}
+			now = row.LeaseExpiresAt.Add(time.Second)
+		} else {
+			if row.LeaseExpiresAt != nil {
+				t.Fatal("lease still scheduled at max attempts")
+			}
+		}
+	}
+	// One more tick past any plausible backoff: the claim query must exclude
+	// attempt_count >= maxSessionRetryAttempts, so nothing is claimed.
+	s.Now = func() time.Time { return now.Add(24 * time.Hour) }
+	f := &fakeOrderNumberClient{apply: true}
+	if ok, err := wbWorker(s, f).RunOnce(context.Background()); err != nil || ok {
+		t.Fatalf("claimed a row past max attempts: ok=%v err=%v", ok, err)
+	}
+}
+
+func TestOrderWritebackCheckSessionInvalidIsSessionClassAndNeverDeletesSession(t *testing.T) {
+	s, task := orderWritebackFixture(t)
+	seedWritebackSession(t, s)
+	if ok, err := wbFactoryWorker(s, sybclient.ErrSessionInvalid).RunOnce(context.Background()); err != nil || !ok {
+		t.Fatalf("run %v %v", ok, err)
+	}
+	row := loadOrderWritebackByTask(t, s, task.ID)
+	if row.Status != "failed" || row.ErrorCode != "SYB_SESSION_UNAVAILABLE" {
+		t.Fatalf("status=%s code=%s", row.Status, row.ErrorCode)
+	}
+	if row.LeaseExpiresAt == nil {
+		t.Fatal("ErrSessionInvalid was not scheduled for retry")
+	}
+	assertWritebackSessionUntouched(t, s)
+}
+
+func TestOrderWritebackCheckSessionNetworkErrorIsSessionClassAndNeverDeletesSession(t *testing.T) {
+	s, task := orderWritebackFixture(t)
+	seedWritebackSession(t, s)
+	if ok, err := wbFactoryWorker(s, errors.New("dial tcp: i/o timeout")).RunOnce(context.Background()); err != nil || !ok {
+		t.Fatalf("run %v %v", ok, err)
+	}
+	row := loadOrderWritebackByTask(t, s, task.ID)
+	if row.Status != "failed" || row.ErrorCode != "SYB_SESSION_UNAVAILABLE" {
+		t.Fatalf("status=%s code=%s", row.Status, row.ErrorCode)
+	}
+	if row.LeaseExpiresAt == nil {
+		t.Fatal("network error was not scheduled for retry")
+	}
+	assertWritebackSessionUntouched(t, s)
+}
+
+func seedWritebackSession(t *testing.T, s *Service) {
+	t.Helper()
+	store := sybclient.NewSessionStore(s.DB)
+	// restoreOrderWritebackClient's SessionStore.Load compares against real
+	// wall-clock time.Now(), not the service's mocked s.Now (which fixtures
+	// pin to a fixed past date) — so the session must expire relative to the
+	// real clock or Load reports ErrNoSession even though a row exists.
+	if err := store.Save(context.Background(), sybclient.Session{
+		Username: "syb-writeback-test", UserID: 555, CookiesJSON: `[{"name":"SESSION","value":"x"}]`, ExpiresAt: time.Now().Add(time.Hour),
+	}); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func assertWritebackSessionUntouched(t *testing.T, s *Service) {
+	t.Helper()
+	var count int64
+	if err := s.DB.Model(&models.SYBSession{}).Where("username = ?", "syb-writeback-test").Count(&count).Error; err != nil {
+		t.Fatal(err)
+	}
+	if count != 1 {
+		t.Fatal("writeback worker deleted or otherwise removed the cached SYB session")
+	}
+}
+
+func TestOrderWritebackCanSubmitDuringSessionBackoff(t *testing.T) {
+	s, task := orderWritebackFixture(t)
+	if _, err := wbFactoryWorker(s, sybclient.ErrNoSession).RunOnce(context.Background()); err != nil {
+		t.Fatal(err)
+	}
+	updated := loadBackfillTask(t, s.DB, task.ID)
+	views, err := s.OrderWritebackViews(context.Background(), []models.PurchaseTask{updated})
+	if err != nil {
+		t.Fatal(err)
+	}
+	v := views[task.ID]
+	if v.Status != "failed" || !v.CanSubmit {
+		t.Fatalf("expected resubmit available during backoff: %+v", v)
+	}
+}
+
+func TestOrderWritebackManualResubmitResetsAttemptCountAndLease(t *testing.T) {
+	s, task := orderWritebackFixture(t)
+	now := s.Now()
+	for i := 0; i < 3; i++ {
+		s.Now = func() time.Time { return now }
+		if _, err := wbFactoryWorker(s, sybclient.ErrNoSession).RunOnce(context.Background()); err != nil {
+			t.Fatal(err)
+		}
+		row := loadOrderWritebackByTask(t, s, task.ID)
+		now = row.LeaseExpiresAt.Add(time.Second)
+	}
+	before := loadOrderWritebackByTask(t, s, task.ID)
+	if before.AttemptCount != 3 {
+		t.Fatalf("attempt_count=%d", before.AttemptCount)
+	}
+	if _, err := s.RequestOrderWriteback(context.Background(), OrderWritebackRequest{uuid.NewString(), []uint64{task.ID}}); err != nil {
+		t.Fatal(err)
+	}
+	after := loadOrderWritebackByTask(t, s, task.ID)
+	if after.Status != "pending" || after.AttemptCount != 0 || after.LeaseExpiresAt != nil {
+		t.Fatalf("manual resubmit did not reset state: %+v", after)
+	}
+	f := &fakeOrderNumberClient{apply: true}
+	if ok, err := wbWorker(s, f).RunOnce(context.Background()); err != nil || !ok || f.writes != 1 {
+		t.Fatalf("worker could not process post-resubmit row: ok=%v err=%v writes=%d", ok, err, f.writes)
+	}
+}
+
+func TestOrderWritebackOtherFailureCodesAreNotAutoRetried(t *testing.T) {
+	s, task := orderWritebackFixture(t)
+	f := &fakeOrderNumberClient{readErr: errors.New("offline")}
+	if ok, err := wbWorker(s, f).RunOnce(context.Background()); err != nil || !ok {
+		t.Fatalf("run %v %v", ok, err)
+	}
+	row := loadOrderWritebackByTask(t, s, task.ID)
+	if row.Status != "failed" || row.ErrorCode != "SYB_READ_FAILED" {
+		t.Fatalf("status=%s code=%s", row.Status, row.ErrorCode)
+	}
+	if row.LeaseExpiresAt != nil {
+		t.Fatal("non-session failure code must not be scheduled for automatic retry")
+	}
+	s.Now = func() time.Time { return row.CreatedAt.Add(24 * time.Hour) }
+	again := &fakeOrderNumberClient{apply: true}
+	if ok, err := wbWorker(s, again).RunOnce(context.Background()); err != nil || ok {
+		t.Fatalf("a non-session failure code was auto-reclaimed: ok=%v err=%v", ok, err)
+	}
+}
+
+// --- restoreOrderWritebackClient against a real sybclient.Client + emulated
+// SYB /am/user/get, so the CheckSession probe added by #330 is actually
+// exercised end to end instead of only through a fake Factory. ---
+
+// sybUserGetServer emulates the one endpoint restoreOrderWritebackClient's
+// CheckSession call depends on, using the real envelope shape documented in
+// sybclient/client.go's `envelope` type and asserted against in
+// sybclient/client_test.go.
+func sybUserGetServer(t *testing.T, handler func(w http.ResponseWriter, r *http.Request)) *httptest.Server {
+	t.Helper()
+	mux := http.NewServeMux()
+	mux.HandleFunc("/am/user/get", handler)
+	srv := httptest.NewServer(mux)
+	t.Cleanup(srv.Close)
+	return srv
+}
+
+// withWritebackSYBConfig points config.ExtConfig.SYB at the given test
+// server for the duration of the test, restoring the previous value
+// afterwards so other tests (and any parallel config reads) are unaffected.
+func withWritebackSYBConfig(t *testing.T, baseURL, username string) {
+	t.Helper()
+	prev := config.ExtConfig.SYB
+	config.ExtConfig.SYB = config.SYB{BaseURL: baseURL, Username: username}
+	t.Cleanup(func() { config.ExtConfig.SYB = prev })
+}
+
+func envelopeOK(w http.ResponseWriter, data any) {
+	body, _ := json.Marshal(data)
+	env, _ := json.Marshal(map[string]any{"status": true, "msg": "获取成功", "data": json.RawMessage(body), "code": nil})
+	w.Header().Set("Content-Type", "application/json")
+	w.Write(env)
+}
+
+func TestRestoreOrderWritebackClientValidSessionReturnsClient(t *testing.T) {
+	s, _ := orderWritebackFixture(t)
+	seedWritebackSession(t, s)
+	srv := sybUserGetServer(t, func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Query().Get("id") != strconv.FormatInt(555, 10) {
+			t.Fatalf("unexpected id query: %s", r.URL.RawQuery)
+		}
+		envelopeOK(w, map[string]any{"id": 555, "username": "syb-writeback-test"})
+	})
+	withWritebackSYBConfig(t, srv.URL, "syb-writeback-test")
+	client, err := restoreOrderWritebackClient(context.Background(), s.DB)
+	if err != nil || client == nil {
+		t.Fatalf("expected a usable client, got client=%v err=%v", client, err)
+	}
+	assertWritebackSessionUntouched(t, s)
+}
+
+func TestRestoreOrderWritebackClientMismatchedUsernameIsSessionInvalid(t *testing.T) {
+	s, _ := orderWritebackFixture(t)
+	seedWritebackSession(t, s)
+	srv := sybUserGetServer(t, func(w http.ResponseWriter, r *http.Request) {
+		// SYB says the cookie now belongs to a different account (12 §3.5):
+		// treated the same as an explicit logout.
+		envelopeOK(w, map[string]any{"id": 555, "username": "somebody-else"})
+	})
+	withWritebackSYBConfig(t, srv.URL, "syb-writeback-test")
+	_, err := restoreOrderWritebackClient(context.Background(), s.DB)
+	if !errors.Is(err, sybclient.ErrSessionInvalid) {
+		t.Fatalf("expected ErrSessionInvalid, got %v", err)
+	}
+	assertWritebackSessionUntouched(t, s)
+}
+
+func TestRestoreOrderWritebackClient500IsNotSessionInvalid(t *testing.T) {
+	s, _ := orderWritebackFixture(t)
+	seedWritebackSession(t, s)
+	srv := sybUserGetServer(t, func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusInternalServerError)
+	})
+	withWritebackSYBConfig(t, srv.URL, "syb-writeback-test")
+	_, err := restoreOrderWritebackClient(context.Background(), s.DB)
+	if err == nil {
+		t.Fatal("expected an error for a 5xx response")
+	}
+	if errors.Is(err, sybclient.ErrSessionInvalid) {
+		t.Fatalf("a 5xx must not be classified as a confirmed logout, got %v", err)
+	}
+	assertWritebackSessionUntouched(t, s)
+}
+
+func TestRestoreOrderWritebackClientTimeoutIsNotSessionInvalid(t *testing.T) {
+	s, _ := orderWritebackFixture(t)
+	seedWritebackSession(t, s)
+	srv := sybUserGetServer(t, func(w http.ResponseWriter, r *http.Request) {
+		<-r.Context().Done() // never respond; the client-side ctx timeout fires first
+	})
+	withWritebackSYBConfig(t, srv.URL, "syb-writeback-test")
+	ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
+	defer cancel()
+	_, err := restoreOrderWritebackClient(ctx, s.DB)
+	if err == nil {
+		t.Fatal("expected an error for a request that never completes")
+	}
+	if errors.Is(err, sybclient.ErrSessionInvalid) {
+		t.Fatalf("a timeout must not be classified as a confirmed logout, got %v", err)
+	}
+	assertWritebackSessionUntouched(t, s)
+}
+
+// TestOrderWritebackWorkerWithRealFactoryOnInvalidSession is the requested
+// end-to-end case: the worker's actual Factory (restoreOrderWritebackClient)
+// against a server that reports the cached session invalid. It must record
+// SYB_SESSION_UNAVAILABLE with a scheduled backoff and must not touch the
+// cached session row.
+func TestOrderWritebackWorkerWithRealFactoryOnInvalidSession(t *testing.T) {
+	s, task := orderWritebackFixture(t)
+	seedWritebackSession(t, s)
+	srv := sybUserGetServer(t, func(w http.ResponseWriter, r *http.Request) {
+		envelopeOK(w, map[string]any{"id": 555, "username": "somebody-else"})
+	})
+	withWritebackSYBConfig(t, srv.URL, "syb-writeback-test")
+	w := &OrderWritebackWorker{DB: s.DB, Now: s.Now, Factory: restoreOrderWritebackClient}
+	if ok, err := w.RunOnce(context.Background()); err != nil || !ok {
+		t.Fatalf("run %v %v", ok, err)
+	}
+	row := loadOrderWritebackByTask(t, s, task.ID)
+	if row.Status != "failed" || row.ErrorCode != "SYB_SESSION_UNAVAILABLE" {
+		t.Fatalf("status=%s code=%s", row.Status, row.ErrorCode)
+	}
+	if row.LeaseExpiresAt == nil {
+		t.Fatal("no backoff scheduled")
+	}
+	assertWritebackSessionUntouched(t, s)
+}

server/app/goauto/purchase/order_writeback_worker.go

@@ -24,12 +24,80 @@ type OrderWritebackWorker struct {
 	Factory func(context.Context, *gorm.DB) (OrderNumberClient, error)
 }
 
+// errSessionUserIDMissing marks a cached session whose UserID column is not a
+// positive SYB account id. SessionStore.Save (session.go) rejects UserID<=0
+// before it is ever persisted, so this should be unreachable in practice; it
+// exists so a corrupted/legacy row fails loudly and safely instead of calling
+// CheckSession with id=0 (#330 修订1).
+var errSessionUserIDMissing = errors.New("SYB 会话记录缺少有效 user id")
+
+// Bounded auto-retry for session-class writeback failures (#330). A session
+// outage self-heals once GoAutoSYBHourlySync refreshes syb_session, but that
+// refresh only happens once per hour (at :05) and only fires the run *after*
+// the session is found dead — so the wait from failure to refresh can be
+// close to a full hour. The backoff schedule below sums to ~90 minutes
+// (5+10+15+30+30) across maxSessionRetryAttempts=6 attempts, deliberately
+// longer than one hourly sync period so a session recovered by "the next"
+// hourly run is still caught automatically instead of exhausting attempts
+// first. maxSessionRetryAttempts caps the automatic attempts so a session
+// that never recovers still lands back in "failed" for a human instead of
+// retrying forever.
+const maxSessionRetryAttempts = 6
+
+var sessionRetryBackoff = []time.Duration{
+	5 * time.Minute,
+	10 * time.Minute,
+	15 * time.Minute,
+	30 * time.Minute,
+	30 * time.Minute,
+}
+
+// sessionRetryDelay returns the backoff before the next automatic attempt,
+// given the attempt number (1-based, i.e. the count already recorded for the
+// attempt that just failed).
+func sessionRetryDelay(attempt int) time.Duration {
+	idx := attempt - 1
+	if idx < 0 {
+		idx = 0
+	}
+	if idx >= len(sessionRetryBackoff) {
+		idx = len(sessionRetryBackoff) - 1
+	}
+	return sessionRetryBackoff[idx]
+}
+
+// sessionUnavailableMessage classifies why the cached SYB session could not
+// be used, without ever including cookies, tokens or other credential
+// material (#330 修订1点3). The category — not the raw error text — is what
+// gets persisted to error_message, wrapped in a fixed, actionable template
+// that stays well under the 300-char column limit.
+func sessionUnavailableMessage(err error) string {
+	category := "会话恢复失败（网络/其他）"
+	switch {
+	case errors.Is(err, sybclient.ErrNoSession):
+		category = "会话缺失/已过期"
+	case errors.Is(err, errSessionUserIDMissing):
+		category = "会话记录异常，缺少 user id"
+	case errors.Is(err, sybclient.ErrSessionInvalid):
+		category = "会话校验失效"
+	}
+	return "SYB会话不可用（" + category + "），将自动重试；如持续失败请恢复登录后重试"
+}
+
+// restoreOrderWritebackClient rebuilds a SYB client from the cached session
+// only. It never logs in, never triggers OCR and never deletes the cached
+// session (that stays the exclusive responsibility of sybimport.Connect's
+// login/refresh path) — it only reports whether the cached cookies still
+// work, via CheckSession, so the caller can classify the failure (#330).
 func restoreOrderWritebackClient(ctx context.Context, db *gorm.DB) (OrderNumberClient, error) {
 	cfg := config.ExtConfig.SYB.Resolved()
 	session, err := sybclient.NewSessionStore(db).Load(ctx, cfg.Username, time.Now())
 	if err != nil {
 		return nil, err
 	}
+	if session.UserID <= 0 {
+		return nil, errSessionUserIDMissing
+	}
 	c, err := sybclient.New(cfg.BaseURL)
 	if err != nil {
 		return nil, err
@@ -37,6 +105,16 @@ func restoreOrderWritebackClient(ctx context.Context, db *gorm.DB) (OrderNumberC
 	if err = c.ImportCookiesJSON(session.CookiesJSON); err != nil {
 		return nil, err
 	}
+	// Active probe (#330 修订1): without this, a remotely-expired cookie jar
+	// imports cleanly and only fails later inside read(), which would record
+	// it as SYB_READ_FAILED instead of the retryable session-class outcome.
+	// Any error here — ErrSessionInvalid or network/format — is treated as
+	// session-class; only ErrSessionInvalid is a confirmed logout, but a
+	// network/format error is not confirmed-valid either, so it is still
+	// retried rather than attempted as a write.
+	if err = c.CheckSession(ctx, session.UserID, cfg.Username); err != nil {
+		return nil, err
+	}
 	return c, nil
 }
 
@@ -78,7 +156,10 @@ func (w *OrderWritebackWorker) RunOnce(ctx context.Context) (bool, error) {
 	var item models.PurchaseOrderWriteback
 	recovering := false
 	err := db.Transaction(func(tx *gorm.DB) error {
-		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).Where("status = ? OR (status = ? AND lease_expires_at <= ?)", "pending", "running", now).Order("id").First(&item).Error; err != nil {
+		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).Where(
+			"status = ? OR (status = ? AND lease_expires_at <= ?) OR (status = ? AND error_code = ? AND lease_expires_at IS NOT NULL AND lease_expires_at <= ? AND attempt_count < ?)",
+			"pending", "running", now, "failed", "SYB_SESSION_UNAVAILABLE", now, maxSessionRetryAttempts,
+		).Order("id").First(&item).Error; err != nil {
 			return err
 		}
 		recovering = item.Status == "running"
@@ -90,6 +171,11 @@ func (w *OrderWritebackWorker) RunOnce(ctx context.Context) (bool, error) {
 	if err != nil {
 		return false, err
 	}
+	// tx.Model(&item).Updates used gorm.Expr("attempt_count + 1") above, which
+	// GORM does not read back into the struct; sync it here so downstream
+	// bounded-retry math (finishSessionUnavailable) sees the true post-claim
+	// count instead of being off by one.
+	item.AttemptCount++
 	finish := func(status, code, message string) error {
 		updates := map[string]any{"status": status, "error_code": code, "error_message": message, "lease_owner": ""}
 		if status != "unknown" {
@@ -100,6 +186,23 @@ func (w *OrderWritebackWorker) RunOnce(ctx context.Context) (bool, error) {
 		}
 		return db.Model(&models.PurchaseOrderWriteback{}).Where("id = ? AND status = 'running' AND lease_owner = ?", item.ID, owner).Updates(updates).Error
 	}
+	// finishSessionUnavailable is the bounded-retry counterpart of finish for
+	// SYB_SESSION_UNAVAILABLE: instead of clearing the lease, it schedules the
+	// next automatic attempt (item.AttemptCount was already incremented by the
+	// claim above) until maxSessionRetryAttempts is reached, at which point it
+	// behaves like finish("failed", ...) and stops retrying (#330).
+	finishSessionUnavailable := func(err error) error {
+		updates := map[string]any{
+			"status": "failed", "error_code": "SYB_SESSION_UNAVAILABLE",
+			"error_message": sessionUnavailableMessage(err), "lease_owner": "",
+		}
+		if item.AttemptCount < maxSessionRetryAttempts {
+			updates["lease_expires_at"] = w.Now().Add(sessionRetryDelay(item.AttemptCount))
+		} else {
+			updates["lease_expires_at"] = nil
+		}
+		return db.Model(&models.PurchaseOrderWriteback{}).Where("id = ? AND status = 'running' AND lease_owner = ?", item.ID, owner).Updates(updates).Error
+	}
 	var task models.PurchaseTask
 	if err = db.First(&task, item.PurchaseTaskID).Error; err != nil {
 		return true, finish("failed", "TASK_UNAVAILABLE", "采购任务不可用，请人工核对")
@@ -108,14 +211,14 @@ func (w *OrderWritebackWorker) RunOnce(ctx context.Context) (bool, error) {
 	if !orderWritebackEligible(task) || *task.PDDOrderNo != item.OrderNo {
 		return true, finish("conflict", "ORDER_FACT_CHANGED", "采购订单事实已变化，请人工核对")
 	}
-	if err = db.First(&syb, *task.SYBProductID).Error; err != nil || int64(syb.StockID) != item.StockID || int64(syb.DetailID) != item.DetailID {
+	if err = db.First(&syb, *task.SYBProductID).Error; err != nil || !validOrderWritebackTarget(syb) || int64(syb.StockID) != item.StockID || int64(syb.DetailID) != item.DetailID {
 		return true, finish("conflict", "SYB_TARGET_CHANGED", "SYB商品明细关联已变化")
 	}
 	callCtx, cancel := context.WithTimeout(ctx, 25*time.Second)
 	client, err := w.Factory(callCtx, db)
 	cancel()
 	if err != nil {
-		return true, finish("failed", "SYB_SESSION_UNAVAILABLE", "SYB会话不可用，请恢复登录后重试")
+		return true, finishSessionUnavailable(err)
 	}
 	read := func() (string, string, error) {
 		readCtx, stop := context.WithTimeout(ctx, 20*time.Second)

server/app/goauto/purchase/types.go

@@ -157,6 +157,7 @@ type ResultRequest struct {
 	PDDOrderNo          string          `json:"pddOrderNo,omitempty"`
 	OrderSubmittedAt    *time.Time      `json:"orderSubmittedAt,omitempty"`
 	ActualUnitPriceCent *int64          `json:"actualUnitPriceCent,omitempty"`
+	PDDOrderAmountCent  *int64          `json:"pddOrderAmountCent,omitempty"`
 	ErrorCode           string          `json:"errorCode,omitempty"`
 	ErrorMessage        string          `json:"errorMessage,omitempty"`
 	ProbedSpecs         json.RawMessage `json:"probedSpecs,omitempty"`
@@ -179,10 +180,11 @@ type SpecDecisionRequest struct {
 }
 
 type ManualRequest struct {
-	RequestID        string     `json:"requestId"`
-	OperatorID       uint64     `json:"operatorId"`
-	Reason           string     `json:"reason,omitempty"`
-	Status           string     `json:"status,omitempty"`
-	PDDOrderNo       string     `json:"pddOrderNo,omitempty"`
-	OrderSubmittedAt *time.Time `json:"orderSubmittedAt,omitempty"`
+	RequestID          string     `json:"requestId"`
+	OperatorID         uint64     `json:"operatorId"`
+	Reason             string     `json:"reason,omitempty"`
+	Status             string     `json:"status,omitempty"`
+	PDDOrderNo         string     `json:"pddOrderNo,omitempty"`
+	OrderSubmittedAt   *time.Time `json:"orderSubmittedAt,omitempty"`
+	PDDOrderAmountCent *int64     `json:"pddOrderAmountCent,omitempty"`
 }

server/app/goauto/shopeeproduct/handler.go

@@ -11,6 +11,7 @@ import (
 
 	"github.com/gin-gonic/gin"
 	"github.com/go-admin-team/go-admin-core/sdk/pkg"
+	jwt "github.com/go-admin-team/go-admin-core/sdk/pkg/jwtauth"
 	"gorm.io/gorm"
 )
 
@@ -120,6 +121,8 @@ func (handler Handler) LinkPDD(c *gin.Context) {
 		return
 	}
 	service.ReplacementEligibility = handler.ReplacementEligibility
+	service.OperatorUserID = currentUserID(c)
+	service.OperatorIsAdmin = currentRole(c) == "admin"
 	response, err := service.LinkPDD(c.Request.Context(), id, request)
 	respond(c, response, err)
 }
@@ -442,6 +445,11 @@ func currentUserID(c *gin.Context) uint64 {
 	}
 }
 
+func currentRole(c *gin.Context) string {
+	value, _ := jwt.ExtractClaims(c)["rolekey"].(string)
+	return value
+}
+
 func respond(c *gin.Context, response SaveResponse, err error) {
 	if err != nil {
 		writeError(c, err)
@@ -489,6 +497,8 @@ func writeError(c *gin.Context, err error) {
 		status = http.StatusNotFound
 	case CodePDDProductDisabled, CodeSpecContextStale, CodeLatestCollectionUnavailable, CodeLinkConflict:
 		status = http.StatusConflict
+	case CodeDeviceOwnershipForbidden:
+		status = http.StatusForbidden
 	case CodeAIUnavailable:
 		status = http.StatusServiceUnavailable
 	}

server/app/goauto/shopeeproduct/latest_collection.go

@@ -11,6 +11,7 @@ import (
 
 const CodeLatestCollectionUnavailable = "LATEST_COLLECTION_UNAVAILABLE"
 const CodeLinkConflict = "PDD_LINK_CONFLICT"
+const CodeDeviceOwnershipForbidden = "DEVICE_OWNERSHIP_FORBIDDEN"
 
 type LatestCollectionRequest struct {
 	SYBProductID       uint64                       `json:"sybProductId"`
@@ -105,6 +106,9 @@ func (service *Service) linkLatestCollection(ctx context.Context, id uint64, req
 		if device.Status != models.DeviceStatusOnline && device.Status != models.DeviceStatusOffline {
 			return latestUnavailable("手机已停用，请重新选择")
 		}
+		if service.OperatorUserID > 0 && !service.OperatorIsAdmin && (device.OwnerUserID == nil || *device.OwnerUserID != service.OperatorUserID) {
+			return &ServiceError{Code: CodeDeviceOwnershipForbidden, Message: "该手机不属于当前采购员，无法使用其采集记录", Retryable: false}
+		}
 		var task models.CollectionTask
 		query := tx.Clauses(clause.Locking{Strength: "UPDATE"}).Where("device_id = ? AND source = ? AND status IN ?", r.DeviceID, models.CollectionTaskSourceAgentCurrentPage, []string{models.TaskStatusCompleted, models.TaskStatusCompletedPartial})
 		if replacement != nil && !replacement.Preview {

server/app/goauto/shopeeproduct/latest_collection_test.go

@@ -63,6 +63,21 @@ func TestLatestCollectionOfflineAndOnlyIfUnlinked(t *testing.T) {
 	}
 }
 
+func TestLatestCollectionRejectsDeviceOwnedByAnotherUser(t *testing.T) {
+	s, id, req, _ := latestFixture(t)
+	owner := uint64(21)
+	s.DB.Model(&models.AgentDevice{}).Where("id = ?", req.LatestCollection.DeviceID).Update("owner_user_id", owner)
+	s.OperatorUserID = 22
+	if _, err := s.LinkPDD(context.Background(), id, req); err == nil || errCode(t, err) != CodeDeviceOwnershipForbidden {
+		t.Fatalf("expected ownership rejection: %v", err)
+	}
+	var product models.ShopeeProduct
+	s.DB.First(&product, id)
+	if product.PDDProductID != nil {
+		t.Fatal("ownership rejection wrote association")
+	}
+}
+
 func TestLatestCollectionRejectsInvalidContextWithoutWrite(t *testing.T) {
 	cases := []struct {
 		name   string

server/app/goauto/shopeeproduct/service.go

@@ -62,6 +62,8 @@ type ReplacementEligibility func(context.Context, *gorm.DB, uint64) error
 type Service struct {
 	DB                     *gorm.DB
 	ReplacementEligibility ReplacementEligibility
+	OperatorUserID         uint64
+	OperatorIsAdmin        bool
 }
 
 func NewService(db *gorm.DB) *Service { return &Service{DB: db} }

server/cmd/migrate/migration/version-local/1789800300000_device_owner.go

@@ -0,0 +1,22 @@
+package version_local
+
+import (
+	goautomigrations "go-admin/app/goauto/migrations"
+	"go-admin/cmd/migrate/migration"
+	common "go-admin/common/models"
+	"gorm.io/gorm"
+	"path/filepath"
+)
+
+func init() {
+	fileName := filepath.Base("1789800300000_device_owner.go")
+	migration.Migrate.SetVersion(migration.GetFilename(fileName), migrateDeviceOwner)
+}
+func migrateDeviceOwner(tx *gorm.DB, version string) error {
+	return tx.Transaction(func(db *gorm.DB) error {
+		if err := goautomigrations.Migrate(db); err != nil {
+			return err
+		}
+		return db.Create(&common.Migration{Version: version}).Error
+	})
+}

web/src/api/goauto/devices.js

@@ -8,6 +8,14 @@ export function listDevices(params) {
   })
 }
 
+export function listDeviceOwners() {
+  return request({ url: '/api/admin/v1/devices/owners', method: 'get' })
+}
+
+export function setDeviceOwner(deviceId, ownerUserId) {
+  return request({ url: `/api/admin/v1/devices/${deviceId}/owner`, method: 'patch', data: { ownerUserId} })
+}
+
 export function disableDevice(deviceId) {
   return request({
     url: `/api/admin/v1/devices/${deviceId}/disable`,

web/src/views/goauto/devices/index.vue

@@ -34,6 +34,9 @@
               <div class="device-model">{{ row.manufacturer }} {{ row.model }}</div>
             </template>
           </el-table-column>
+          <el-table-column label="所属采购员" min-width="150">
+            <template #default="{ row }">{{ ownerLabel(row) }}</template>
+          </el-table-column>
           <el-table-column label="系统" min-width="130">
             <template #default="{ row }">Android {{ row.androidVersion }}</template>
           </el-table-column>
@@ -70,6 +73,7 @@
           </el-table-column>
           <el-table-column v-if="isAdmin" label="操作" width="270" fixed="right">
             <template #default="{ row }">
+              <el-button type="primary" link @click="openOwnerDialog(row)">归属</el-button>
               <el-button
                 type="warning"
                 link
@@ -90,7 +94,7 @@
               >吊销 Token</el-button>
             </template>
           </el-table-column>
-        </el-table>
+      </el-table>
 
         <pagination
           v-show="total > 0"
@@ -100,6 +104,13 @@
           @pagination="getList"
         />
       </el-card>
+      <el-dialog v-model="ownerDialog.open" title="设置所属采购员" width="420px">
+        <p v-if="ownerDialog.row">设备：{{ ownerDialog.row.name }}（#{{ ownerDialog.row.id }}）</p>
+        <el-select v-model="ownerDialog.ownerUserId" clearable placeholder="未归属" style="width: 100%" :loading="ownerDialog.loading">
+          <el-option v-for="owner in ownerDialog.owners" :key="owner.userId" :label="owner.nickName || owner.username" :value="owner.userId" />
+        </el-select>
+        <template #footer><el-button @click="ownerDialog.open = false">取消</el-button><el-button type="primary" :loading="ownerDialog.saving" @click="saveOwner">保存</el-button></template>
+      </el-dialog>
       <el-drawer v-model="releaseDrawer.open" title="Agent 版本管理" size="720px" destroy-on-close>
         <el-alert type="info" :closable="false" show-icon title="上传后需明确设为当前版本；APK 下载需要 Admin 或设备 Token，不提供公开静态地址。" />
         <el-form label-position="top" class="release-upload-form">
@@ -122,7 +133,7 @@
 <script>
 import { ElMessage, ElMessageBox } from 'element-plus'
 import { Refresh, RefreshLeft, Search } from '@element-plus/icons-vue'
-import { disableDevice, listDevices, resetDeviceIdentity, revokeDeviceToken } from '@/api/goauto/devices'
+import { disableDevice, listDeviceOwners, listDevices, resetDeviceIdentity, revokeDeviceToken, setDeviceOwner } from '@/api/goauto/devices'
 import { downloadAgentAppRelease, listAgentAppReleases, setCurrentAgentAppRelease, uploadAgentAppRelease } from '@/api/goauto/agent-app-releases'
 import { createRequestId } from '@/utils/request-id'
 
@@ -137,7 +148,8 @@ export default {
       devices: [],
       total: 0,
       query: { page: 1, pageSize: 20, name: '', status: '' },
-      releaseDrawer: { open: false, loading: false, uploading: false, progress: 0, file: null, notes: '', items: [] }
+      releaseDrawer: { open: false, loading: false, uploading: false, progress: 0, file: null, notes: '', items: [] },
+      ownerDialog: { open: false, loading: false, saving: false, row: null, ownerUserId: null, owners: [] }
     }
   },
   computed: {
@@ -171,6 +183,9 @@ export default {
     statusType(status) {
       return { online: 'success', offline: 'info', disabled: 'danger' }[status] || 'info'
     },
+    ownerLabel(row) { if (!row.ownerUserId) return '未归属'; const owner = this.ownerDialog.owners.find(item => item.userId === row.ownerUserId); return owner ? (owner.nickName || owner.username) : `用户 #${row.ownerUserId}` },
+    async openOwnerDialog(row) { this.ownerDialog.row = row; this.ownerDialog.ownerUserId = row.ownerUserId || null; this.ownerDialog.open = true; this.ownerDialog.loading = true; try { this.ownerDialog.owners = (await listDeviceOwners()).data || [] } finally { this.ownerDialog.loading = false } },
+    async saveOwner() { if (!this.ownerDialog.row) return; this.ownerDialog.saving = true; try { await setDeviceOwner(this.ownerDialog.row.id, this.ownerDialog.ownerUserId); ElMessage.success('设备归属已更新'); this.ownerDialog.open = false; await this.getList() } finally { this.ownerDialog.saving = false } },
     async openReleases() { this.releaseDrawer.open = true; await this.loadReleases() },
     async loadReleases() { this.releaseDrawer.loading = true; try { const response = await listAgentAppReleases({ page: 1, pageSize: 100 }); this.releaseDrawer.items = response.data.items } finally { this.releaseDrawer.loading = false } },
     onAPKChange(file) { this.releaseDrawer.file = file.raw }, onAPKRemove() { this.releaseDrawer.file = null },

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

@@ -25,7 +25,7 @@
           <el-table-column label="设备" min-width="140"><template #default="{ row }"><div>{{ row.deviceName || '尚未分派' }}</div><div class="muted">账号：{{ row.pddAccountRefSnapshot || '不强制记录' }}</div></template></el-table-column>
           <el-table-column label="状态" width="150" align="center"><template #default="{ row }"><el-tag :type="statusType(row.status)">{{ statusLabel(row.status) }}</el-tag><el-tooltip v-if="row.status === 'failed' && !row.retryable" :content="row.retryDisabledReason || '当前任务不能重试'" placement="top"><span class="retry-disabled" tabindex="0">不可重试</span></el-tooltip></template></el-table-column>
 		  <el-table-column label="规格匹配" min-width="150"><template #default="{ row }"><el-tag :type="matchingType(row.matching?.status)" effect="plain">{{ matchingLabel(row.matching?.status) }}</el-tag><div v-if="row.matching && !row.matching.executable" class="muted">{{ row.matching.reason || '完成前不可执行' }}</div></template></el-table-column>
-          <el-table-column label="订单 / 支付" min-width="170"><template #default="{ row }"><div>{{ row.pddOrderNo || '尚未取得订单号' }}</div><div class="muted">{{ paymentLabel(row.paymentReviewStatus) }}</div></template></el-table-column>
+          <el-table-column label="订单 / 支付" min-width="170"><template #default="{ row }"><div>{{ row.pddOrderNo || '尚未取得订单号' }}</div><div v-if="row.pddOrderNo" class="muted">{{ orderInformationComplete(row) ? '信息完整' : '订单信息待补全' }}</div><div class="muted">{{ paymentLabel(row.paymentReviewStatus) }}</div></template></el-table-column>
           <el-table-column label="SYB 单号回填" min-width="170"><template #default="{ row }"><span>{{ orderWritebackLabel(row.orderWriteback?.status) }}</span><div class="muted">{{ row.orderWriteback?.reason || '' }}</div></template></el-table-column>
           <el-table-column label="创建时间" width="170"><template #default="{ row }">{{ formatTime(row.createdAt) }}</template></el-table-column>
           <el-table-column label="操作" width="90" fixed="right"><template #default="{ row }"><el-button type="primary" link @click="openDetail(row)">详情</el-button></template></el-table-column>
@@ -57,7 +57,7 @@
 			  <div v-if="['manual_required','cancelled'].includes(detail.matching.status)" class="matching-actions"><el-button :loading="matchingAction.saving" @click="requeueMatching">重新尝试 AI</el-button><el-button v-if="detail.matching.status === 'manual_required'" type="primary" @click="openMatchingDialog">人工选择规格</el-button></div>
 			</section>
             <section><h3>订单与人工处理</h3><div class="state-grid">
-              <div class="state-card"><span>订单</span><strong>{{ detail.task.pddOrderNo || '尚未取得订单号' }}</strong><small>{{ detail.task.orderSubmittedAt ? `下单时间 ${formatTime(detail.task.orderSubmittedAt)}` : '获取订单号失败即采购失败' }}</small><small>实付价格：{{ detail.task.pddOrderAmountCent == null ? '尚未获取' : priceText(detail.task.pddOrderAmountCent, 'CNY') }}</small></div>
+              <div class="state-card"><span>订单</span><strong>{{ detail.task.pddOrderNo || '尚未取得订单号' }}</strong><small>{{ detail.task.orderSubmittedAt ? `下单时间 ${formatTime(detail.task.orderSubmittedAt)}` : '下单时间尚未获取' }}</small><small>订单金额：{{ detail.task.pddOrderAmountCent == null ? '尚未获取' : priceText(detail.task.pddOrderAmountCent, 'CNY') }}</small><small>{{ orderInformationComplete(detail.task) ? '信息完整' : '订单信息待补全；请先核对已有订单，不要重复采购。' }}</small></div>
               <div class="state-card"><span>支付复核</span><strong>{{ paymentLabel(detail.task.paymentReviewStatus) }}</strong><small>{{ detail.task.paymentReviewedAt ? formatTime(detail.task.paymentReviewedAt) : '仅人工记录，系统不支付' }}</small></div>
               <div class="state-card"><span>物流</span><strong>{{ logisticsLabel(detail.task.logisticsStatus) }}</strong><small>{{ detail.task.trackingNo || '尚未取得快递单号' }}</small></div>
               <div v-if="detail.task.taskType !== 'stock'" class="state-card"><span>SYB 物流回填</span><strong>{{ writebackLabel(detail.task.writebackStatus) }}</strong><small>{{ detail.task.writebackAt ? formatTime(detail.task.writebackAt) : '由独立回填流程处理' }}</small></div>
@@ -75,6 +75,7 @@
               <el-button v-if="detail.task.status === 'order_created' && detail.task.paymentReviewStatus === 'pending'" type="success" @click="confirmPayment('paid')">标记已支付</el-button>
               <el-button v-if="canSelectWriteback" type="primary" plain @click="confirmWriteback">选为回填候选</el-button>
               <el-button v-if="detail.task.status === 'order_result_unknown'" type="warning" @click="openUnknownDialog">处理未知结果</el-button>
+              <el-button v-if="detail.task.executionMode === 'live' && detail.task.status === 'order_created' && !orderInformationComplete(detail.task)" type="primary" plain @click="openUnknownDialog">补全订单信息</el-button>
               <el-button v-if="canAuthorizeRepurchase" type="warning" plain @click="openRepurchaseDialog">允许重新采购</el-button>
               <el-button v-if="canCancel" type="danger" plain @click="openCancelDialog">标记已取消</el-button>
             </div>
@@ -127,13 +128,14 @@
         <template #footer><el-button @click="cancelDialog.open=false">返回</el-button><el-button type="danger" :disabled="!cancelDialog.reason.trim()" :loading="cancelDialog.saving" @click="submitCancel">确认已取消</el-button></template>
       </el-dialog>
 
-      <el-dialog v-model="unknown.open" title="处理订单结果未知" width="620px" :close-on-click-modal="false">
+      <el-dialog v-model="unknown.open" :title="detail.task?.status === 'order_created' ? '补全订单信息' : '处理订单结果未知'" width="620px" :close-on-click-modal="false" :close-on-press-escape="!unknown.saving" :show-close="!unknown.saving">
         <el-alert title="请先人工核对 PDD 订单。未确认前不要重复采购，避免产生重复订单。" type="warning" :closable="false" show-icon class="notice" />
-        <el-form label-position="top"><el-form-item label="核对结果"><el-radio-group v-model="unknown.status"><el-radio value="order_created">订单已创建</el-radio><el-radio value="cancelled">确认没有订单，标记已取消</el-radio></el-radio-group></el-form-item>
-          <template v-if="unknown.status === 'order_created'"><el-form-item label="PDD 订单号"><el-input v-model="unknown.pddOrderNo" /></el-form-item><el-form-item label="下单时间"><el-date-picker v-model="unknown.orderSubmittedAt" type="datetime" value-format="YYYY-MM-DDTHH:mm:ssZ" placeholder="选择下单时间" style="width:100%" /></el-form-item></template>
+        <el-form label-position="top" :disabled="unknown.saving"><el-form-item v-if="detail.task?.status === 'order_result_unknown'" label="核对结果"><el-radio-group v-model="unknown.status"><el-radio value="order_created">订单已创建</el-radio><el-radio value="cancelled">确认没有订单，标记已取消</el-radio></el-radio-group></el-form-item>
+          <template v-if="unknown.status === 'order_created'"><el-form-item label="PDD 订单号" required><el-input v-model="unknown.pddOrderNo" :readonly="Boolean(detail.task?.pddOrderNo)" /></el-form-item><el-form-item label="下单时间" required><el-date-picker v-model="unknown.orderSubmittedAt" :disabled="Boolean(detail.task?.orderSubmittedAt)" type="datetime" value-format="YYYY-MM-DDTHH:mm:ssZ" placeholder="选择下单时间" style="width:100%" /></el-form-item><el-form-item label="订单金额（人民币元）" required :error="unknown.amountYuan && orderAmountCent(unknown.amountYuan) === null ? '请输入不小于0、最多两位小数的金额' : ''"><el-input v-model="unknown.amountYuan" :readonly="detail.task?.pddOrderAmountCent != null" placeholder="例如 13.00" inputmode="decimal" /></el-form-item><p class="muted">订单金额只存 Admin，不代表已付款；SYB 仅回填订单号。</p></template>
           <el-form-item v-else label="说明"><el-input v-model="unknown.reason" type="textarea" :rows="3" maxlength="300" show-word-limit /></el-form-item>
         </el-form>
-        <template #footer><el-button @click="unknown.open=false">返回</el-button><el-button type="warning" :disabled="!canSubmitUnknown" :loading="unknown.saving" @click="submitUnknown">确认处理结果</el-button></template>
+        <el-alert v-if="unknown.error" :title="unknown.error" type="error" :closable="false" show-icon />
+        <template #footer><el-button :disabled="unknown.saving" @click="unknown.open=false">返回</el-button><el-button type="primary" :disabled="!canSubmitUnknown || unknown.saving" :loading="unknown.saving" @click="submitUnknown">保存</el-button></template>
       </el-dialog>
     </template>
   </BasicLayout>
@@ -155,7 +157,7 @@ export default {
   setup() { return { RefreshLeft, Search } },
   data() {
     return {
-      loading: false, loadError: '', tasks: [], total: 0, statuses: statusOptions,
+      loading: false, loadError: '', tasks: [], total: 0, statuses: [...statusOptions, { value: 'syb_writeback_succeeded', label: '已回填 SYB' }],
       orderWriteback: { open: false, saving: false, items: [] },
       query: { page: 1, pageSize: 20, taskId: '', taskType: '', shopeeOrderNo: '', status: '', executionMode: 'live', sybProductId: '', pddOrderNo: '' },
 	  detail: { open: false, loading: false, task: null, attempts: [], matching: null },
@@ -165,7 +167,7 @@ export default {
 	  retryResult: { open: false, items: [], createdCount: 0, failedCount: 0 },
 	  repurchase: { open: false, saving: false, reason: '', confirmText: '' },
 	  cancelDialog: { open: false, saving: false, reason: '' },
-	  unknown: { open: false, saving: false, status: 'order_created', pddOrderNo: '', orderSubmittedAt: '', reason: '' }
+	  unknown: { open: false, saving: false, status: 'order_created', pddOrderNo: '', orderSubmittedAt: '', amountYuan: '', reason: '', error: '' }
     }
   },
   computed: {
@@ -183,7 +185,7 @@ export default {
     canSelectWriteback() { const t = this.detail.task; return t && t.taskType !== 'stock' && t.status === 'order_created' && t.paymentReviewStatus === 'paid' && t.writebackStatus === 'not_selected' },
     canCancel() { const t = this.detail.task; return t && !['running', 'order_submit_started', 'cancelled'].includes(t.status) },
     canSubmitRepurchase() { return this.repurchase.reason.trim() && this.repurchase.confirmText === '允许重新采购' },
-    canSubmitUnknown() { return this.unknown.status === 'order_created' ? this.unknown.pddOrderNo.trim() && this.unknown.orderSubmittedAt : this.unknown.reason.trim() },
+    canSubmitUnknown() { return this.unknown.status === 'order_created' ? this.unknown.pddOrderNo.trim() && this.unknown.orderSubmittedAt && this.orderAmountCent(this.unknown.amountYuan) !== null : this.unknown.reason.trim() },
 	canSubmitMatching() { const m = this.detail.matching || {}; return (!m.targetColor || this.matchingDialog.color) && (!m.targetSize || this.matchingDialog.size) },
     firstRetriedTask() { return this.retryResult.items.find(item => item.created && item.taskId) || null }
   },
@@ -272,8 +274,20 @@ export default {
     async submitRepurchase() { this.repurchase.saving = true; try { await this.runAction(() => authorizeRepurchase(this.detail.task.id, { requestId: this.requestId(), reason: this.repurchase.reason.trim() }), '已授权一次重新采购'); this.repurchase.open = false } finally { this.repurchase.saving = false } },
     openCancelDialog() { this.cancelDialog = { open: true, saving: false, reason: '' } },
     async submitCancel() { this.cancelDialog.saving = true; try { await this.runAction(() => cancelPurchaseTask(this.detail.task.id, { requestId: this.requestId(), reason: this.cancelDialog.reason.trim() }), '已标记任务取消'); this.cancelDialog.open = false } finally { this.cancelDialog.saving = false } },
-    openUnknownDialog() { this.unknown = { open: true, saving: false, status: 'order_created', pddOrderNo: '', orderSubmittedAt: '', reason: '' } },
-    async submitUnknown() { const payload = { requestId: this.requestId(), status: this.unknown.status, pddOrderNo: this.unknown.pddOrderNo.trim() || undefined, orderSubmittedAt: this.unknown.orderSubmittedAt || undefined, reason: this.unknown.reason.trim() || undefined }; this.unknown.saving = true; try { await this.runAction(() => resolveUnknownPurchaseTask(this.detail.task.id, payload), '未知结果已处理'); this.unknown.open = false } finally { this.unknown.saving = false } },
+    orderInformationComplete(t) { return Boolean(t?.pddOrderNo?.trim() && t.orderSubmittedAt && Number.isFinite(Date.parse(t.orderSubmittedAt)) && t.pddOrderAmountCent != null && t.pddOrderAmountCent >= 0) },
+    orderAmountCent(value) { if (!/^\d+(\.\d{1,2})?$/.test(value)) return null; const [whole, fraction = ''] = value.split('.'); const cents = Number(whole) * 100 + Number(fraction.padEnd(2, '0')); return Number.isSafeInteger(cents) ? cents : null },
+    openUnknownDialog() { const t = this.detail.task; this.unknown = { open: true, saving: false, status: 'order_created', pddOrderNo: t.pddOrderNo || '', orderSubmittedAt: t.orderSubmittedAt || '', amountYuan: t.pddOrderAmountCent == null ? '' : (t.pddOrderAmountCent / 100).toFixed(2), reason: '', error: '', requestId: this.requestId(), fingerprint: '' } },
+    async submitUnknown() {
+      if (!this.canSubmitUnknown || this.unknown.saving) return
+      const values = this.unknown.status === 'order_created' ? { status: 'order_created', pddOrderNo: this.unknown.pddOrderNo.trim(), orderSubmittedAt: this.unknown.orderSubmittedAt, pddOrderAmountCent: this.orderAmountCent(this.unknown.amountYuan) } : { status: 'cancelled', reason: this.unknown.reason.trim() }
+      const fingerprint = JSON.stringify(values)
+      if (this.unknown.fingerprint && this.unknown.fingerprint !== fingerprint) this.unknown.requestId = this.requestId()
+      this.unknown.fingerprint = fingerprint
+      this.unknown.saving = true; this.unknown.error = ''
+      try { await this.runAction(() => resolveUnknownPurchaseTask(this.detail.task.id, { requestId: this.unknown.requestId, ...values }), '订单信息已保存'); this.unknown.open = false }
+      catch (error) { this.unknown.error = '保存未确认，输入已保留。请核对订单号及现有信息；网络异常时刷新确认后重试。' }
+      finally { this.unknown.saving = false }
+    },
     openShopeeMapping() { const route = this.$router.resolve({ path: '/shopee-products/index', query: { productId: this.detail.task.shopeeProductId }}); window.open(route.href, '_blank', 'noopener') }
   }
 }

web/tests/e2e/purchase-order-writeback.spec.ts

@@ -1,11 +1,11 @@
 import { expect, test } from '@playwright/test'
 
-async function setup(page: any, state = 'not_started') {
+async function setup(page: any, state = 'not_started', failManualOnce = false) {
   await page.setViewportSize({ width: 1920, height: 1080 })
   await page.context().addCookies([{ name: 'Admin-Token', value: 'test-only', domain: 'localhost', path: '/' }])
   const requests: { path: string, body: any }[] = []
   const items = [
-    { id: 11, taskType: 'syb_order', executionMode: 'live', status: 'order_created', pddOrderNo: 'EXAMPLE-11', paymentReviewStatus: 'unpaid', orderWriteback: { status: state, canSubmit: ['not_started', 'failed', 'unknown'].includes(state), reason: state === 'conflict' ? 'SYB 已有不同单号，未覆盖' : '' } },
+    { id: 11, taskType: 'syb_order', executionMode: 'live', status: 'order_created', pddOrderNo: 'EXAMPLE-11', orderSubmittedAt: '2026-09-19T12:00:00Z', pddOrderAmountCent: null as number | null, paymentReviewStatus: 'unpaid', orderWriteback: { status: state, canSubmit: ['not_started', 'failed', 'unknown'].includes(state), reason: state === 'conflict' ? 'SYB 已有不同单号，未覆盖' : '' } },
     { id: 12, taskType: 'syb_order', executionMode: 'live', status: 'failed', retryable: true, orderWriteback: { status: 'not_applicable', canSubmit: false, reason: '' } },
     { id: 13, taskType: 'stock', executionMode: 'live', status: 'order_created', orderWriteback: { status: 'not_applicable', canSubmit: false, reason: '' } }
   ]
@@ -16,6 +16,11 @@ async function setup(page: any, state = 'not_started') {
     if (route.request().method() === 'POST') {
       const body = route.request().postDataJSON()
       requests.push({ path, body })
+      if (path.endsWith('/resolve-unknown')) {
+        if (failManualOnce) { failManualOnce = false; return route.fulfill({ status: 500, json: { code: 500, message: 'synthetic failure' } }) }
+        items[0].pddOrderAmountCent = body.pddOrderAmountCent
+        return route.fulfill({ json: { code: 200, data: items[0] } })
+      }
       if (path.endsWith('/syb-order-writeback')) {
         items[0].orderWriteback = { status: 'pending', canSubmit: false, reason: '' }
         return route.fulfill({ json: { code: 200, data: { items: body.purchaseTaskIds.map((taskId: number) => ({ taskId, result: 'pending', reason: '已受理' })) } } })
@@ -76,3 +81,65 @@ test('冲突显示原因且没有覆盖按钮', async ({ page }) => {
   await expect(drawer.getByText('SYB 已有不同单号，未覆盖', { exact: true })).toBeVisible()
   await expect(drawer.getByRole('button', { name: /回填 SYB 单号/ })).toHaveCount(0)
 })
+
+test('状态下拉框筛选已回填SYB，清空后恢复普通列表', async ({ page }) => {
+  const requests = await setup(page, 'succeeded')
+  const statuses: string[] = []
+  await page.route('**/api/admin/v1/purchase-tasks?**', async route => {
+    const query = new URL(route.request().url()).searchParams
+    statuses.push(query.get('status') || '')
+    expect(query.get('page')).toBe('1')
+    return route.fulfill({ json: { code: 200, data: { items: [{ id: 11, taskType: 'syb_order', executionMode: 'live', status: 'order_created', orderWriteback: { status: 'succeeded', canSubmit: false } }], total: 1 } } })
+  })
+  const field = page.locator('.search-form .el-form-item').filter({ has: page.locator('label').filter({ hasText: /^状态$/ }) })
+  await field.locator('.el-select').click()
+  await page.getByRole('option', { name: '已回填 SYB', exact: true }).click()
+  await page.getByRole('button', { name: '查询', exact: true }).click()
+  await expect.poll(() => statuses.at(-1)).toBe('syb_writeback_succeeded')
+  await expect(page.getByText('订单已创建', { exact: true }).first()).toBeVisible()
+  await field.locator('.el-select').hover()
+  await field.locator('.el-select__clear').click()
+  await page.getByRole('button', { name: '查询', exact: true }).click()
+  await expect.poll(() => statuses.at(-1)).toBe('')
+  expect(requests).toHaveLength(0)
+})
+
+for (const amount of ['0', '13.01']) {
+  test(`已创建订单补金额 ${amount}，不重新采购或修改支付状态`, async ({ page }) => {
+    const requests = await setup(page)
+    await page.getByRole('button', { name: '详情', exact: true }).first().click()
+    const drawer = page.getByRole('dialog', { name: '采购任务详情' })
+    await drawer.getByRole('button', { name: '补全订单信息', exact: true }).click()
+    const dialog = page.getByRole('dialog', { name: '补全订单信息', exact: true })
+    await expect(dialog.getByRole('button', { name: '保存', exact: true })).toBeDisabled()
+    await expect(dialog.getByRole('textbox').first()).toHaveAttribute('readonly', '')
+    await dialog.getByPlaceholder('例如 13.00').fill('-1')
+    await expect(dialog.getByText('请输入不小于0、最多两位小数的金额')).toBeVisible()
+    await expect(dialog.getByRole('button', { name: '保存', exact: true })).toBeDisabled()
+    await dialog.getByPlaceholder('例如 13.00').fill(amount)
+    await dialog.getByRole('button', { name: '保存', exact: true }).click()
+    await expect(dialog).toBeHidden()
+    expect(requests).toHaveLength(1)
+    expect(requests[0].body.pddOrderAmountCent).toBe(Math.round(Number(amount) * 100))
+    expect(requests[0].body.pddOrderNo).toBe('EXAMPLE-11')
+    expect(requests[0].body.orderSubmittedAt).toBe('2026-09-19T12:00:00Z')
+    expect(requests[0].path).toContain('/resolve-unknown')
+    await expect(drawer.getByText('信息完整', { exact: true })).toBeVisible()
+    await expect(drawer.getByRole('button', { name: '补全订单信息', exact: true })).toHaveCount(0)
+  })
+}
+
+test('补录失败保留输入，原样重试复用requestId', async ({ page }) => {
+  const requests = await setup(page, 'not_started', true)
+  await page.getByRole('button', { name: '详情', exact: true }).first().click()
+  await page.getByRole('button', { name: '补全订单信息', exact: true }).click()
+  const dialog = page.getByRole('dialog', { name: '补全订单信息', exact: true })
+  await dialog.getByPlaceholder('例如 13.00').fill('15.50')
+  await dialog.getByRole('button', { name: '保存', exact: true }).click()
+  await expect(dialog.getByText(/保存未确认/)).toBeVisible()
+  await expect(dialog.getByPlaceholder('例如 13.00')).toHaveValue('15.50')
+  await dialog.getByRole('button', { name: '保存', exact: true }).click()
+  await expect(dialog).toBeHidden()
+  expect(requests).toHaveLength(2)
+  expect(requests[1].body).toEqual(requests[0].body)
+})