@seasonkoh/webaz 0.1.29 → 0.1.30

package/dist/bond-refund-blockers.js

@@ -0,0 +1,50 @@
+import { OPEN_FEE_ACCRUING_STATUSES, readAvailableFeePrepayUnits } from './direct-pay-fee-ar.js';
+import { sellerHasPendingSlash } from './bond-slash.js'; // B3:待复核罚没提案挡退出
+export function enumerateBondRefundBlockers(db, sellerId) {
+    const out = [];
+    // ① 在途直付单(OPEN_FEE_ACCRUING_STATUSES 已含 pending_accept..disputed 全部非终态)
+    try {
+        const ph = OPEN_FEE_ACCRUING_STATUSES.map(() => '?').join(',');
+        const n = db.prepare(`SELECT COUNT(*) n FROM orders WHERE seller_id = ? AND payment_rail = 'direct_p2p' AND status IN (${ph})`)
+            .get(sellerId, ...OPEN_FEE_ACCRUING_STATUSES).n;
+        if (n > 0)
+            out.push({ code: 'OPEN_DIRECT_PAY_ORDERS', count: n });
+    }
+    catch {
+        out.push({ code: 'UNVERIFIABLE_OPEN_ORDERS' });
+    }
+    // ② 取消退款握手进行中(防御性)
+    try {
+        const n = db.prepare(`SELECT COUNT(*) n FROM direct_pay_cancel_requests WHERE seller_id = ? AND status IN ('requested','refund_marked')`)
+            .get(sellerId).n;
+        if (n > 0)
+            out.push({ code: 'OPEN_CANCEL_REFUND_HANDSHAKE', count: n });
+    }
+    catch {
+        out.push({ code: 'UNVERIFIABLE_CANCEL_REFUND' });
+    }
+    // ③ 退货流进行中(completed 直付单的退货/场外退款握手 —— ① 覆盖不到)
+    try {
+        const n = db.prepare(`SELECT COUNT(*) n FROM return_requests r JOIN orders o ON o.id = r.order_id
+      WHERE o.seller_id = ? AND o.payment_rail = 'direct_p2p'
+        AND r.status IN ('pending','accepted_pickup_pending','picked_up','await_refund','refund_marked')`)
+            .get(sellerId).n;
+        if (n > 0)
+            out.push({ code: 'OPEN_RETURN_FLOW', count: n });
+    }
+    catch {
+        out.push({ code: 'UNVERIFIABLE_RETURNS' });
+    }
+    // ⑤ 待复核罚没提案(B3;sellerHasPendingSlash 内部 fail-closed)
+    if (sellerHasPendingSlash(db, sellerId))
+        out.push({ code: 'PENDING_SLASH_REVIEW' });
+    // ④ 平台服务费欠费(available = Σ预充值 + Σ调整 − Σ已计提;负 = 欠)
+    try {
+        if (readAvailableFeePrepayUnits(db, sellerId) < 0)
+            out.push({ code: 'UNPAID_PLATFORM_FEES' });
+    }
+    catch {
+        out.push({ code: 'UNVERIFIABLE_FEES' });
+    }
+    return out;
+}

package/dist/bond-slash.js

@@ -0,0 +1,100 @@
+import { slashBond } from './direct-receive-deposits.js';
+const SELLER_FAULT_RULINGS = ['refund_buyer', 'partial_refund'];
+/** 卖家是否有待复核罚没提案(B2 退出 blockers 用)。 */
+export function sellerHasPendingSlash(db, sellerId) {
+    try {
+        return !!db.prepare("SELECT 1 FROM bond_slash_proposals WHERE seller_id = ? AND status = 'proposed' LIMIT 1").get(sellerId);
+    }
+    catch {
+        return true;
+    } // 表读不了 → fail-closed(视为有,挡退出)
+}
+/** admin 发起罚没提案。校验依据争议 + deposit 状态;冷静期算成绝对截止存库。 */
+export function proposeBondSlash(db, args) {
+    const dep = db.prepare('SELECT id, user_id, status, production_receipt_confirmed_at FROM direct_receive_deposits WHERE id = ?')
+        .get(args.depositId);
+    if (!dep)
+        return { ok: false, reason: 'deposit not found' };
+    if (dep.status !== 'locked' && dep.status !== 'refunding')
+        return { ok: false, reason: `can only propose slash on a locked/refunding bond (got '${dep.status}')` };
+    const dsp = db.prepare(`SELECT d.id, d.status, d.ruling_type, o.payment_rail, o.seller_id
+                          FROM disputes d JOIN orders o ON o.id = d.order_id WHERE d.id = ?`)
+        .get(args.disputeId);
+    if (!dsp)
+        return { ok: false, reason: 'dispute not found' };
+    if (dsp.payment_rail !== 'direct_p2p')
+        return { ok: false, reason: 'dispute is not on a direct_p2p order(罚没口径仅直付争议)' };
+    if (dsp.seller_id !== dep.user_id)
+        return { ok: false, reason: 'dispute seller does not match bond owner' };
+    if (dsp.status !== 'resolved' || !dsp.ruling_type || !SELLER_FAULT_RULINGS.includes(dsp.ruling_type)) {
+        return { ok: false, reason: `dispute must be resolved with a seller-fault ruling (${SELLER_FAULT_RULINGS.join('|')}); got status='${dsp.status}' ruling='${dsp.ruling_type ?? 'none'}'` };
+    }
+    const open = db.prepare("SELECT 1 FROM bond_slash_proposals WHERE deposit_id = ? AND status = 'proposed' LIMIT 1").get(args.depositId);
+    if (open)
+        return { ok: false, reason: 'an open slash proposal already exists for this deposit' };
+    const days = Math.max(0, args.coolingDays);
+    db.prepare(`INSERT INTO bond_slash_proposals (id, deposit_id, seller_id, dispute_id, reason, status, cooling_until, proposed_by)
+              VALUES (?,?,?,?,?, 'proposed', datetime('now', ?), ?)`)
+        .run(args.proposalId, args.depositId, dep.user_id, args.disputeId, args.reason ? String(args.reason).slice(0, 300) : null, `+${days} days`, args.proposedBy);
+    return { ok: true, proposalId: args.proposalId, status: 'proposed' };
+}
+/** admin 撤销提案(执行前任意时刻)。 */
+export function cancelBondSlashProposal(db, args) {
+    const row = db.prepare('SELECT status FROM bond_slash_proposals WHERE id = ?').get(args.proposalId);
+    if (!row)
+        return { ok: false, reason: 'proposal not found' };
+    if (row.status === 'cancelled')
+        return { ok: true, status: 'cancelled', already: true };
+    if (row.status !== 'proposed')
+        return { ok: false, reason: `cannot cancel from status '${row.status}'` };
+    db.prepare("UPDATE bond_slash_proposals SET status = 'cancelled', cancelled_at = datetime('now'), cancel_note = ? WHERE id = ? AND status = 'proposed'")
+        .run(args.note ? String(args.note).slice(0, 300) : null, args.proposalId);
+    return { ok: true, status: 'cancelled' };
+}
+/**
+ * 执行罚没:提案 proposed + 冷静期已过 → 同一事务内 CAS(proposed→executed)+ slashBond(全额 provenance
+ * + status slashed + 资格吊销)。txnId 由调用方生成(审计关联)。
+ */
+export function executeBondSlashProposal(db, args) {
+    const row = db.prepare('SELECT id, deposit_id, seller_id, dispute_id, reason, status, cooling_until FROM bond_slash_proposals WHERE id = ?')
+        .get(args.proposalId);
+    if (!row)
+        return { ok: false, reason: 'proposal not found' };
+    if (row.status === 'executed')
+        return { ok: true, status: 'executed', already: true };
+    if (row.status !== 'proposed')
+        return { ok: false, reason: `cannot execute from status '${row.status}'` };
+    const coolMs = Date.parse(row.cooling_until.includes('T') ? row.cooling_until : row.cooling_until.replace(' ', 'T') + 'Z');
+    const nowMs = Date.parse(args.nowIso);
+    if (!Number.isFinite(coolMs) || !Number.isFinite(nowMs))
+        return { ok: false, reason: 'unparseable cooling timestamps' };
+    if (nowMs < coolMs)
+        return { ok: false, reason: `cooling window not over (until ${row.cooling_until})` };
+    let out = { ok: true, status: 'executed' };
+    db.transaction(() => {
+        const cas = db.prepare("UPDATE bond_slash_proposals SET status = 'executed', executed_at = datetime('now'), executed_txn_id = ? WHERE id = ? AND status = 'proposed'")
+            .run(args.txnId, args.proposalId);
+        if (cas.changes !== 1)
+            throw new Error('execute race: already processed');
+        const s = slashBond(db, { depositId: row.deposit_id, txnId: args.txnId, reason: `bond_slash_proposal:${row.id} dispute:${row.dispute_id}${row.reason ? ` ${row.reason}` : ''}` });
+        if (!s.ok)
+            throw new Error(s.reason);
+    })();
+    return out;
+}
+/** 提案列表(admin 队列/卖家告知)。 */
+export function listBondSlashProposals(db, filter = {}) {
+    const where = [];
+    const params = [];
+    if (filter.sellerId) {
+        where.push('p.seller_id = ?');
+        params.push(filter.sellerId);
+    }
+    if (filter.status) {
+        where.push('p.status = ?');
+        params.push(filter.status);
+    }
+    return db.prepare(`SELECT p.*, u.name AS seller_name, u.handle AS seller_handle
+                     FROM bond_slash_proposals p JOIN users u ON u.id = p.seller_id
+                     ${where.length ? 'WHERE ' + where.join(' AND ') : ''} ORDER BY p.proposed_at DESC LIMIT 200`).all(...params);
+}

