@seasonkoh/webaz 0.1.29 → 0.1.31

package/dist/pwa/routes/direct-pay-timeouts.js

@@ -1,6 +1,20 @@
 import { transition } from '../../layer0-foundation/L0-2-state-machine/engine.js';
 import { releaseFeeStake } from '../../direct-pay-ledger.js';
+import { restorePreShipDirectPayStock } from '../../direct-pay-stock.js'; // D3 库存回补唯一入口(pre-ship 放行;已出库拒绝)
+import { notifyTransition, createNotification } from '../../layer2-business/L2-6-notifications/notification-engine.js';
+import { expireDeferrals, listExpiringDeferrals, markDeferralReminded, suspendPrivilegeOnDeferralExpiry } from '../../direct-receive-deferral.js'; // B4:缓交到期提醒/收口
 const SYS = 'sys_protocol';
+/** 货款协商买家申诉窗(天),governance 可调,默认 7d。与 request_cancel 同源 param,保证手动/自动一致。 */
+function recourseDays(db) {
+    try {
+        const row = db.prepare("SELECT value FROM protocol_params WHERE key = 'direct_pay.payment_query_recourse_days'").get();
+        const n = Number(row?.value ?? 7);
+        return Number.isFinite(n) && n > 0 ? Math.max(1, n) : 7;
+    }
+    catch {
+        return 7;
+    }
+}
 /** 宽限期(小时),governance 可调,默认 48h(2d)。不硬编码。 */
 function graceHours(db) {
     try {
@@ -17,16 +31,92 @@ export function runDirectPayTimeoutSweep(deps) {
     const gh = graceHours(db);
     const windowExpired = [];
     const graceCancelled = [];
+    const pqRecourseOpened = [];
+    const pqCancelled = [];
+    const acceptExpired = [];
+    const deferralReminded = [];
+    const deferralExpired = [];
+    // F. 缓交收口(B4):① 到期前提醒(param direct_pay.deferral_reminder_days,默认 3d;reminder_sent_at 去重)
+    //    ② 过 grace 到期 → expired + 无生产 bond 则停权(有 bond=已缴清兜底不停)+ 通知。均 fail-soft 不断 cron。
+    try {
+        const remindDays = (() => { try {
+            const r = db.prepare("SELECT value FROM protocol_params WHERE key = 'direct_pay.deferral_reminder_days'").get();
+            const n = Number(r?.value ?? 3);
+            return Number.isFinite(n) && n > 0 ? n : 3;
+        }
+        catch {
+            return 3;
+        } })();
+        for (const d of listExpiringDeferrals(db, new Date().toISOString(), remindDays)) {
+            markDeferralReminded(db, d.id);
+            deferralReminded.push(d.id);
+            try {
+                createNotification(db, d.user_id, null, 'deferral_expiring_soon', '⏰ 保证金缓交即将到期', `你的缓交资格将于 ${d.expires_at} 到期。请在到期前缴纳履约保证金转正式(设置页-直付履约保证金),否则宽限期后直付资格将关闭。`, { templateKey: 'deferral_expiring_soon', params: { expires: d.expires_at } });
+            }
+            catch (e) {
+                console.warn('[direct-pay-timeouts] notify deferral-remind:', e.message);
+            }
+        }
+        for (const uid of expireDeferrals(db, new Date().toISOString()).expired) {
+            const suspended = suspendPrivilegeOnDeferralExpiry(db, uid);
+            deferralExpired.push(uid);
+            try {
+                createNotification(db, uid, null, 'deferral_expired', '🚫 保证金缓交已到期', suspended ? '缓交资格已到期且未缴纳保证金,直付资格已关闭。缴纳履约保证金并经运营确认后可重新开通;在途订单不受影响,请正常履约完成。' : '缓交资格已到期;你已缴纳保证金,直付资格不受影响。', { templateKey: 'deferral_expired', params: { closed: suspended ? 1 : 0 } });
+            }
+            catch (e) {
+                console.warn('[direct-pay-timeouts] notify deferral-expired:', e.message);
+            }
+        }
+    }
+    catch (e) {
+        console.error('[direct-pay-timeouts] deferral closure sweep:', e);
+    }
+    // E. 手动接单窗超时(v16):pending_accept 过 pending_accept_deadline → 无责取消 + 回补库存。
+    //    零资金(此阶段没人付过钱 —— 时序门);双方通知。WHERE 硬门:仅 now > deadline 命中。
+    const acceptRows = db.prepare(`
+    SELECT id, product_id, quantity, buyer_id, seller_id FROM orders
+    WHERE status = 'pending_accept'
+      AND payment_rail = 'direct_p2p'
+      AND pending_accept_deadline IS NOT NULL
+      AND datetime(pending_accept_deadline) < datetime('now')
+    LIMIT 1000
+  `).all();
+    for (const { id, product_id, quantity, buyer_id, seller_id } of acceptRows) {
+        let done = false;
+        db.transaction(() => {
+            const r = transition(db, id, 'cancelled', SYS, [], '手动接单:卖家超时未确认接单,系统无责取消(付款前,零资金)');
+            if (!r.success)
+                return;
+            restorePreShipDirectPayStock(db, { fromStatus: 'pending_accept', productId: product_id, quantity });
+            acceptExpired.push(id);
+            done = true;
+        })();
+        if (done) {
+            try {
+                createNotification(db, buyer_id, id, 'direct_pay_accept_expired', '⏰ 卖家超时未接单,订单已取消', '卖家未在接单窗口内确认,订单已自动取消 —— 你尚未付款,无需任何操作。可换商品或联系卖家后重新下单。', { templateKey: 'dp_pending_accept_expired_buyer', params: {} });
+            }
+            catch (e) {
+                console.warn('[direct-pay-timeouts] notify accept-expired buyer:', e.message);
+            }
+            try {
+                createNotification(db, seller_id, id, 'direct_pay_accept_expired', '⏰ 订单因超时未接单已取消', '你未在接单窗口内确认接单,订单已自动取消,库存已恢复。频繁超时会影响买家体验,可考虑改用自动接单或缩短响应时间。', { templateKey: 'dp_pending_accept_expired_seller', params: {} });
+            }
+            catch (e) {
+                console.warn('[direct-pay-timeouts] notify accept-expired seller:', e.message);
+            }
+        }
+    }
     // A. 付款窗口超时 → 可争议态(非静默关单)+ 退费用质押 + 设宽限期
     const windowRows = db.prepare(`
-    SELECT id FROM orders
+    SELECT id, buyer_id FROM orders
     WHERE status = 'direct_pay_window'
       AND payment_rail = 'direct_p2p'
       AND direct_pay_window_deadline IS NOT NULL
       AND datetime(direct_pay_window_deadline) < datetime('now')
     LIMIT 1000
   `).all();
-    for (const { id } of windowRows) {
+    for (const { id, buyer_id } of windowRows) {
+        let done = false;
         db.transaction(() => {
             const r = transition(db, id, 'direct_expired_unconfirmed', SYS, [], 'Rail1 直付:付款窗口超时未标记');
             if (!r.success)
@@ -34,33 +124,120 @@ export function runDirectPayTimeoutSweep(deps) {
             releaseFeeStake(db, { orderId: id }); // 费用质押退卖家(无完成,不收费)
             db.prepare(`UPDATE orders SET direct_grace_deadline = datetime('now', ?) WHERE id = ?`).run(`+${gh} hours`, id);
             windowExpired.push(id);
+            done = true;
         })();
+        // 审计项 B(N2):此前窗口静默过期,卡点付款的买家毫不知情直到 48h 后自动取消。tx 外 fail-soft。
+        if (done) {
+            try {
+                createNotification(db, buyer_id, id, 'direct_pay_window_expired', '⏰ 直付付款窗口已过期', `若你已付款:请在 ${gh} 小时宽限期内到订单页提交付款凭证发起争议;未付款可直接关闭订单,否则宽限期满将自动取消。`, { templateKey: 'dp_window_expired', params: { graceHours: gh } });
+            }
+            catch (e) {
+                console.warn('[direct-pay-timeouts] notify window-expired:', e.message);
+            }
+        }
     }
     // B. 宽限期满 → 系统关单(★ WHERE 保证仅 now>grace 命中;宽限期内绝不关,买家 →disputed 全程可用)
     const graceRows = db.prepare(`
-    SELECT id FROM orders
+    SELECT id, product_id, quantity, buyer_id, seller_id FROM orders
     WHERE status = 'direct_expired_unconfirmed'
       AND payment_rail = 'direct_p2p'
       AND direct_grace_deadline IS NOT NULL
       AND datetime(direct_grace_deadline) < datetime('now')
     LIMIT 1000
   `).all();
-    for (const { id } of graceRows) {
+    for (const { id, product_id, quantity, buyer_id, seller_id } of graceRows) {
+        let done = false;
         db.transaction(() => {
             const r = transition(db, id, 'cancelled', SYS, [], 'Rail1 直付:宽限期满,买家未付款/未升级争议,系统关单');
-            if (r.success)
-                graceCancelled.push(id);
+            if (!r.success)
+                return;
+            restorePreShipDirectPayStock(db, { fromStatus: 'direct_expired_unconfirmed', productId: product_id, quantity }); // D3 回补(pre-ship 唯一入口)
+            graceCancelled.push(id);
+            done = true;
+        })();
+        // 审计项 B(N2):自动关单也要告知双方(此前静默,买家不知单没了、卖家不知库存已回)。tx 外 fail-soft。
+        if (done) {
+            try {
+                createNotification(db, buyer_id, id, 'direct_pay_grace_cancelled', '🚫 直付订单已自动取消', '付款窗口与宽限期均已过且未收到你的付款标记/凭证,订单已关闭。若你确已付款,请通过订单页联系卖家协商。', { templateKey: 'dp_grace_cancelled_buyer', params: {} });
+            }
+            catch (e) {
+                console.warn('[direct-pay-timeouts] notify grace-cancel buyer:', e.message);
+            }
+            try {
+                createNotification(db, seller_id, id, 'direct_pay_grace_cancelled', '🚫 直付订单已自动取消(买家未付款)', '买家未在付款窗口+宽限期内付款,订单已自动关闭,库存已恢复。', { templateKey: 'dp_grace_cancelled_seller', params: {} });
+            }
+            catch (e) {
+                console.warn('[direct-pay-timeouts] notify grace-cancel seller:', e.message);
+            }
+        }
+    }
+    // D. 货款协商买家静默:payment_query 已过买家响应宽限(payment_query_deadline)且卖家未手动请求取消
+    //    (payment_query_cancel_deadline 仍空)→ 系统【代卖家自动启动取消申请】(等价 request_cancel):
+    //    设 payment_query_cancel_deadline = now + recourse_days + 通知买家最后申诉窗已开。★ 不关单、不动状态、不涉资金;
+    //    买家窗内仍可 pq_escalate 主张已付,订单离开 payment_query 后本 sweep 与 Sweep C 均不再命中。之后由 Sweep C 窗满关单。
+    //    幂等:WHERE payment_query_cancel_deadline IS NULL —— 卖家已手动 request_cancel 的单不被重置,重复 cron 也不刷新窗口。
+    const rd = recourseDays(db);
+    const pqSilentRows = db.prepare(`
+    SELECT id, buyer_id FROM orders
+    WHERE status = 'payment_query'
+      AND payment_rail = 'direct_p2p'
+      AND payment_query_deadline IS NOT NULL
+      AND datetime(payment_query_deadline) < datetime('now')
+      AND payment_query_cancel_deadline IS NULL
+    LIMIT 1000
+  `).all();
+    for (const { id, buyer_id } of pqSilentRows) {
+        const res = db.prepare(`UPDATE orders SET payment_query_cancel_deadline = datetime('now', ?) WHERE id = ? AND payment_query_cancel_deadline IS NULL`).run(`+${rd} days`, id);
+        if (res.changes === 0)
+            continue; // 竞态:同 tick 已被设(卖家 request_cancel)——不重复处理
+        pqRecourseOpened.push(id);
+        try {
+            const dl = db.prepare("SELECT payment_query_cancel_deadline d FROM orders WHERE id = ?").get(id).d;
+            createNotification(db, buyer_id, id, 'payment_query_cancel_requested', '⏳ 卖家申请取消订单', `卖家称未收到货款且你未在响应期内回应,系统已代卖家发起取消。你约有 ${rd} 天:若确已付款请提供付款参考或发起举证(pq_escalate),否则订单将于 ${dl} 自动取消。直付非托管,无平台退款。`);
+        }
+        catch (e) {
+            console.warn('[direct-pay-timeouts] notify pq-recourse:', e.message);
+        }
+    }
+    // C. 货款协商:卖家已请求取消(payment_query_cancel_deadline 已设)+ 买家申诉窗满 → 系统关单 + 退费用质押。
+    //    ★ 窗内(now < deadline)绝不关:买家全程可主张已付/升级举证(pq_escalate 回 disputed)。
+    const pqCancelRows = db.prepare(`
+    SELECT id, product_id, quantity FROM orders
+    WHERE status = 'payment_query'
+      AND payment_rail = 'direct_p2p'
+      AND payment_query_cancel_deadline IS NOT NULL
+      AND datetime(payment_query_cancel_deadline) < datetime('now')
+    LIMIT 1000
+  `).all();
+    for (const { id, product_id, quantity } of pqCancelRows) {
+        let done = false;
+        db.transaction(() => {
+            const r = transition(db, id, 'cancelled', SYS, [], 'Rail1 直付:货款协商申诉窗满,买家未回应/未升级,系统关单');
+            if (!r.success)
+                return;
+            releaseFeeStake(db, { orderId: id }); // 无完成不收费:退卖家费用质押
+            restorePreShipDirectPayStock(db, { fromStatus: 'payment_query', productId: product_id, quantity }); // D3 回补(pre-ship 唯一入口)
+            done = true;
         })();
+        if (done) {
+            pqCancelled.push(id);
+            try {
+                notifyTransition(db, id, 'payment_query', 'cancelled');
+            }
+            catch (e) {
+                console.warn('[direct-pay-timeouts] notify pq-cancel:', e.message);
+            }
+        } // 通知买卖双方(cron 系统关单也要发,route 之外)
     }
-    return { windowExpired, graceCancelled };
+    return { windowExpired, graceCancelled, pqRecourseOpened, pqCancelled, acceptExpired, deferralReminded, deferralExpired };
 }
 export function startDirectPayTimeoutCron(deps) {
     const ms = 10 * 60 * 1000; // 10min — 付款窗口最短 30min,10min 粒度足够
     setInterval(() => {
         try {
             const r = runDirectPayTimeoutSweep(deps);
-            if (r.windowExpired.length || r.graceCancelled.length) {
-                console.log(`[direct-pay-timeouts] window→expired ${r.windowExpired.length}, grace→cancelled ${r.graceCancelled.length}`);
+            if (r.windowExpired.length || r.graceCancelled.length || r.pqRecourseOpened.length || r.pqCancelled.length || r.acceptExpired.length || r.deferralReminded.length || r.deferralExpired.length) {
+                console.log(`[direct-pay-timeouts] window→expired ${r.windowExpired.length}, grace→cancelled ${r.graceCancelled.length}, pq→recourse ${r.pqRecourseOpened.length}, pq→cancelled ${r.pqCancelled.length}, accept→expired ${r.acceptExpired.length}, deferral remind/expired ${r.deferralReminded.length}/${r.deferralExpired.length}`);
             }
         }
         catch (e) {

package/dist/pwa/routes/disputes-read.js

@@ -1,6 +1,6 @@
 import { dbOne, dbAll } from '../../layer0-foundation/L0-1-database/db.js'; // RFC-016 异步 DB seam
 export function registerDisputesReadRoutes(app, deps) {
-    const { db, auth, errorRes, getOpenDisputes, getDisputeDetails, getEvidenceRequests, listEvidenceFiles, isEligibleArbitrator } = deps;
+    const { db, auth, errorRes, getOpenDisputes, getDisputeDetails, getEvidenceRequests, listEvidenceFiles, isEligibleArbitrator, isArbitrationAdmin } = deps;
     // 仲裁员：查看所有开放争议
     app.get('/api/disputes', async (req, res) => {
         const user = auth(req, res);
@@ -19,8 +19,8 @@ export function registerDisputesReadRoutes(app, deps) {
         const dispute = await dbOne('SELECT id, order_id, reason, initiator_id, defendant_id FROM disputes WHERE id = ?', [req.params.id]);
         if (!dispute)
             return void res.status(404).json({ error: '争议不存在' });
-        const role = user.role;
-        if (dispute.initiator_id !== user.id && dispute.defendant_id !== user.id && role !== 'arbitrator') {
+        // PR-E fix:同详情/parties —— party 或 active whitelist 仲裁员;不再用 role === 'arbitrator'。
+        if (dispute.initiator_id !== user.id && dispute.defendant_id !== user.id && !isEligibleArbitrator(user.id).ok) {
             return void res.status(403).json({ error: '无权查看' });
         }
         const order = await dbOne('SELECT product_id FROM orders WHERE id = ?', [dispute.order_id]);
@@ -90,12 +90,16 @@ export function registerDisputesReadRoutes(app, deps) {
         const dispute = await getDisputeDetails(db, req.params.id);
         if (!dispute)
             return void res.status(404).json({ error: '争议不存在' });
-        const role = user.role;
-        // 允许：发起方、被告方、物流方、仲裁员
+        // PR-E:允许 发起方 / 被告方 / 物流方 / active whitelist 仲裁员。不再用 role === 'arbitrator'(旧旁路 →
+        //   suspended/revoked/role-only 可越权读、whitelist-only 买家被错误挡)。授权源统一为 isEligibleArbitrator。
         const orderForAuth = await dbOne('SELECT logistics_id FROM orders WHERE id = ?', [dispute.order_id]);
         const isLogisticsParty = orderForAuth?.logistics_id === user.id;
+        // 当事方 / active 白名单仲裁员 / arbitration-admin(争议查看 —— 只读监督)。admin 门用 isArbitrationAdmin(user)
+        //   而非 user.role==='admin':与后台列表 /admin/disputes(requireArbitrationAdmin)【同一】授权模型,否则会错放
+        //   (role='admin' 但无 arbitration 权限的 admin 绕过列表边界直读详情)/ 错挡(roles=["buyer","admin"] 的 admin 进不去)。
+        //   裁定/驳回等【动作】仍在 disputes-write 由 isEligibleArbitrator + 指派 + COI 门守,admin 只看不能裁。
         if (dispute.initiator_id !== user.id && dispute.defendant_id !== user.id
-            && !isLogisticsParty && role !== 'arbitrator') {
+            && !isLogisticsParty && !isEligibleArbitrator(user.id).ok && !isArbitrationAdmin(user)) {
             return void res.status(403).json({ error: '无权查看此争议' });
         }
         // 原告证据 — 从状态机历史中取 disputed 转移时附带的
@@ -308,8 +312,13 @@ export function registerDisputesReadRoutes(app, deps) {
             });
         }
         events.sort((a, b) => String(a.ts).localeCompare(String(b.ts)));
+        // 仲裁员【驳回仲裁,退回协商】可达性(与 dismissDisputeToNegotiation / pq_withdraw 同谓词):direct_p2p + 最近一次进入
+        //   disputed 是 from payment_query + 未裁定。前端据此才在裁定面板显示"驳回仲裁"选项;真正拦截仍在路由/域函数。
+        const lastDispFrom = await dbOne("SELECT from_status FROM order_state_history WHERE order_id = ? AND to_status = 'disputed' ORDER BY created_at DESC, rowid DESC LIMIT 1", [dispute.order_id]);
+        const canDismissToNegotiation = dispute.payment_rail === 'direct_p2p' && lastDispFrom?.from_status === 'payment_query' && (dispute.status === 'open' || dispute.status === 'in_review');
         res.json({
             ...dispute,
+            can_dismiss_to_negotiation: canDismissToNegotiation,
             plaintiff_evidence: plaintiffEvidence,
             defendant_evidence: defendantEvidence,
             party_evidence: partyEvidence,
@@ -344,6 +353,11 @@ export function registerDisputesReadRoutes(app, deps) {
         if (!dispute)
             return void res.status(404).json({ error: '争议不存在' });
         const order = await dbOne('SELECT buyer_id, seller_id, logistics_id FROM orders WHERE id = ?', [dispute.order_id]);
+        // PR-E:同详情权限门 —— 仅 涉案方 或 active whitelist 仲裁员可读涉案方名单(此前任意登录用户可读=泄露)。
+        const isParty = [order?.buyer_id, order?.seller_id, order?.logistics_id, dispute.initiator_id, dispute.defendant_id].filter(Boolean).includes(user.id);
+        if (!isParty && !isEligibleArbitrator(user.id).ok) {
+            return void res.status(403).json({ error: '无权查看涉案方' });
+        }
         const partyIds = [dispute.initiator_id, dispute.defendant_id, order?.logistics_id].filter(Boolean);
         const uniqueIds = [...new Set(partyIds)];
         const parties = (await Promise.all(uniqueIds.map(id => dbOne('SELECT id, name, role FROM users WHERE id = ?', [id])))).filter(Boolean);

package/dist/pwa/routes/disputes-write.js

@@ -7,8 +7,33 @@ import { applyWalletDelta } from '../../ledger.js';
 // RFC-016 Phase 1 — 纯只读端点/校验读/SNF 分发读/标记写 → async seam;arbitrate 仲裁核心(原子领取 +
 //   2 settlement db.transaction + reputation/strike/publish)与 tx 内 appendAuditLog 保持同步(Phase 3 迁 pg)。
 import { dbOne, dbAll, dbRun } from '../../layer0-foundation/L0-1-database/db.js';
+import { arbitratorHasConflict } from '../arbitrator-lifecycle.js'; // PR-B COI 硬门
+import { dismissDisputeToNegotiation } from '../../layer3-trust/L3-1-dispute-engine/dispute-engine.js'; // 仲裁员驳回仲裁,退回协商(非胜负裁决)
 export function registerDisputesWriteRoutes(app, deps) {
-    const { db, auth, generateId, detectFraud, errorRes, isEligibleArbitrator, requireHumanPresence, getDisputeDetails, respondToDispute, arbitrateDispute, addPartyEvidence, requestEvidence, markEvidenceExpiry, uploadEvidence, EVIDENCE_MAX_BYTES, EVIDENCE_ALLOWED_MIME, appendOrderEvent, FUND_BASE_RATE, settleCommission, depositToFund, calculatePv, recordDisputeReputation, issueAgentStrike, publishDisputeCase, logAdminAction, snfSend, getProtocolParam } = deps;
+    const { db, auth, generateId, detectFraud, errorRes, isEligibleArbitrator, requireHumanPresence, getDisputeDetails, respondToDispute, arbitrateDispute, addPartyEvidence, requestEvidence, markEvidenceExpiry, uploadEvidence, EVIDENCE_MAX_BYTES, EVIDENCE_ALLOWED_MIME, appendOrderEvent, FUND_BASE_RATE, settleCommission, depositToFund, calculatePv, recordDisputeReputation, issueAgentStrike, publishDisputeCase, logAdminAction, snfSend, getProtocolParam, notifyTransition } = deps;
+    // PR-E:案件级仲裁操作(裁定 / 补证)统一的【原子领取或校验指派】。assigned 为空 → CAS 首位领取;
+    //   非空且不含 caller → NOT_ASSIGNED_ARBITRATOR。arbitrate 与 request-evidence 共用,防"任意 active 仲裁员操作任意案"。
+    const claimOrCheckAssignment = (disputeId, userId) => {
+        const row = db.prepare('SELECT assigned_arbitrators FROM disputes WHERE id = ?').get(disputeId);
+        let assigned = [];
+        try {
+            assigned = JSON.parse(row?.assigned_arbitrators || '[]');
+        }
+        catch { }
+        if (assigned.length === 0) {
+            const claim = db.prepare(`UPDATE disputes SET assigned_arbitrators = ? WHERE id = ? AND (assigned_arbitrators IS NULL OR assigned_arbitrators = '[]')`).run(JSON.stringify([userId]), disputeId);
+            if (claim.changes === 0) {
+                const fresh = db.prepare('SELECT assigned_arbitrators FROM disputes WHERE id = ?').get(disputeId);
+                try {
+                    assigned = JSON.parse(fresh?.assigned_arbitrators || '[]');
+                }
+                catch { }
+            }
+            else
+                assigned = [userId];
+        }
+        return assigned.includes(userId) ? { ok: true } : { ok: false, error_code: 'NOT_ASSIGNED_ARBITRATOR' };
+    };
     // ── RFC-007 stage 5：客观拒单【临时判责】的仲裁翻案 ─────────────────────────────
     //   卖家 contest_decline 后,订单 = fault_seller + decline_objective_pending=1 + decline_contested=1(未结算)。
     //   仲裁员(真实人工 + WebAuthn)裁决:uphold → declined_nofault(免责全退+退质押);reject → 违约结算。
@@ -117,7 +142,7 @@ export function registerDisputesWriteRoutes(app, deps) {
         const { ruling, reason, refund_amount, liable_party_id, liability_parties } = req.body;
         if (!ruling || !reason)
             return void res.json({ error: '请提供裁定结果（ruling）和理由（reason）' });
-        const validRulings = ['refund_buyer', 'release_seller', 'partial_refund', 'liability_split'];
+        const validRulings = ['refund_buyer', 'release_seller', 'partial_refund', 'liability_split', 'dismiss_to_negotiation'];
         if (!validRulings.includes(ruling)) {
             return void res.json({ error: `ruling 必须是 ${validRulings.join(' / ')} 之一` });
         }
@@ -134,32 +159,52 @@ export function registerDisputesWriteRoutes(app, deps) {
         const dispute = await getDisputeDetails(db, req.params.id);
         if (!dispute)
             return void res.status(404).json({ error: '争议不存在' });
-        // P0: 防"任意仲裁员裁决任意争议"
-        // 若 assigned_arbitrators 为空 → 首位调用者原子领取
-        const arbRow = db.prepare(`SELECT assigned_arbitrators FROM disputes WHERE id = ?`).get(req.params.id);
-        let assignedArbitrators = [];
-        try {
-            assignedArbitrators = JSON.parse(arbRow?.assigned_arbitrators || '[]');
-        }
-        catch { }
-        if (assignedArbitrators.length === 0) {
-            const claimRes = db.prepare(`UPDATE disputes SET assigned_arbitrators = ? WHERE id = ? AND (assigned_arbitrators IS NULL OR assigned_arbitrators = '[]')`)
-                .run(JSON.stringify([user.id]), req.params.id);
-            if (claimRes.changes === 0) {
-                const fresh = db.prepare(`SELECT assigned_arbitrators FROM disputes WHERE id = ?`).get(req.params.id);
-                try {
-                    assignedArbitrators = JSON.parse(fresh?.assigned_arbitrators || '[]');
-                }
-                catch { }
+        // PR-B COI 硬门:当事方(买家/卖家/物流/发起人/被诉人)不得仲裁本案。在领取/裁定前拦截。
+        if (arbitratorHasConflict(db, dispute.order_id, dispute.initiator_id ?? null, dispute.defendant_id ?? null, user.id)) {
+            return void res.status(403).json({ error: '你是本案当事方,不可仲裁(利益冲突)', error_code: 'ARBITRATOR_CONFLICT_OF_INTEREST' });
+        }
+        // P0: 防"任意仲裁员裁决任意争议" —— 原子领取或校验指派(与 request-evidence 共用 helper)。
+        const claim = claimOrCheckAssignment(req.params.id, user.id);
+        if (!claim.ok) {
+            return void res.status(403).json({ error: '此争议未分配给你 — 仅指派的仲裁员可裁定', error_code: claim.error_code || 'NOT_ASSIGNED_ARBITRATOR' });
+        }
+        // 仲裁员【驳回仲裁,退回协商】—— 非胜负裁决:不结算/不退款/不收仲裁费/不扣信誉/不动 escrow。仅 direct_p2p 且由 payment_query 升级来的争议;
+        //   域函数硬校验 rail + payment_query-origin + 未裁定,否则 NOT_PAYMENT_QUERY_DISPUTE / ARBITRATION_DISMISS_NOT_ALLOWED。状态回退 + dispute 关闭同一原子事务。
+        if (ruling === 'dismiss_to_negotiation') {
+            let dm;
+            try {
+                dm = db.transaction(() => dismissDisputeToNegotiation(db, req.params.id, reason))();
+            }
+            catch (e) {
+                return void errorRes(res, 500, 'DISMISS_FAILED', e.message);
             }
-            else {
-                assignedArbitrators = [user.id];
+            if (!dm.success) {
+                const st = dm.error_code === 'DISPUTE_NOT_FOUND' ? 404 : (dm.error_code === 'SYS_MISSING' || dm.error_code === 'TRANSITION_FAILED') ? 500 : 409;
+                return void errorRes(res, st, dm.error_code || 'DISMISS_FAILED', dm.error || '驳回仲裁失败');
             }
+            try {
+                appendOrderEvent(db, { orderId: dm.order_id, eventType: 'transition', fromStatus: 'disputed', toStatus: 'payment_query', actorId: user.id, actorRole: 'arbitrator', extra: { action: 'dismiss_to_negotiation', dispute_id: req.params.id, reason, non_custodial: true } });
+            }
+            catch (e) {
+                console.warn('[order-chain] dismiss event:', e.message);
+            }
+            try {
+                markEvidenceExpiry(db, req.params.id);
+            }
+            catch (e) {
+                console.warn('[evidence] mark expiry:', e.message);
+            }
+            try {
+                notifyTransition(db, dm.order_id, 'disputed', 'payment_query');
+            }
+            catch (e) {
+                console.warn('[notify] dismiss:', e.message);
+            }
+            return void res.json({ success: true, status: 'payment_query', dispute_dismissed: true, returned_to_negotiation: true, message: '已驳回仲裁,退回买卖双方协商' });
         }
-        if (!assignedArbitrators.includes(user.id)) {
-            return void res.status(403).json({ error: '此争议未分配给你 — 仅指派的仲裁员可裁定', error_code: 'NOT_ASSIGNED_ARBITRATOR' });
-        }
-        // 协议层：仲裁员签名的 ruling 入订单链
+        // 协议层：仲裁员签名的 ruling 入订单链。direct_p2p 非托管=仅信誉裁决,绝不把请求里的退款/赔付金额写进【签名链/timeline】
+        //   (即便资金层不动钱,签名链会永久留假语义)→ 强制 non_custodial + 金额/责任方全清。
+        const ncRail = dispute.payment_rail === 'direct_p2p';
         try {
             appendOrderEvent(db, {
                 orderId: dispute.order_id,
@@ -172,9 +217,10 @@ export function registerDisputesWriteRoutes(app, deps) {
                     action: 'arbitration_ruling',
                     dispute_id: req.params.id,
                     ruling, reason,
-                    refund_amount: refund_amount ? Number(refund_amount) : null,
-                    liable_party_id: liable_party_id || null,
-                    liability_parties: liability_parties || null,
+                    non_custodial: ncRail || undefined,
+                    refund_amount: ncRail ? null : (refund_amount ? Number(refund_amount) : null),
+                    liable_party_id: ncRail ? null : (liable_party_id || null),
+                    liability_parties: ncRail ? null : (liability_parties || null),
                 },
             });
         }
@@ -191,8 +237,10 @@ export function registerDisputesWriteRoutes(app, deps) {
         catch (e) {
             console.warn('[evidence] mark expiry:', e.message);
         }
+        // 非托管(直付)争议:协议不持货款、不做托管结算 → 【跳过】所有佣金/PV/基金分润钩子(否则会从卖家余额扣不存在的佣金)。
+        const nonCustodial = !!result.non_custodial;
         // release_seller 等同正常完成 → 触发推土机分润 + 原子能
-        if (ruling === 'release_seller') {
+        if (ruling === 'release_seller' && !nonCustodial) {
             try {
                 db.transaction(() => {
                     const order = db.prepare("SELECT * FROM orders WHERE id = ?").get(dispute.order_id);
@@ -233,8 +281,8 @@ export function registerDisputesWriteRoutes(app, deps) {
                 console.error('[dispute commission/pv hook]', e);
             }
         }
-        // Bug-A fix：partial_refund / liability_split 也按 effectiveBase 发 commission/PV/基金池
-        if (ruling === 'partial_refund' || ruling === 'liability_split') {
+        // Bug-A fix：partial_refund / liability_split 也按 effectiveBase 发 commission/PV/基金池(非托管跳过)
+        if ((ruling === 'partial_refund' || ruling === 'liability_split') && !nonCustodial) {
             try {
                 db.transaction(() => {
                     const order = db.prepare("SELECT * FROM orders WHERE id = ?").get(dispute.order_id);
@@ -519,13 +567,23 @@ export function registerDisputesWriteRoutes(app, deps) {
         }
     });
     // 仲裁员：请求某方补证
-    app.post('/api/disputes/:id/request-evidence', (req, res) => {
+    app.post('/api/disputes/:id/request-evidence', async (req, res) => {
         const user = auth(req, res);
         if (!user)
             return;
+        // PR-E:① active whitelist ② COI(当事方不可补证本案,与 arbitrate 同门) ③ 已分配/领取该案(claim-if-empty)④ 涉案方目标(engine)。
         const elig = isEligibleArbitrator(user.id);
         if (!elig.ok)
             return void errorRes(res, 403, 'NOT_ARBITRATOR', elig.reason || '仅限仲裁员');
+        const disp = await getDisputeDetails(db, req.params.id);
+        if (!disp)
+            return void res.status(404).json({ error: '争议不存在' });
+        if (arbitratorHasConflict(db, disp.order_id, disp.initiator_id ?? null, disp.defendant_id ?? null, user.id)) {
+            return void res.status(403).json({ error: '你是本案当事方,不可补证(利益冲突)', error_code: 'ARBITRATOR_CONFLICT_OF_INTEREST' });
+        }
+        const claim = claimOrCheckAssignment(req.params.id, user.id);
+        if (!claim.ok)
+            return void errorRes(res, 403, claim.error_code || 'NOT_ASSIGNED_ARBITRATOR', '此争议未分配给你 — 仅指派的仲裁员可补证');
         const { requested_from_id, evidence_types, description, deadline_hours = 48 } = req.body;
         if (!requested_from_id || !description)
             return void res.json({ error: '请指定被要求方和证据要求说明' });
@@ -538,7 +596,7 @@ export function registerDisputesWriteRoutes(app, deps) {
         }
         const result = requestEvidence(db, req.params.id, user.id, requested_from_id, evidence_types, description, Number(deadline_hours));
         if (!result.success)
-            return void res.json({ error: result.error });
+            return void res.json({ error: result.error, error_code: result.error_code });
         res.json({ success: true, request_id: result.requestId });
     });
     // ─── task #1093 stage 6: arbitrator_pause / resume auto_judge ─────

package/dist/pwa/routes/external-anchors.js

@@ -1,5 +1,6 @@
 import { dbAll } from '../../layer0-foundation/L0-1-database/db.js'; // RFC-016 异步 DB seam
 import { createAnchor, verifyAnchorSignature, revokeAnchor, issueOwnershipToken, submitVerification, getAnchor, listAnchorsByProduct, listAnchorsBySeller, distributeAnchorRewards, ANCHOR_VERIFICATION_FEE_RECOMMENDED, } from '../../layer1-agent/L1-2-external-anchor/anchor-engine.js';
+import { isEligibleArbitrator } from '../arbitrator-lifecycle.js'; // 仲裁能力唯一源=active 白名单(distribute 是动钱动作,不认 legacy role)
 export function registerExternalAnchorsRoutes(app, deps) {
     const { db, auth } = deps;
     app.post('/api/external-anchors', (req, res) => {
@@ -42,12 +43,13 @@ export function registerExternalAnchorsRoutes(app, deps) {
             total_paid_out: verifications.reduce((s, v) => s + Number(v.reward_amount || 0), 0),
         });
     });
-    // 手动 distribute（admin/arbitrator 补救：anchor 已 community 但 fee_paid_out=0）
+    // 手动 distribute（admin/白名单仲裁员 补救：anchor 已 community 但 fee_paid_out=0）——动钱动作,仲裁员认 active
+    //   白名单(isEligibleArbitrator),不认 legacy user.role(否则已 suspend/revoke 但 role 未同步的账号仍可触发放款)。
     app.post('/api/external-anchors/:id/distribute-rewards', (req, res) => {
         const user = auth(req, res);
         if (!user)
             return;
-        if (user.role !== 'admin' && user.role !== 'arbitrator')
+        if (user.role !== 'admin' && !isEligibleArbitrator(db, user.id).ok)
             return void res.status(403).json({ error: '仅管理员/仲裁员可手动分发' });
         const paid = distributeAnchorRewards(db, req.params.id);
         res.json({ ok: true, paid });

package/dist/pwa/routes/fee-prepay-requests.js

@@ -0,0 +1,66 @@
+import { listActivePlatformAccounts } from '../../platform-receive-accounts.js';
+import { createFeePrepayRequest, listSellerRequests, cancelRequest } from '../../direct-pay-fee-prepay-request.js';
+// N3:申请提交 → 通知有审批权的 admin(approve/reject 是 ROOT 门,只通知 root;regional 收到也办不了)。
+import { createNotification } from '../../layer2-business/L2-6-notifications/notification-engine.js';
+import { dbAll } from '../../layer0-foundation/L0-1-database/db.js';
+export function registerFeePrepayRequestRoutes(app, deps) {
+    const { db, auth, generateId } = deps;
+    /** 登录 + seller 角色。返回 user 或 null(已写响应)。 */
+    function requireSeller(req, res) {
+        const user = auth(req, res);
+        if (!user)
+            return null;
+        if (user.role !== 'seller') {
+            res.status(403).json({ error: '仅卖家可申请平台服务费预充值', error_code: 'SELLER_ONLY' });
+            return null;
+        }
+        return user;
+    }
+    // ── 卖家看平台收款方式(active;含 instruction + qr_data_uri —— 平台公开收款明细,据此付款)──
+    app.get('/api/direct-receive/platform-receive-accounts', (req, res) => {
+        const user = requireSeller(req, res);
+        if (!user)
+            return;
+        res.json({ accounts: listActivePlatformAccounts(db) });
+    });
+    // ── 提交预充值申请(不 Passkey;凭据必填)──
+    app.post('/api/direct-receive/fee-prepay-request', async (req, res) => {
+        const user = requireSeller(req, res);
+        if (!user)
+            return;
+        const b = req.body || {};
+        const r = createFeePrepayRequest(db, user.id, {
+            amountUnits: Number(b.amount_units), currency: b.currency, platformAccountId: b.platform_account_id,
+            evidenceRef: b.evidence_ref, evidenceNote: b.evidence_note,
+        }, generateId);
+        if (!r.ok)
+            return void res.status(400).json({ error: r.reason, error_code: 'FEE_PREPAY_REQUEST_INVALID' });
+        // N3:通知 root admin 有待审申请(此前提交后无人收到任何未读信号,全靠人肉翻队列)。best-effort 不阻断。
+        try {
+            const roots = await dbAll("SELECT id FROM users WHERE role = 'admin' AND (admin_type = 'root' OR admin_type IS NULL)");
+            const amountUsdc = Number(b.amount_units) / 1_000_000;
+            for (const a of roots) {
+                createNotification(db, a.id, null, 'dp_fee_prepay_requested', '💳 新预充值申请待审', `卖家 ${String(user.name ?? user.id)} 申请平台服务费预充值 ${amountUsdc} USDC,请到 admin 后台核对到账后处理。`, { templateKey: 'dp_fee_prepay_requested', params: { seller: String(user.name ?? user.id), amount: amountUsdc } });
+            }
+        }
+        catch (e) {
+            console.warn('[fee-prepay-request notify]', e.message);
+        }
+        res.json({ ok: true, request: r.request });
+    });
+    // ── 卖家看自己的申请(全状态)──
+    app.get('/api/direct-receive/fee-prepay-requests', (req, res) => {
+        const user = requireSeller(req, res);
+        if (!user)
+            return;
+        res.json({ requests: listSellerRequests(db, user.id) });
+    });
+    // ── 卖家撤销自己的 pending 申请 ──
+    app.post('/api/direct-receive/fee-prepay-request/:id/cancel', (req, res) => {
+        const user = requireSeller(req, res);
+        if (!user)
+            return;
+        const changed = cancelRequest(db, String(req.params.id), user.id);
+        res.json({ ok: true, changed });
+    });
+}