@bolloon/bolloon-agent 0.4.11 → 0.4.13

package/dist/agents/payment-gate.js

@@ -0,0 +1,99 @@
+/**
+ * payment-gate.ts — YAML 驱动的支付验证门 (2026-08-13)
+ *
+ * 用户要求: 智能体支付不能全部交给 AI, 需要 YAML 验证流程.
+ * 设计 (参考 Hermes write_approval 配置驱动 + arXiv:2605.30998):
+ *   - payment-policy.yaml 声明式规则 (allow/confirm/deny)
+ *   - 支付请求按规则链逐条匹配 → decision
+ *   - deny 不可覆盖; confirm 返回 pending 等待人工审批 (不自动执行)
+ *
+ * 加载: ~/.bolloon/payment-policy.yaml (不存在则用内置默认 payment-policy.yaml)
+ */
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import * as yaml from 'js-yaml';
+const home = () => process.env.HOME || os.homedir() || '/tmp';
+/** 支付验证门: 加载 YAML 并评估 */
+export class PaymentGate {
+    policy = null;
+    policyPath;
+    constructor(policyPath = path.join(home(), '.bolloon', 'payment-policy.yaml')) {
+        this.policyPath = policyPath;
+    }
+    /** 加载 YAML (本地文件优先, 否则内置默认) */
+    load() {
+        if (this.policy)
+            return this.policy;
+        const candidates = [
+            this.policyPath,
+            path.resolve(process.cwd(), 'src/agents/payment-policy.yaml'),
+        ];
+        for (const f of candidates) {
+            try {
+                if (fs.existsSync(f)) {
+                    this.policy = yaml.load(fs.readFileSync(f, 'utf-8'));
+                    return this.policy;
+                }
+            }
+            catch { /* 下一个 */ }
+        }
+        this.policy = { default_action: 'confirm', default_reason: '未命中任何支付规则, 需要人工确认' };
+        return this.policy;
+    }
+    /**
+     * 评估支付请求 (按规则链, 顺序匹配第一条命中).
+     * 流程: 硬限制 (超限即 deny) → 规则链 (allow/confirm/deny) → 默认.
+     */
+    evaluate(intent) {
+        const p = this.load();
+        const service = String(intent.service || '').toLowerCase();
+        const recipient = String(intent.recipient || '').toLowerCase();
+        const amount = Number(intent.amount) || 0;
+        const limits = {
+            maxPerTransaction: p.limits?.max_per_transaction ?? 1,
+            maxDailyTotal: p.limits?.max_daily_total ?? 10,
+        };
+        // 0. 硬限制: 超单笔/日限 → deny (无论规则)
+        if (amount > limits.maxPerTransaction) {
+            return { decision: 'deny', reason: `单笔超限: ${amount} > ${limits.maxPerTransaction}`, requiresApproval: false, limits };
+        }
+        // 1. 规则链 (顺序匹配)
+        for (const rule of p.rules ?? []) {
+            const matchesService = !rule.services || rule.services.some((s) => s.toLowerCase() === service);
+            const matchesRecipient = !rule.recipients || rule.recipients.some((r) => r.toLowerCase() === recipient);
+            const matchesAmount = rule.max_amount === undefined || amount <= rule.max_amount;
+            if (matchesService && matchesRecipient && matchesAmount) {
+                return {
+                    decision: rule.action,
+                    reason: rule.reason || rule.description || `规则 ${rule.id} 命中`,
+                    ruleId: rule.id,
+                    requiresApproval: rule.action === 'confirm',
+                    limits,
+                };
+            }
+        }
+        // 2. 默认
+        return {
+            decision: p.default_action ?? 'confirm',
+            reason: p.default_reason || '默认: 需人工确认',
+            requiresApproval: (p.default_action ?? 'confirm') === 'confirm',
+            limits,
+        };
+    }
+    /** 快捷: 是否允许 (allow = true; confirm/deny = false 且不自动) */
+    isAllowed(intent) {
+        const v = this.evaluate(intent);
+        return { allowed: v.decision === 'allow', verdict: v };
+    }
+}
+let _gate = null;
+/** 单例 */
+export function getPaymentGate() {
+    if (!_gate)
+        _gate = new PaymentGate();
+    return _gate;
+}
+export function resetPaymentGate() {
+    _gate = null;
+}