package/dist/bond-terms.js

@@ -0,0 +1,31 @@
+/**
+ * 商家履约保证金条款(B 决策前置,2026-07-05)。
+ *
+ * 为什么存在:罚没/退还必须有【商家缴纳前显式同意】的合同依据 —— 没有条款文本,罚没在合同法上站不住
+ *   (SG 语境:罚没条款须像"约定履约损害赔偿"而非"惩罚",penalty clause 可能不可执行,故文本刻意
+ *   采用 liquidated-damages 表述并写明用途去向)。条款版本化:缴纳申报时快照 terms_version 进 deposit 行,
+ *   新版本只影响之后的缴纳;版本串同时作为 rail-clearance 的 policy_version(可审计对齐)。
+ *
+ * 变更本文本 = 变更商家合同条款:必须 bump BOND_TERMS.version,且只对新申报生效。
+ */
+export const BOND_TERMS = {
+    version: 'bond-terms.v1.2026-07-05',
+    zh: `【商家履约保证金条款 v1】
+1. 性质:本保证金是你(商家)向 WebAZ 平台缴纳的【履约担保物】(security deposit),用于担保你在直付(direct_p2p)交易中的履约义务。它不是投资、不是存款、不是买家资金,也不产生利息。
+2. 金额与币种:按平台公示档位(当前 T0 = 500 USDC 等值;固定 token 数,档位参考 ≈ S$500,非实时汇率换算)。可按平台公示的收款账户以 USDC 或对应法币缴纳;跨币种等值由平台运营在核实到账时按公示口径认定。
+3. 生效:缴纳后须经平台运营核实真实到账并确认锁定方才生效;申报本身不授予任何资格。
+4. 退还:你可申请退出并退还保证金。前提是【无任何未了结的直付责任】(在途订单、售后/退货流程、争议、待复核罚没、平台服务费欠费等),并经过平台公示的冷静期;冷静期内你的直付资格暂停,期间可随时撤销申请。退还在协议外原路/约定方式完成并留痕。
+5. 罚没(约定履约损害赔偿):仅当直付交易争议经平台仲裁【裁定你承担责任】后,平台方可发起罚没提案;提案设有公示冷静期(即你的申诉窗口),期满经人工复核后执行。你同意:被执行的罚没金额作为【约定的履约损害赔偿与生态修复金】全额转入平台处罚金专户 —— 该专户只进不出、不用于平台收益、不向个案裁决者发放,用途受治理公示约束。
+6. 链上风险:以 USDC 缴纳时,链、地址、金额由你自行核对;错链/错地址造成的损失由你承担。
+7. 条款版本:本条款版本化。你每次缴纳申报时同意的版本会被记录;条款更新只影响之后的新缴纳。
+8. 你确认:已阅读并理解上述条款,自愿缴纳。`,
+    en: `[Merchant Performance Bond Terms v1]
+1. Nature: this bond is a SECURITY DEPOSIT you (the merchant) place with the WebAZ platform to secure your fulfilment obligations in Direct Pay (direct_p2p) trades. It is not an investment, not a deposit account, not buyer funds, and bears no interest.
+2. Amount & currency: per the published tier (currently T0 = 500 USDC equivalent; a fixed token amount — the "≈ S$500" label is a tier reference, not a live FX conversion). Payable in USDC or the corresponding fiat via the platform's published receiving accounts; cross-currency equivalence is determined by platform operations at verification time per the published basis.
+3. Effectiveness: the bond takes effect only after platform operations verify the actual arrival of funds and confirm the lock; a declaration by itself grants nothing.
+4. Refund: you may request exit and refund, provided you have NO outstanding Direct Pay liabilities (open orders, after-sales/return flows, disputes, pending slash reviews, unpaid platform service fees, etc.) and after the published cooling window; your Direct Pay eligibility is suspended during the window and you may cancel the request at any time. The refund is completed off-protocol via the original/agreed channel and recorded.
+5. Slash (agreed liquidated damages): only after a Direct Pay dispute is RULED against you by platform arbitration may the platform open a slash proposal; the proposal carries a published cooling window (your appeal window) and is executed after human review. You agree that a slashed amount, as AGREED LIQUIDATED DAMAGES and ecosystem-remediation funds, is transferred in full to the platform's penalty reserve — inflow-only, never platform profit, never paid to per-case adjudicators, with usage bound by published governance.
+6. On-chain risk: when paying in USDC you are responsible for verifying the chain, address and amount; losses from wrong-chain/wrong-address transfers are yours.
+7. Versioning: these terms are versioned. The version you agree to at each declaration is recorded; updates affect only subsequent deposits.
+8. You confirm you have read and understood these terms and deposit voluntarily.`,
+};

package/dist/direct-pay-bond-rail-clearance.js

@@ -10,10 +10,11 @@
  *   Lock B — registry 放行锁(本模块):某 rail 的 legal_cleared + production_ready + 非占位 policy_version +
  *            jurisdiction ∈ allowlist。当前【全部默认 fail-closed】→ 全拒。由 assertBondRailCleared 守。
  *
- * 现状:本模块所有 rail 的 legal_cleared=false / allowlist=[] / policy_version=占位 / production_ready=false,
- *   且 Lock A 也全拒 → isBondRailClearedForProduction 恒 false → confirmProductionReceipt 恒抛 →
- *   sellerHasProductionBaseBondLocked 恒 false → Direct Pay 仍 non-launchable / fail-closed。
- *   置真值(legal_cleared / 真实 allowlist / 真实 policy_version / production_ready)= 法务清门 + 外审 gated 决定,【不在本 PR】。
+ * 现状(2026-07-05 更新):**operator_attested 轨已放行(SG)** —— Holden 决策 B(经营者知情自担风险,
+ *   非律师意见):保证金是商家履约担保物、不涉买家资金/货款;法币收取=常规合同担保物;USDC 收取的 PS Act
+ *   DPT 定性风险已知并接受(security-deposit 豁免待律师确认,确认前敞口=pre-launch 无真实商家)。前置已建:
+ *   条款文本+缴纳前强制同意(src/bond-terms.ts,liquidated-damages 表述;policy_version=条款版本,审计对齐)。
+ *   usdc_onchain / fiat_psp【自动收款轨】仍全 fail-closed(未实现+未清门,与本次放行无关)。
  */
 import { getDepositRail } from './deposit-rails.js';
 /** policy_version 占位值(= 未设)。等于此值即视为未放行。 */
@@ -24,6 +25,10 @@ export const BOND_POLICY_VERSION_PLACEHOLDER = 'pre-legal-unset';
  * 全部默认 fail-closed —— 真值由后续【法务清门 + 外审】PR 配置,不在本 scaffold。
  */
 const BOND_RAIL_CLEARANCE = {
+    // ✅ 2026-07-05 放行(Holden 决策 B,经营者知情自担;详见文件头)。policy_version = 条款版本(bond-terms.ts,
+    //   缴纳前强制同意)。运营就绪:B1 申报/核实队列 + confirm-production(ROOT+Passkey)+ B2 退还 + B3 罚没全链已建。
+    operator_attested: { railId: 'operator_attested', assetCategory: 'usdc_fiat', legalCleared: true, jurisdictionAllowlist: ['SG'], policyVersion: 'bond-terms.v1.2026-07-05', productionReady: true },
+    // 自动收款轨:未实现(Lock A 也拒),维持全 fail-closed —— 与 operator_attested 放行无关。
     usdc_onchain: { railId: 'usdc_onchain', assetCategory: 'usdc', legalCleared: false, jurisdictionAllowlist: [], policyVersion: BOND_POLICY_VERSION_PLACEHOLDER, productionReady: false },
     fiat_psp: { railId: 'fiat_psp', assetCategory: 'fiat', legalCleared: false, jurisdictionAllowlist: [], policyVersion: BOND_POLICY_VERSION_PLACEHOLDER, productionReady: false },
 };