package/dist/agents/pi-sdk-tools.js

@@ -2262,6 +2262,249 @@ export function registerBuiltinTools(ctx) {
         }
         catch { /* A2UI 工具注册失败静默 */ }
     })();
+    // 2026-08-13 (Phase E1): Agent 服务 Registry — 注册/发现服务 (Agent Economic Network Discovery 层)
+    (async () => {
+        try {
+            const registry = await import('../agents/agent-registry.js');
+            // 注册自己为服务提供者
+            ctx.tools.set('registry_register', {
+                name: 'registry_register',
+                description: '在 Agent 服务注册表注册自己的服务 (定价/能力/钱包). 让其他 Agent 能发现并调用你. 参数: service_name(如 research), description, price_amount, price_currency(USDC), price_per(如 query), capabilities(数组), wallet(收款地址)',
+                parameters: {
+                    service_name: '服务名 (必填, 如 research/coding/data)',
+                    description: '服务描述 (必填)',
+                    price_amount: '单价金额 (必填, 如 0.05)',
+                    price_currency: '计价币种 (默认 USDC)',
+                    price_per: '计价单位 (默认 query)',
+                    capabilities: '能力数组 (可选)',
+                    wallet: '收款钱包地址 (必填)',
+                },
+                execute: async (args) => {
+                    const serviceName = String(args.service_name || '').trim();
+                    const wallet = String(args.wallet || '').trim();
+                    if (!serviceName || !wallet)
+                        return { success: false, error: 'service_name 和 wallet 必填' };
+                    const reg = registry.getAgentRegistry();
+                    const r = await reg.register({
+                        agentId: ctx.identity?.did || `did:local:${ctx.identity?.name || 'agent'}`,
+                        name: ctx.identity?.name || 'agent',
+                        wallet,
+                        service: {
+                            name: serviceName,
+                            description: String(args.description || `${serviceName} 服务`).trim(),
+                            price: {
+                                amount: String(args.price_amount || '0'),
+                                currency: String(args.price_currency || 'USDC').toUpperCase(),
+                                per: String(args.price_per || 'query'),
+                            },
+                        },
+                        capabilities: Array.isArray(args.capabilities) ? args.capabilities.map(String) : [serviceName],
+                    });
+                    return r.ok
+                        ? { success: true, output: `✅ 已注册服务: ${serviceName} (${args.price_amount || 0} ${String(args.price_currency || 'USDC').toUpperCase()}/${args.price_per || 'query'}) wallet=${wallet.slice(0, 10)}...` }
+                        : { success: false, error: r.error };
+                },
+            });
+            // 发现可用的 Agent 服务
+            ctx.tools.set('registry_discover', {
+                name: 'registry_discover',
+                description: '在 Agent 服务注册表发现服务 (按名称/能力/描述). 找到服务后可用 x402 支付调用. query: 搜索词 (如 research/compute/data).',
+                parameters: { query: '搜索词 (可选, 空=列出全部)' },
+                execute: async (args) => {
+                    const q = String(args.query || '').trim();
+                    const reg = registry.getAgentRegistry();
+                    const services = await reg.discover(q);
+                    if (services.length === 0)
+                        return { success: true, output: '(注册表无匹配服务)' };
+                    const lines = services.slice(0, 20).map((s) => `  [${s.service.name}] ${s.name} (${s.service.price.amount} ${s.service.price.currency}/${s.service.price.per}) wallet=${String(s.wallet).slice(0, 12)}... agent=${s.agentId.slice(0, 24)}...`);
+                    return { success: true, output: `发现 ${services.length} 个服务:\n${lines.join('\n')}` };
+                },
+            });
+        }
+        catch { /* registry 工具注册失败静默 */ }
+    })();
+    // 2026-08-13 (Phase E2): service_call — 调用 Agent 服务 (x402 402 自动支付闭环)
+    ctx.tools.set('service_call', {
+        name: 'service_call',
+        description: '调用注册表里的 Agent 服务 (x402 支付闭环). 从 registry_discover 找到服务名后调用. service_name: 服务名; args: 服务参数; 有钱包私钥时自动支付 402.',
+        parameters: {
+            service_name: '服务名 (必填, registry_discover 查到的)',
+            args: '服务参数 JSON (可选)',
+            max_payment_amount: '最大支付金额 (可选)',
+        },
+        execute: async (args) => {
+            const serviceName = String(args.service_name || '').trim();
+            if (!serviceName)
+                return { success: false, error: 'service_name 必填 (先用 registry_discover 查)' };
+            try {
+                const { serviceCall } = await import('./agent-service-client.js');
+                // 尝试取 channel 钱包私钥 (autoPay)
+                let privateKey;
+                try {
+                    const wallet = await ctx.getChannelWallet?.();
+                    if (wallet?.encryptedPrivateKey)
+                        privateKey = wallet.encryptedPrivateKey;
+                }
+                catch { /* 无钱包 */ }
+                let argsObj = {};
+                try {
+                    argsObj = JSON.parse(String(args.args || '{}'));
+                }
+                catch {
+                    argsObj = {};
+                }
+                const r = await serviceCall({
+                    serviceName,
+                    args: argsObj,
+                    privateKey,
+                    maxPaymentAmount: String(args.max_payment_amount || '').trim() || undefined,
+                });
+                if (!r.success)
+                    return { success: false, error: r.error, service: r.service?.service?.name };
+                return { success: true, output: r.output, paid: r.paid, txHash: r.txHash };
+            }
+            catch (e) {
+                return { success: false, error: `service_call 失败: ${String(e?.message || e).slice(0, 200)}` };
+            }
+        },
+    });
+    // 2026-08-13 (Phase E3): Policy Engine — 预算/授权 (安全核心, 私钥不暴露给 LLM)
+    ctx.tools.set('policy_config', {
+        name: 'policy_config',
+        description: '查看/更新支付策略 (预算/白名单). LLM 只能查看预算与授权规则, 私钥由 Policy Engine 隔离保管. 查看: 无参数; 更新: 传要改的字段 (per_transaction_limit/daily_limit/allowed_recipients/allowed_services).',
+        parameters: {
+            per_transaction_limit: '可选: 单笔上限 (数字)',
+            daily_limit: '可选: 每日预算 (数字)',
+            allowed_recipients: '可选: 允许收款方数组',
+            allowed_services: '可选: 允许服务数组',
+        },
+        execute: async (args) => {
+            try {
+                const { getEconomicPolicy } = await import('./economic-policy.js');
+                const policy = getEconomicPolicy();
+                const patch = {};
+                if (args.per_transaction_limit !== undefined)
+                    patch.perTransactionLimit = Number(args.per_transaction_limit);
+                if (args.daily_limit !== undefined)
+                    patch.dailyLimit = Number(args.daily_limit);
+                if (Array.isArray(args.allowed_recipients))
+                    patch.allowedRecipients = args.allowed_recipients.map(String);
+                if (Array.isArray(args.allowed_services))
+                    patch.allowedServices = args.allowed_services.map(String);
+                if (Object.keys(patch).length > 0)
+                    policy.updateConfig(patch);
+                const spent = await policy.dailySpent();
+                const c = policy.config();
+                return {
+                    success: true,
+                    output: `支付策略:\n  单笔上限: $${c.perTransactionLimit}\n  每日预算: $${c.dailyLimit} (今日已用 $${spent})\n  允许收款方: ${c.allowedRecipients.length ? c.allowedRecipients.join(', ') : '(全部)'}\n  允许服务: ${c.allowedServices.length ? c.allowedServices.join(', ') : '(全部)'}\n  速率: ${c.rateLimitPerMinute}/min`,
+                };
+            }
+            catch (e) {
+                return { success: false, error: `policy_config 失败: ${String(e?.message || e).slice(0, 200)}` };
+            }
+        },
+    });
+    // 2026-08-13 (Phase M4): Reputation — 服务结果记录 + 信誉查询 (Agent Economic Protocol §7)
+    ctx.tools.set('reputation_update', {
+        name: 'reputation_update',
+        description: '记录一次服务结果, 更新服务提供者的信誉 (success/failed/disputed → score). 服务完成后调用. agent_id: 服务提供者 DID; service_name: 服务名; outcome: success|failed|disputed.',
+        parameters: { agent_id: '服务提供者 agent_id (必填)', service_name: '服务名 (必填)', outcome: '结果: success|failed|disputed (必填)' },
+        execute: async (args) => {
+            try {
+                const { recordServiceOutcome } = await import('./agent-reputation.js');
+                const agentId = String(args.agent_id || '').trim();
+                const serviceName = String(args.service_name || '').trim();
+                const outcome = String(args.outcome || '').trim();
+                if (!agentId || !serviceName || !['success', 'failed', 'disputed'].includes(outcome)) {
+                    return { success: false, error: 'agent_id/service_name/outcome(success|failed|disputed) 必填' };
+                }
+                const r = await recordServiceOutcome(agentId, serviceName, outcome);
+                if (!r.ok)
+                    return { success: false, error: r.error };
+                return { success: true, output: `✅ 已记录 ${outcome}: tasks=${r.reputation?.tasks}, score=${r.reputation?.score}` };
+            }
+            catch (e) {
+                return { success: false, error: `reputation_update 失败: ${String(e?.message || e).slice(0, 200)}` };
+            }
+        },
+    });
+    ctx.tools.set('reputation_query', {
+        name: 'reputation_query',
+        description: '查询 Agent 的信誉 (成功率/任务数). agent_id: 服务提供者 DID; service_name: 可选. 选择服务前先查信誉.',
+        parameters: { agent_id: '服务提供者 agent_id (必填)', service_name: '服务名 (可选)' },
+        execute: async (args) => {
+            try {
+                const { queryReputation, formatReputation } = await import('./agent-reputation.js');
+                const r = await queryReputation(String(args.agent_id || '').trim(), String(args.service_name || '').trim() || undefined);
+                if (!r.ok)
+                    return { success: true, output: r.error || '(无信誉记录)' };
+                return { success: true, output: r.entries.map((e) => `  [${e.service}] ${formatReputation(e.reputation)}`).join('\n') };
+            }
+            catch (e) {
+                return { success: false, error: `reputation_query 失败: ${String(e?.message || e).slice(0, 200)}` };
+            }
+        },
+    });
+    // 2026-08-13: Treasury 桥 — 链下结算 (Policy/Registry) 驱动链上 Treasury.payAgent
+    //   配置: BOLLOON_TREASURY_RPC / BOLLOON_TREASURY_ADDRESS / BOLLOON_TREASURY_KEY / BOLLOON_TREASURY_TOKEN
+    const treasuryConfigFromEnv = () => {
+        const rpcUrl = process.env.BOLLOON_TREASURY_RPC || '';
+        const treasuryAddress = process.env.BOLLOON_TREASURY_ADDRESS || '';
+        const tokenAddress = process.env.BOLLOON_TREASURY_TOKEN || '';
+        const privateKey = process.env.BOLLOON_TREASURY_KEY || '';
+        return { rpcUrl, treasuryAddress, tokenAddress, privateKey };
+    };
+    ctx.tools.set('treasury_pay', {
+        name: 'treasury_pay',
+        description: '从 Treasury 支付给 Agent (链上 AgentTreasury.payAgent). 自动过 Policy 预算校验 + 信誉门槛 (链上). agent_address: 收款 Agent 地址; amount: 金额 (USDC). 需配置 BOLLOON_TREASURY_* 环境变量 (RPC/合约/私钥).',
+        parameters: { agent_address: '收款 Agent 钱包地址 (必填)', amount: '金额 USDC (必填)', service: '服务名 (可选, Policy 校验用)' },
+        execute: async (args) => {
+            const cfg = treasuryConfigFromEnv();
+            if (!cfg.rpcUrl || !cfg.treasuryAddress || !cfg.privateKey) {
+                return { success: false, error: '未配置 Treasury (BOLLOON_TREASURY_RPC/ADDRESS/KEY/TOKEN)' };
+            }
+            const agentAddress = String(args.agent_address || '').trim();
+            const amount = Number(args.amount);
+            if (!agentAddress || !amount || amount <= 0)
+                return { success: false, error: 'agent_address 和 amount(>0) 必填' };
+            try {
+                const { treasuryPay } = await import('./treasury-bridge.js');
+                const r = await treasuryPay(cfg, {
+                    agentAddress,
+                    amount,
+                    service: String(args.service || '').trim() || undefined,
+                });
+                if (!r.success)
+                    return { success: false, error: r.error };
+                return { success: true, output: `✅ Treasury 已支付 ${amount} USDC → ${agentAddress.slice(0, 10)}... tx=${r.txHash}` };
+            }
+            catch (e) {
+                return { success: false, error: `treasury_pay 失败: ${String(e?.message || e).slice(0, 200)}` };
+            }
+        },
+    });
+    ctx.tools.set('treasury_status', {
+        name: 'treasury_status',
+        description: '查询 Treasury 状态 (余额/日限/冻结). 需配置 BOLLOON_TREASURY_* 环境变量.',
+        parameters: {},
+        execute: async () => {
+            const cfg = treasuryConfigFromEnv();
+            if (!cfg.rpcUrl || !cfg.treasuryAddress) {
+                return { success: false, error: '未配置 Treasury (BOLLOON_TREASURY_RPC/ADDRESS)' };
+            }
+            try {
+                const { treasuryStatus } = await import('./treasury-bridge.js');
+                const s = await treasuryStatus(cfg);
+                if (!s.ok)
+                    return { success: false, error: s.error };
+                return { success: true, output: `Treasury:\n  余额: ${s.balance} USDC\n  日限: ${s.dailyLimit} USDC\n  冻结: ${s.frozen ? '是' : '否'}` };
+            }
+            catch (e) {
+                return { success: false, error: `treasury_status 失败: ${String(e?.message || e).slice(0, 200)}` };
+            }
+        },
+    });
     // ============================================================
     // publish_did (2026-08-03) — 把当前 agent 的 DID 发布到 IPFS + IPNS
     // 全自动: 自动安装/启动本地 Kubo → 上传 DID 文档 → 发布 IPNS name