@@ -33,7 +38,7 @@ export function getBondRailClearance(railId) {
 }
 /**
  * 该 rail 在该 jurisdiction 下是否【可用于生产 base-bond】= Lock A(真实实现)且 Lock B(registry 放行)全过。
- * 当前恒 false。纯读,无副作用。
+ * jurisdiction 语义=【平台收款主体法域】(非卖家法域)。2026-07-05 起 operator_attested/SG 为 true(#240)。纯读,无副作用。
  */
 export function isBondRailClearedForProduction(railId, jurisdiction) {
     const c = getBondRailClearance(railId);

package/dist/direct-pay-cancel-refund.js

@@ -0,0 +1,160 @@
+import { restorePreShipDirectPayStock } from './direct-pay-stock.js'; // 库存回补唯一入口(pre-ship 放行;已出库拒绝,走退货验收)
+export function initDirectPayCancelRefundSchema(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS direct_pay_cancel_requests (
+      id TEXT PRIMARY KEY,
+      order_id TEXT NOT NULL,
+      buyer_id TEXT NOT NULL,
+      seller_id TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'requested' CHECK (status IN ('requested','refund_marked','settled','declined','withdrawn')),
+      reason TEXT,
+      refund_reference TEXT,
+      respond_deadline TEXT NOT NULL,
+      seller_responded_at TEXT,
+      settled_at TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_dpcr_order ON direct_pay_cancel_requests(order_id);
+  `);
+}
+function loadOrder(db, orderId) {
+    return db.prepare('SELECT id, buyer_id, seller_id, status, payment_rail, product_id, quantity FROM orders WHERE id = ?').get(orderId);
+}
+/** 最新一条请求(任意状态)。 */
+function latestRequest(db, orderId) {
+    return db.prepare('SELECT * FROM direct_pay_cancel_requests WHERE order_id = ? ORDER BY created_at DESC, rowid DESC LIMIT 1').get(orderId);
+}
+/** requested 且 respond_deadline 已过 → 视为 expired(lazy,不写库;可重新 request)。 */
+function effectiveStatus(db, r) {
+    if (r.status === 'requested') {
+        const over = db.prepare("SELECT datetime(?) < datetime('now') AS o").get(r.respond_deadline);
+        if (over.o)
+            return 'expired';
+    }
+    return r.status;
+}
+function respondDays(db) {
+    try {
+        const p = db.prepare("SELECT value FROM protocol_params WHERE key = 'direct_pay.cancel_refund_respond_days'").get();
+        if (p)
+            return Math.max(1, Number(p.value) || 5);
+    }
+    catch { /* 表缺失 → 默认 */ }
+    return 5;
+}
+/** ① 买家发起取消退款请求。 */
+export function requestCancelRefund(db, args) {
+    const order = loadOrder(db, args.orderId);
+    if (!order)
+        return { ok: false, error: '订单不存在', error_code: 'ORDER_NOT_FOUND' };
+    if (order.buyer_id !== args.buyerId)
+        return { ok: false, error: '只有订单买家可发起取消退款', error_code: 'NOT_ORDER_BUYER' };
+    if (order.payment_rail !== 'direct_p2p')
+        return { ok: false, error: '仅直付订单适用取消退款握手(托管单走托管退款)', error_code: 'NOT_DIRECT_PAY' };
+    if (order.status !== 'accepted')
+        return { ok: false, error: '仅付款后、发货前(accepted)可申请取消退款', error_code: 'ORDER_NOT_ACCEPTED' };
+    const last = latestRequest(db, args.orderId);
+    if (last && ['requested', 'refund_marked'].includes(effectiveStatus(db, last)))
+        return { ok: false, error: '已有进行中的取消退款请求', error_code: 'REQUEST_ALREADY_OPEN' };
+    const n = db.prepare('SELECT COUNT(*) AS n FROM direct_pay_cancel_requests WHERE order_id = ?').get(args.orderId).n;
+    if (n >= 3)
+        return { ok: false, error: '本订单取消退款请求次数已达上限(3),请与卖家协商或发起争议', error_code: 'REQUEST_CAP_REACHED' };
+    const reason = typeof args.reason === 'string' ? args.reason.trim().slice(0, 200) : null;
+    db.prepare(`INSERT INTO direct_pay_cancel_requests (id, order_id, buyer_id, seller_id, reason, respond_deadline)
+              VALUES (?, ?, ?, ?, ?, datetime('now', ?))`)
+        .run(args.requestId, args.orderId, order.buyer_id, order.seller_id, reason, `+${respondDays(db)} days`);
+    return { ok: true, request: latestRequest(db, args.orderId), status: 'requested' };
+}
+/** ② a. 卖家拒绝(如已备货)→ 履约继续。 */
+export function declineCancelRefund(db, args) {
+    const order = loadOrder(db, args.orderId);
+    if (!order)
+        return { ok: false, error: '订单不存在', error_code: 'ORDER_NOT_FOUND' };
+    if (order.seller_id !== args.sellerId)
+        return { ok: false, error: '只有订单卖家可拒绝', error_code: 'NOT_ORDER_SELLER' };
+    const r = db.prepare(`UPDATE direct_pay_cancel_requests SET status = 'declined', seller_responded_at = datetime('now'), updated_at = datetime('now')
+                        WHERE order_id = ? AND status = 'requested'`).run(args.orderId);
+    if (r.changes !== 1)
+        return { ok: false, error: '没有待响应的取消退款请求', error_code: 'NO_OPEN_REQUEST' };
+    return { ok: true, status: 'declined' };
+}
+/** ② b. 卖家声明已场外退款(可附退款参考)。此后买家只能 confirm 或走争议(不可 withdraw)。 */
+export function markRefunded(db, args) {
+    const order = loadOrder(db, args.orderId);
+    if (!order)
+        return { ok: false, error: '订单不存在', error_code: 'ORDER_NOT_FOUND' };
+    if (order.seller_id !== args.sellerId)
+        return { ok: false, error: '只有订单卖家可声明退款', error_code: 'NOT_ORDER_SELLER' };
+    if (order.status !== 'accepted')
+        return { ok: false, error: '订单已不在待发货阶段,握手已失效', error_code: 'ORDER_NOT_ACCEPTED' };
+    const ref = typeof args.refundReference === 'string' ? args.refundReference.trim().slice(0, 200) : null;
+    const r = db.prepare(`UPDATE direct_pay_cancel_requests SET status = 'refund_marked', refund_reference = ?, seller_responded_at = datetime('now'), updated_at = datetime('now')
+                        WHERE order_id = ? AND status = 'requested'`).run(ref, args.orderId);
+    if (r.changes !== 1)
+        return { ok: false, error: '没有待响应的取消退款请求', error_code: 'NO_OPEN_REQUEST' };
+    return { ok: true, status: 'refund_marked' };
+}
+/** 买家撤回 —— 仅限卖家尚未响应(requested)。卖家已 mark_refunded 后禁撤(防"收了退款还让订单继续履约")。 */
+export function withdrawCancelRefund(db, args) {
+    const order = loadOrder(db, args.orderId);
+    if (!order)
+        return { ok: false, error: '订单不存在', error_code: 'ORDER_NOT_FOUND' };
+    if (order.buyer_id !== args.buyerId)
+        return { ok: false, error: '只有订单买家可撤回', error_code: 'NOT_ORDER_BUYER' };
+    const r = db.prepare(`UPDATE direct_pay_cancel_requests SET status = 'withdrawn', updated_at = datetime('now')
+                        WHERE order_id = ? AND status = 'requested'`).run(args.orderId);
+    if (r.changes !== 1)
+        return { ok: false, error: '没有可撤回的请求(卖家已声明退款后不可撤回,请确认收款或发起争议)', error_code: 'NO_OPEN_REQUEST' };
+    return { ok: true, status: 'withdrawn' };
+}
+/**
+ * ③ 买家确认已收到场外退款 → settled + accepted→cancelled(system)+ 恢复库存。
+ * 【必须由路由 db.transaction 包裹】;transition 依赖注入(状态机 adapter,便于单测与防循环依赖)。
+ */
+export function confirmRefundReceived(db, args, transition) {
+    const order = loadOrder(db, args.orderId);
+    if (!order)
+        return { ok: false, error: '订单不存在', error_code: 'ORDER_NOT_FOUND' };
+    if (order.buyer_id !== args.buyerId)
+        return { ok: false, error: '只有订单买家可确认收到退款', error_code: 'NOT_ORDER_BUYER' };
+    // 竞态重校验:卖家已发货/已争议 → 握手失效,绝不在非 accepted 状态上关单
+    if (order.status !== 'accepted')
+        return { ok: false, error: '订单已不在待发货阶段(可能已发货/争议),握手已失效', error_code: 'ORDER_NOT_ACCEPTED' };
+    const sys = db.prepare("SELECT id FROM users WHERE role = 'system' LIMIT 1").get();
+    if (!sys)
+        return { ok: false, error: '系统账号缺失', error_code: 'SYS_MISSING' };
+    // 请求行 CAS:仅 refund_marked → settled(卖家未声明退款前买家不可单方确认关单)
+    const cas = db.prepare(`UPDATE direct_pay_cancel_requests SET status = 'settled', settled_at = datetime('now'), updated_at = datetime('now')
+                          WHERE order_id = ? AND status = 'refund_marked'`).run(args.orderId);
+    if (cas.changes !== 1)
+        return { ok: false, error: '卖家尚未声明退款,不可确认', error_code: 'REFUND_NOT_MARKED' };
+    const t = transition(db, args.orderId, 'cancelled', sys.id, [], '直付取消退款握手:卖家已场外退款,买家确认收到 → 无责取消');
+    if (!t.success)
+        throw new Error(t.error || 'TRANSITION_FAILED'); // 抛错让路由 db.transaction 整体回滚(含上面 CAS)
+    // 库存回补:经唯一守卫入口(accepted=已付未发,A 类放行;已出库来源在入口被拒 —— 见 direct-pay-stock.ts 情形矩阵)
+    restorePreShipDirectPayStock(db, { fromStatus: 'accepted', productId: order.product_id, quantity: Number(order.quantity) || 1 });
+    return { ok: true, status: 'cancelled' };
+}
+/** 状态读取(party-gated):非当事方一律 NOT_A_PARTY,不泄露请求存在性。 */
+export function getCancelRefundState(db, orderId, viewerId) {
+    const order = loadOrder(db, orderId);
+    if (!order)
+        return { ok: false, error: '订单不存在', error_code: 'ORDER_NOT_FOUND' };
+    const isBuyer = order.buyer_id === viewerId;
+    const isSeller = order.seller_id === viewerId;
+    if (!isBuyer && !isSeller)
+        return { ok: false, error: '仅订单当事方可查看', error_code: 'NOT_A_PARTY' };
+    const last = latestRequest(db, orderId);
+    const eff = last ? effectiveStatus(db, last) : null;
+    const open = eff === 'requested' || eff === 'refund_marked';
+    const req = last ? { ...last, status: eff, stale: open && order.status !== 'accepted' } : null;
+    return {
+        ok: true,
+        request: req ?? undefined,
+        can_request: isBuyer && order.payment_rail === 'direct_p2p' && order.status === 'accepted' && !open,
+        can_respond: isSeller && eff === 'requested' && order.status === 'accepted',
+        can_confirm: isBuyer && eff === 'refund_marked' && order.status === 'accepted',
+        can_withdraw: isBuyer && eff === 'requested',
+    };
+}

package/dist/direct-pay-create.js

@@ -8,6 +8,27 @@ import { enforceCollateralExposureGate } from './merchant-bond-exposure.js'; //
 import { productStoreVerified } from './product-verification.js';
 import { sellerExemptFromPerProduct } from './store-verification.js';
 import { safeRunDirectPayAmlMonitor } from './direct-pay-aml-monitor.js';
+import { getUsdRatesSync, convertUsdcToLocal, SUPPORTED_CURRENCIES } from './fx-rates.js'; // 审计项 E:建单冻结应付参考换算(display-only,同步缓存)
+import { createNotification } from './layer2-business/L2-6-notifications/notification-engine.js'; // 审计项 B:直付转移此前通知黑洞(卖家不知有单/已付款)
+import { buildTradeTermsSnapshot, writeTradeTermsSnapshot } from './trade-terms.js'; // S0 交易条款快照(证据,fail-soft 零钱路)
+/** 应付参考换算快照(审计项 E):同步缓存 FX(display-only,fallback 亦可,永不抛/永不阻塞建单)。
+ *  USD/USDC/未知币种 → 只记 payable_usdc(前端回落仅 USDC);换算失败同样只记 usdc,建单照常。 */
+export function buildPayableSnapshot(totalUsdc, accountCurrency) {
+    const base = { payable_usdc: totalUsdc };
+    const cur = String(accountCurrency || '').toUpperCase();
+    if (!cur || cur === 'USD' || cur === 'USDC' || !SUPPORTED_CURRENCIES.includes(cur))
+        return base;
+    try {
+        const snap = getUsdRatesSync();
+        const approx = convertUsdcToLocal(totalUsdc, cur, snap.rates);
+        if (!Number.isFinite(approx))
+            return base;
+        return { ...base, payable_approx: Math.round(approx * 100) / 100, payable_currency: cur, payable_rate: snap.rates[cur], payable_asof: snap.as_of, payable_stale: snap.stale };
+    }
+    catch {
+        return base;
+    }
+}
 /** 原子创建 direct_p2p 订单。成功返回 { orderId };任一步失败抛错(调用方回 409,事务已回滚)。 */
 export function createDirectPayOrder(db, deps, args) {
     const { generateId, transition, appendOrderEvent } = deps;
@@ -15,26 +36,38 @@ export function createDirectPayOrder(db, deps, args) {
     db.transaction(() => {
         // 本金不入协议:escrow_amount=0,不写 buyer wallet。同一 INSERT 写入【入口控制 policy 快照】(frozen-at-create)。
         const s = args.snapshot;
+        const quoteRequired = !!args.shipping?.quoteRequired;
+        const manual = args.acceptMode === 'manual' || quoteRequired; // 询价单必须先接单报价(无论接单模式)
+        // manual:不设 window deadline(接单时才起表),记 accept_mode 快照 + 接单截止。
         db.prepare(`INSERT INTO orders (id, product_id, buyer_id, seller_id, quantity, unit_price, total_amount, escrow_amount,
       status, payment_rail, shipping_address, direct_pay_instruction_snapshot, direct_pay_account_snapshot, direct_pay_window_deadline,
+      accept_mode_snapshot, pending_accept_deadline, ship_to_region, shipping_fee, shipping_est_days, shipping_quote_required,
       direct_pay_enabled_snapshot, direct_pay_rail_breaker_snapshot, direct_pay_region_snapshot,
       direct_pay_region_allowlist_snapshot, direct_pay_per_tx_cap_units_snapshot, direct_pay_seller_breaker_snapshot, direct_pay_decision_code)
-      VALUES (?,?,?,?,?,?,?,0,'created','direct_p2p',?,?,?,?, ?,?,?,?,?,?,?)`)
-            .run(orderId, args.productId, args.buyerId, args.sellerId, args.quantity, args.unitPrice, args.totalAmount, args.shippingAddress, args.instructionSnapshot, args.accountSnapshot ? JSON.stringify(args.accountSnapshot) : null, args.windowDeadlineIso, s.enabled ? 1 : 0, s.railBreakerTripped ? 1 : 0, s.region, JSON.stringify(s.regionAllowlist), s.perTxCapUnits, s.sellerBreakerTripped ? 1 : 0, s.decisionCode);
+      VALUES (?,?,?,?,?,?,?,0,'created','direct_p2p',?,?,?,?,?,?,?,?,?,?, ?,?,?,?,?,?,?)`)
+            .run(orderId, args.productId, args.buyerId, args.sellerId, args.quantity, args.unitPrice, args.totalAmount, args.shippingAddress, args.instructionSnapshot, args.accountSnapshot ? JSON.stringify(args.accountSnapshot) : null, manual ? null : args.windowDeadlineIso, args.acceptMode, manual ? (args.pendingAcceptDeadlineIso ?? null) : null, args.shipping?.region ?? null, (args.shipping && (args.shipping.fee > 0 || args.shipping.region)) ? args.shipping.fee : null, args.shipping?.estDays ?? null, quoteRequired ? 1 : null, s.enabled ? 1 : 0, s.railBreakerTripped ? 1 : 0, s.region, JSON.stringify(s.regionAllowlist), s.perTxCapUnits, s.sellerBreakerTripped ? 1 : 0, s.decisionCode);
         appendOrderEvent(db, {
             orderId, eventType: 'open', fromStatus: null, toStatus: 'created', actorId: args.buyerId, actorRole: 'buyer',
             extra: { product_id: args.productId, seller_id: args.sellerId, quantity: args.quantity, total_amount: args.totalAmount, payment_rail: 'direct_p2p' },
         });
-        // created → direct_pay_window(system-only edge);失败回滚。
-        const rc = transition(db, orderId, 'direct_pay_window', 'sys_protocol', [], 'Rail1 直付:进入付款窗口(平台费完成时记应收,建单不收费)');
+        // created → direct_pay_window(auto)| pending_accept(manual,v16:卖家确认接单前不开付款窗口)。失败回滚。
+        const rc = manual
+            ? transition(db, orderId, 'pending_accept', 'sys_protocol', [], '手动接单:等待卖家确认接单(付款前,不展示收款信息)')
+            : transition(db, orderId, 'direct_pay_window', 'sys_protocol', [], 'Rail1 直付:进入付款窗口(平台费完成时记应收,建单不收费)');
         if (!rc.success)
-            throw new Error(rc.error || 'transition→direct_pay_window failed');
+            throw new Error(rc.error || `transition→${manual ? 'pending_accept' : 'direct_pay_window'} failed`);
         // 【无建单资金写】平台费完成时 accrue;建单门是【首单宽限 + 预充值续用】只读门(在 createDirectPayResponse 内,建单前)。
         // 扣库存(原子;售罄即抛回滚)。变体/flash 直付 v1 不支持。
         const upd = db.prepare('UPDATE products SET stock = stock - ? WHERE id = ? AND stock >= ?').run(args.quantity, args.productId, args.quantity);
         if (upd.changes !== 1)
             throw new Error('stock depleted');
     })();