package/dist/agents/treasury-bridge.js

@@ -0,0 +1,127 @@
+/**
+ * treasury-bridge.ts — Treasury 合约 × Agent 经济网络桥接 (2026-08-13)
+ *
+ * 打通: 链下结算逻辑 (Registry 服务/Policy 授权/Reputation 门槛) → 链上 Treasury.payAgent.
+ *
+ * 流程:
+ *   registry 服务完成 → reputation_update(success) → treasuryPay(agent, amount)
+ *     ├─ 链下校验: Policy (预算) + Registry (服务价格) + Reputation (≥60)
+ *     └─ 链上执行: AgentTreasury.payAgent(agent, amount)
+ *
+ * 合约 ABI 用最小接口 (viem writeContract), 支持任意部署地址 + RPC.
+ * 真实链上需部署 AgentTreasury + 注入 owner 私钥; 测试注入 mock.
+ */
+/** Treasury 合约最小 ABI (payAgent/deposit/balance/dailySpend/frozen) */
+const TREASURY_ABI = [
+    {
+        name: 'payAgent',
+        type: 'function',
+        stateMutability: 'nonpayable',
+        inputs: [
+            { name: 'agent', type: 'address' },
+            { name: 'amount', type: 'uint256' },
+        ],
+        outputs: [],
+    },
+    {
+        name: 'deposit',
+        type: 'function',
+        stateMutability: 'nonpayable',
+        inputs: [{ name: 'amount', type: 'uint256' }],
+        outputs: [],
+    },
+    {
+        name: 'balance',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [],
+        outputs: [{ name: '', type: 'uint256' }],
+    },
+    {
+        name: 'frozen',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [],
+        outputs: [{ name: '', type: 'bool' }],
+    },
+    {
+        name: 'dailyLimit',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [],
+        outputs: [{ name: '', type: 'uint256' }],
+    },
+];
+/**
+ * 链下校验 → 链上 Treasury.payAgent.
+ * 校验链: Policy (预算/白名单) → 合约调用.
+ */
+export async function treasuryPay(config, opts) {
+    const { agentAddress, amount, service } = opts;
+    // 1. Policy 授权 (预算/白名单) — 链下, 防无预算支付
+    if (opts.policyCheck) {
+        const decision = await opts.policyCheck({ payTo: agentAddress, amount, service: service || 'treasury-pay' });
+        if (!decision.allowed) {
+            return { success: false, error: `[policy] ${decision.reason}`, checks: { policy: decision } };
+        }
+    }
+    else {
+        try {
+            const { getEconomicPolicy } = await import('./economic-policy.js');
+            const policy = getEconomicPolicy();
+            const decision = await policy.check({ payTo: agentAddress, amount, service: service || 'treasury-pay' });
+            if (!decision.allowed) {
+                return { success: false, error: `[policy] ${decision.reason}`, checks: { policy: decision } };
+            }
+        }
+        catch { /* policy 不可用放行 */ }
+    }
+    // 2. 链上 payAgent (dryRun: 只验证 policy 门, 不真实上链)
+    if (opts.dryRun) {
+        return { success: true, txHash: 'dry-run:0x0', checks: { policy: { allowed: true } }, dryRun: true };
+    }
+    try {
+        const { createWalletClient, http, parseUnits } = await import('viem');
+        const { privateKeyToAccount } = await import('viem/accounts');
+        const { base, baseSepolia } = await import('viem/chains');
+        const decimals = config.decimals ?? 6;
+        const account = privateKeyToAccount(config.privateKey);
+        const chain = config.rpcUrl.includes('sepolia') ? baseSepolia : base;
+        const client = createWalletClient({ account, chain, transport: http(config.rpcUrl) });
+        const txHash = await client.writeContract({
+            address: config.treasuryAddress,
+            abi: TREASURY_ABI,
+            functionName: 'payAgent',
+            args: [agentAddress, parseUnits(String(amount), decimals)],
+        });
+        // 记录花费 (链下日预算镜像)
+        try {
+            const { getEconomicPolicy } = await import('./economic-policy.js');
+            await getEconomicPolicy().recordSpend(amount).catch(() => { });
+        }
+        catch { /* 静默 */ }
+        return { success: true, txHash, checks: { policy: { allowed: true } } };
+    }
+    catch (e) {
+        return { success: false, error: `Treasury.payAgent 失败: ${String(e?.message || e).slice(0, 200)}` };
+    }
+}
+/** 查询 Treasury 状态 (余额/日限/冻结) */
+export async function treasuryStatus(config) {
+    try {
+        const { createPublicClient, http, formatUnits } = await import('viem');
+        const { base, baseSepolia } = await import('viem/chains');
+        const chain = config.rpcUrl.includes('sepolia') ? baseSepolia : base;
+        const client = createPublicClient({ chain, transport: http(config.rpcUrl) });
+        const decimals = config.decimals ?? 6;
+        const [bal, limit, frozen] = await Promise.all([
+            client.readContract({ address: config.treasuryAddress, abi: TREASURY_ABI, functionName: 'balance' }),
+            client.readContract({ address: config.treasuryAddress, abi: TREASURY_ABI, functionName: 'dailyLimit' }),
+            client.readContract({ address: config.treasuryAddress, abi: TREASURY_ABI, functionName: 'frozen' }),
+        ]);
+        return { ok: true, balance: formatUnits(bal, decimals), dailyLimit: formatUnits(limit, decimals), frozen: frozen };
+    }
+    catch (e) {
+        return { ok: false, error: `Treasury 状态查询失败: ${String(e?.message || e).slice(0, 200)}` };
+    }
+}

package/dist/index.js

@@ -1333,6 +1333,48 @@ async function processInput(input, comm) {
         }
         return;
     }
+    // /payments [/approve <id> /reject <id>] — 人工支付审批 (2026-08-13)
+    //   YAML 验证门判定 confirm 的支付请求 → 这里人工批准/拒绝
+    if (cmd === '/payments' || cmd.startsWith('/payments ') || cmd.startsWith('/approve ') || cmd.startsWith('/reject ')) {
+        try {
+            const { getApprovalStore } = await import('./agents/payment-approval.js');
+            const store = getApprovalStore();
+            if (cmd.startsWith('/approve ')) {
+                const id = cmd.slice('/approve '.length).trim();
+                const r = await store.approve(id);
+                if (!r.ok) {
+                    appendLine(`${C_ERROR}${r.error}${RESET}`);
+                    return;
+                }
+                appendLine(`${C_OK}✓ 已批准 ${id} → ${r.approval?.status}${r.approval?.result ? ` (${String(r.approval.result).slice(0, 80)})` : ''}${RESET}`);
+                return;
+            }
+            if (cmd.startsWith('/reject ')) {
+                const id = cmd.slice('/reject '.length).trim();
+                const r = await store.reject(id);
+                if (!r.ok) {
+                    appendLine(`${C_ERROR}${r.error}${RESET}`);
+                    return;
+                }
+                appendLine(`${C_WARN}✗ 已拒绝 ${id}${RESET}`);
+                return;
+            }
+            const approvals = await store.pending();
+            appendLine(`${C_ACCENT}待人工审批支付 (${approvals.length}):${RESET}`);
+            if (approvals.length === 0) {
+                appendLine(`  ${C_DIM}无待审批 — YAML 验证门 allow/deny 已自动处理${RESET}`);
+            }
+            for (const a of approvals) {
+                appendLine(`  ${C_WARN}⏳${RESET} ${C_ACCENT}${a.id}${RESET} ${a.service} $${a.amount} → ${String(a.recipient).slice(0, 12)}...`);
+                appendLine(`    ${C_DIM}${a.reason}${RESET}`);
+                appendLine(`    ${C_DIM}/approve ${a.id} | /reject ${a.id}${RESET}`);
+            }
+        }
+        catch (e) {
+            appendLine(`${C_ERROR}/payments 失败: ${String(e?.message || e).slice(0, 120)}${RESET}`);
+        }
+        return;
+    }
     // /skill — 技能候选 (skill-writer 落盘)
     if (cmd === '/skill') {
         try {

package/dist/web/mobile.html

@@ -36,6 +36,8 @@
       </div>
       <div class="section-label">MCP 工具 (触控调用)</div>
       <div class="list" id="mcp-tools"></div>
+      <div class="section-label">待人工审批支付</div>
+      <div class="list" id="approval-list"></div>
       <div class="section-label">A2UI 动态面板 (智能体生成)</div>
       <div id="a2ui-root"></div>
     </section>

package/dist/web/mobile.js

@@ -44,7 +44,7 @@
     $$('.page').forEach((p) => { p.hidden = p.dataset.tab !== tab; });
     $$('.tab').forEach((t) => t.classList.toggle('active', t.dataset.tab === tab));
     $('#topbar-title').textContent = TITLES[tab] || '微信';
-    if (tab === 'discover') loadMcpTools();
+    if (tab === 'discover') { loadMcpTools(); loadApprovals(); }
     window.__mobileTouch?.('tab', tab);
   }
   $$('.tab').forEach((t) => t.addEventListener('click', () => switchTab(t.dataset.tab)));
@@ -307,6 +307,43 @@
     // 预留: 触控事件上报/控制
   };
 