+    // S0 条款快照:冻结下单时的时效/退货/清关/税责声明(事务外 fail-soft —— 快照是证据非计价输入,缺失=pre-S0 同待遇)
+    writeTradeTermsSnapshot(db, orderId, buildTradeTermsSnapshot(db, {
+        productId: args.productId, sellerId: args.sellerId,
+        shipping: { source: args.shipping?.quoteRequired ? 'quote_pending' : (args.shipping?.region ? 'template' : 'none'), region: args.shipping?.region ?? null, fee: args.shipping?.quoteRequired ? null : ((args.shipping && (args.shipping.fee > 0 || args.shipping.region)) ? args.shipping.fee : null), estDays: args.shipping?.estDays ?? null, freeThresholdApplied: args.shipping?.freeThresholdApplied },
+        acceptModeEffective: args.acceptMode,
+    }));
     return { orderId };
 }
 /**
@@ -94,7 +127,7 @@ export function createDirectPayResponse(res, db, deps, ctx) {
             return;
         }
         instructionSnapshot = acc.instruction;
-        accountSnapshot = { account_id: acc.id, method: acc.method, currency: acc.currency, label: acc.label, qr_ref: acc.qr_image_ref };
+        accountSnapshot = { account_id: acc.id, method: acc.method, currency: acc.currency, label: acc.label, qr_ref: acc.qr_image_ref, ...buildPayableSnapshot(ctx.totalAmount, acc.currency) };
     }
     else {
         const instr = getActivePaymentInstruction(db, sellerId);
@@ -113,6 +146,15 @@ export function createDirectPayResponse(res, db, deps, ctx) {
         res.status(409).json({ error_code: coarsenBuyerFacingDirectPayCode(quota.code), error: '该卖家暂不支持直付' });
         return;
     }
+    // 审计项 G:单买家·单卖家在途直付单上限(param direct_pay.max_open_per_buyer_seller,默认 5)——
+    //   防单个买家刷单锁库存(建单即扣库存,窗口+宽限可占 ~52h)+ 耗尽卖家缓交额度的 griefing。只读门,任何写之前;
+    //   买家自身行为所致 → 精确 code 直接透出(非卖家隐私,无需脱敏)。
+    const openCap = Math.max(1, Number(deps.getProtocolParam('direct_pay.max_open_per_buyer_seller', 5)) || 5);
+    const openN = db.prepare(`SELECT COUNT(*) n FROM orders WHERE buyer_id = ? AND seller_id = ? AND payment_rail = 'direct_p2p' AND status IN ('pending_accept','direct_pay_window','direct_expired_unconfirmed','accepted','payment_query')`).get(ctx.buyerId, sellerId).n;
+    if (openN >= openCap) {
+        res.status(429).json({ error_code: 'DIRECT_PAY_TOO_MANY_OPEN', error: `你在该卖家已有 ${openN} 笔进行中的直付订单(上限 ${openCap}),请先完成或取消后再下单` });
+        return;
+    }
     // §6.5 抵押背书开放敞口上限(backend create-gate)。休眠安全:无真实链上抵押(collateral=0)→ N/A;
     //   有抵押才读 exposure_factor_bps(fail-closed)+ 比较 open_exposure+new ≤ collateral×bps/10000。
     //   当前 merchant_bond 关闭、无 active 存款 → 对缓交卖家零影响(返回 ok)。买家面脱敏。
@@ -137,23 +179,50 @@ export function createDirectPayResponse(res, db, deps, ctx) {
         return;
     }
     const windowHours = deps.getProtocolParam('direct_pay.payment_window_hours', 4);
+    // 手动接单模式(v16):单品覆盖 ?? 店铺默认 ?? 'auto'。快照进订单(卖家事后改不影响在途单)。
+    //   'manual' → 先进 pending_accept:不开付款窗口、不展示收款信息(时序门=非托管唯一正确的付款风控)。
+    const storeMode = db.prepare('SELECT store_accept_mode FROM users WHERE id = ?').get(sellerId)?.store_accept_mode;
+    const rawMode = ctx.product.accept_mode ?? storeMode;
+    const acceptMode = rawMode === 'manual' ? 'manual' : 'auto';
+    const acceptWindowHours = Math.max(1, Number(deps.getProtocolParam('direct_pay.accept_window_hours', 24)) || 24);
     try {
         const { orderId } = createDirectPayOrder(db, deps, {
             productId: ctx.product.id, sellerId, buyerId: ctx.buyerId, quantity: ctx.reqQty,
             unitPrice: ctx.basePrice, totalAmount: ctx.totalAmount,
             instructionSnapshot, accountSnapshot, windowDeadlineIso: new Date(Date.now() + windowHours * 3600_000).toISOString(),
-            shippingAddress: ctx.shippingAddress,
+            shippingAddress: ctx.shippingAddress, acceptMode, shipping: ctx.shipping,
+            pendingAcceptDeadlineIso: (acceptMode === 'manual' || ctx.shipping?.quoteRequired) ? new Date(Date.now() + acceptWindowHours * 3600_000).toISOString() : undefined,
             // frozen-at-create policy 快照:control 全过(ctrl.ok)才到此,decisionCode='OK'。
             snapshot: { enabled: cfg.enabled, railBreakerTripped: cfg.railBreakerTripped, region: cfg.region, regionAllowlist: cfg.regionAllowlist, perTxCapUnits: cfg.perTxCapUnits, sellerBreakerTripped, decisionCode: 'OK' },
         });
         // PR-6C: 建单事务已提交后,运行【append-only AML 监控】(fail-soft;命中治理阈值即 append aml_flags,仅影响【后续】
         //   create/availability 的 #107 breaker)。safe 包装吞异常 → 监控失败【绝不】回流成建单失败,也不碰当前订单。
         safeRunDirectPayAmlMonitor(db, { sellerId, orderId, nowIso: new Date().toISOString(), getProtocolParam: deps.getProtocolParam });
+        // 审计项 B(N2):通知卖家。manual → 待接单提醒(带截止);auto → 原"等买家付款"。fail-soft 不阻断建单响应。
+        try {
+            if (ctx.shipping?.quoteRequired) {
+                createNotification(db, sellerId, orderId, 'direct_pay_quote_needed', '🛎️ 新直付订单(模板外地区),待你报价运费', `商品「${String(ctx.product.title || '').slice(0, 40)}」× ${ctx.reqQty},货款 ${ctx.totalAmount} USDC,收货地区 ${ctx.shipping.region ?? '-'} 不在你的运费模板内。请在 ${acceptWindowHours} 小时内核实可达并报价(运费+预计时效),买家确认后才进入付款;超时订单自动取消。`, { templateKey: 'dp_quote_needed', params: { product: String(ctx.product.title || '').slice(0, 40), qty: ctx.reqQty, amount: ctx.totalAmount, region: ctx.shipping.region ?? '-', hours: acceptWindowHours } });
+            }
+            else if (acceptMode === 'manual') {
+                createNotification(db, sellerId, orderId, 'direct_pay_pending_accept', '🛎️ 新直付订单,待你确认接单', `商品「${String(ctx.product.title || '').slice(0, 40)}」× ${ctx.reqQty},应付 ${ctx.totalAmount} USDC。请在 ${acceptWindowHours} 小时内确认接单(核实可发货/物流),超时订单自动取消;接单后买家才会看到收款方式。`, { templateKey: 'dp_pending_accept_new', params: { product: String(ctx.product.title || '').slice(0, 40), qty: ctx.reqQty, amount: ctx.totalAmount, hours: acceptWindowHours } });
+            }
+            else {
+                createNotification(db, sellerId, orderId, 'direct_pay_order_created', '🛒 新直付订单,等买家付款', `商品「${String(ctx.product.title || '').slice(0, 40)}」× ${ctx.reqQty},应付 ${ctx.totalAmount} USDC。买家完成场外付款并标记后你会收到发货提醒。`, { templateKey: 'dp_new_order', params: { product: String(ctx.product.title || '').slice(0, 40), qty: ctx.reqQty, amount: ctx.totalAmount } });
+            }
+        }
+        catch { /* 通知失败不阻断 */ }
         // ⚠️ 不在 create 响应里下发卖家收款说明(payment_instruction/label)——D1/D2 both-acked 前不得泄露(响应契约门,
         //   非仅 UI 软门)。买家先完成披露 ack,再经 GET /orders/:id 读取 redaction-gated 的 direct_pay_instruction_snapshot。