+  // === 人工支付审批 (2026-08-13): YAML 验证门 confirm 的支付请求 → 人工批准/拒绝 ===
+  async function loadApprovals() {
+    const box = $('#approval-list');
+    if (!box) return;
+    try {
+      const r = await api.get('/api/payments/pending');
+      const approvals = r.approvals || [];
+      box.innerHTML = '';
+      if (approvals.length === 0) {
+        box.innerHTML = '<div style="padding:10px 16px;color:var(--text-muted)">无待审批支付</div>';
+        return;
+      }
+      approvals.forEach((a) => {
+        const el = document.createElement('div');
+        el.className = 'conv-item';
+        el.style.flexDirection = 'column';
+        el.style.alignItems = 'flex-start';
+        el.innerHTML = `
+          <div style="width:100%"><b>${escapeHtml(a.service)}</b> $${a.amount} → ${escapeHtml(String(a.recipient).slice(0, 14))}...</div>
+          <div style="color:var(--text-muted);font-size:12px">${escapeHtml(a.reason)}</div>
+          <div style="display:flex;gap:8px;margin-top:6px">
+            <button class="approve-btn" data-id="${escapeHtml(a.id)}" style="background:var(--success,#22c55e);border:none;border-radius:6px;padding:4px 14px;color:#fff">批准</button>
+            <button class="reject-btn" data-id="${escapeHtml(a.id)}" style="background:var(--error,#ef4444);border:none;border-radius:6px;padding:4px 14px;color:#fff">拒绝</button>
+          </div>`;
+        el.querySelector('.approve-btn').addEventListener('click', async () => {
+          await api.post(`/api/payments/${a.id}/approve`, {}).catch(() => {});
+          loadApprovals();
+        });
+        el.querySelector('.reject-btn').addEventListener('click', async () => {
+          await api.post(`/api/payments/${a.id}/reject`, {}).catch(() => {});
+          loadApprovals();
+        });
+        box.appendChild(el);
+      });
+    } catch (e) { box.innerHTML = '<div style="padding:10px;color:var(--error)">审批加载失败</div>'; }
+  }
+
   // === MCP 驱动前端 UI (2026-08-12): 订阅 /events, 收到 {type:'ui'} 指令执行组件动作 ===
   function setupUiControl() {
     try {