+        //   manual 单更进一步:pending_accept 阶段【状态门】也挡收款信息(orders-read),卖家接单后才可见。
+        const _pending = acceptMode === 'manual' || !!ctx.shipping?.quoteRequired;
         res.json({
-            success: true, order_id: orderId, status: 'direct_pay_window', payment_rail: 'direct_p2p',
-            note: '本金不经 WebAZ;完成 D1/D2 风险确认(Passkey)后即可在订单页查看卖家收款说明,请【场外】付款后点"我已付款"。本档无经济保障、不退款,仅对卖家信誉处罚。',
+            success: true, order_id: orderId, status: _pending ? 'pending_accept' : 'direct_pay_window', payment_rail: 'direct_p2p',
+            shipping_quote_required: ctx.shipping?.quoteRequired || undefined,
+            note: ctx.shipping?.quoteRequired
+                ? '收货地区在卖家运费模板之外:卖家将核实可达性并报价运费/时效,你确认新总额后才进入付款环节;超时未报价将自动取消,你无需任何操作。'
+                : _pending
+                    ? '本单为手动接单:卖家确认可发货并接单后,你才会看到收款方式并进入付款环节;超时未接单将自动取消,你无需任何操作。'
+                    : '本金不经 WebAZ;完成 D1/D2 风险确认(Passkey)后即可在订单页查看卖家收款说明,请【场外】付款后点"我已付款"。本档无经济保障、不退款,仅对卖家信誉处罚。',
         });
     }
     catch (e) {

package/dist/direct-pay-disclosures.js

@@ -1,27 +1,33 @@
 export const STAGE = { PRE_SELECT: 'pre_select', PRE_CONFIRM: 'pre_confirm' };
-/** D1 = PRE_SELECT 提醒(买家单视角,无任何卖家机制)。 */
+/** D1 = PRE_SELECT 提醒(买家单视角,无任何卖家机制)。措辞准确化:强调"无退款能力(从不托管本金)"而非"拒绝退款"。 */
 export const D1 = {
     stage: STAGE.PRE_SELECT,
-    version: 'd1.v1.2026-06-27',
-    zh: '本单无经济保障,出问题不退款,仅对卖家作信誉处罚。请自行判断风险后付款。',
-    en: 'This order has NO economic protection: no refund if it goes wrong, only reputation penalties on the seller. Decide your own risk before paying.',
+    version: 'd1.v2.2026-07-04',
+    zh: '本次订单为非担保交易:你直接付款给卖家(场外),WebAZ 不托管本金、不能承诺退款或任何经济保障,仅对卖家有信誉处罚权。请自行判断后决定是否付款。',
+    en: 'This is a non-guaranteed transaction: you pay the seller directly (off-platform). WebAZ does not custody the funds and cannot promise refunds or any economic protection — only reputation penalties against the seller. Decide for yourself whether to pay.',
 };
-/** D2 = PRE_CONFIRM 提醒(paid-but-timeout + 最终风险再确认)。 */
+/** D2 = PRE_CONFIRM 提醒(paid-but-timeout + 最终风险再确认)。措辞准确化同 D1。 */
 export const D2 = {
     stage: STAGE.PRE_CONFIRM,
-    version: 'd2.v1.2026-06-27',
-    zh: "付款后请立即点'我已付款';若窗口过期你须发起争议,本档不退款、仅信誉处罚。确认承担风险后再付款。",
-    en: "Mark 'I have paid' immediately after paying; if the window lapses you must raise a dispute — this tier issues no refund, only reputation penalties. Confirm you accept the risk before paying.",
+    version: 'd2.v2.2026-07-04',
+    zh: "付款后请立即回来点'我已付款'。若付款窗口过期,你需自行发起争议(证据裁决,仅影响卖家信誉)。WebAZ 无退款能力(从不托管本金)。确认已了解后再付款。",
+    en: "After paying, come back and tap 'I have paid' right away. If the payment window lapses, you must raise a dispute yourself (evidence-based ruling; affects only the seller's reputation). WebAZ has no refund capability (it never custodies the funds). Confirm you understand before paying.",
 };
 const STAGE_VERSION = { [STAGE.PRE_SELECT]: D1.version, [STAGE.PRE_CONFIRM]: D2.version };
 /** 买家面披露载荷(只含买家自己的部分)。 */
 export function getBuyerDisclosures() {
     return { preSelect: D1, preConfirm: D2 };
 }
-/** 记录一次提醒 ack(append-only;同单同 stage 幂等)。stage 决定 notice_version。 */
+/** 记录一次提醒 ack(每单每 stage 一行;同版本重复 ack 幂等不刷时间)。stage 决定 notice_version。
+ *  版本升级可刷新(审计 P0 修):披露文本 bump 后旧版本 ack 失效(disclosureStageAcked 按当前版本判),此前
+ *  INSERT OR IGNORE 会让重新确认【静默 no-op】(行永远停在旧版本)→ POST 返回 ok 但 requireBothDisclosuresAcked
+ *  永远 403,在途单不可恢复地变砖。现改 upsert:版本不同才覆盖(notice_version+acked_at 同步刷新为新确认时刻)。 */
 export function recordDisclosureAck(db, args) {
-    db.prepare(`INSERT OR IGNORE INTO direct_pay_disclosure_acks (id, order_id, buyer_id, stage, notice_version, acked_at)
-    VALUES (?, ?, ?, ?, ?, datetime('now'))`).run(args.ackId, args.orderId, args.buyerId, args.stage, STAGE_VERSION[args.stage]);
+    db.prepare(`INSERT INTO direct_pay_disclosure_acks (id, order_id, buyer_id, stage, notice_version, acked_at)
+    VALUES (?, ?, ?, ?, ?, datetime('now'))
+    ON CONFLICT(order_id, stage) DO UPDATE SET notice_version = excluded.notice_version, acked_at = excluded.acked_at
+    WHERE excluded.notice_version != direct_pay_disclosure_acks.notice_version`)
+        .run(args.ackId, args.orderId, args.buyerId, args.stage, STAGE_VERSION[args.stage]);
 }
 /** 某 stage 是否已 ack(且版本为当前)。 */
 export function disclosureStageAcked(db, orderId, stage) {

package/dist/direct-pay-fee-ar.js

@@ -8,9 +8,9 @@ export function feeUnitsForOrder(totalAmountU, source) {
 }
 /** 开放(未完全关闭、仍会 accrue 费)的 direct_p2p 单状态。完成单已在 receivables(借记预充值),故【不含】completed/终态。 */
 export const OPEN_FEE_ACCRUING_STATUSES = [
-    'created', 'direct_pay_window', 'direct_expired_unconfirmed',
+    'created', 'pending_accept', 'direct_pay_window', 'direct_expired_unconfirmed',
     'accepted', 'shipped', 'picked_up', 'in_transit', 'delivered', 'confirmed', 'disputed',
-];
+]; // pending_accept(手动接单待确认)保守计入在途:未接单也占预估费口径,防开一堆待接单绕过预充值门
 /** 某 SUM 查询结果 → units(空表/NULL → 0)。SUM 的是整数 units 值存成的 REAL,toUnits 精确还原。 */
 function sumUnits(db, sql, sellerId) {
     const row = db.prepare(sql).get(sellerId);