@bolloon/bolloon-agent 0.4.12 → 0.4.13

package/dist/agents/agent-service-client.js

@@ -30,12 +30,38 @@ export async function serviceCall(opts) {
     // 3. 调服务 (x402 自动支付: 402 → 签名 → 重试)
     try {
         const { x402Fetch } = await import('./x402/x402Pay.js');
+        // 2026-08-13: YAML 验证门 (不全部交给 AI) — 支付前先过 payment-policy.yaml 规则链
+        const { getPaymentGate } = await import('./payment-gate.js');
+        const gate = getPaymentGate();
+        const amount = parseFloat(service.service?.price?.amount || '0');
+        const gateVerdict = gate.evaluate({ service: service.service?.name, amount, recipient: service.wallet });
+        if (gateVerdict.decision === 'deny') {
+            return { success: false, error: `[payment-gate] ${gateVerdict.reason}`, service };
+        }
+        if (gateVerdict.decision === 'confirm') {
+            // 2026-08-13: 人工审批 — 创建 pending 审批请求 (不自动执行), UI/CLI 批准后重试
+            const { getApprovalStore } = await import('./payment-approval.js');
+            const store = getApprovalStore();
+            const approval = await store.create({
+                service: service.service?.name || serviceName,
+                amount,
+                recipient: service.wallet,
+                reason: gateVerdict.reason,
+                retryPayload: { serviceName, args, privateKey, maxPaymentAmount: maxPaymentAmount || service.service?.price?.amount },
+            });
+            return {
+                success: false,
+                error: `[payment-gate] 需人工确认: ${gateVerdict.reason} (approval=${approval.id}, 批准后自动执行)`,
+                service,
+                requiresApproval: true,
+                approvalId: approval.id,
+            };
+        }
         // Phase E3: Policy Engine 授权 (预算/白名单) — 通过才允许自动支付
         let effectiveKey = privateKey;
         if (privateKey) {
             const { getEconomicPolicy } = await import('./economic-policy.js');
             const policy = getEconomicPolicy();
-            const amount = parseFloat(service.service?.price?.amount || '0');
             const decision = await policy.check({
                 payTo: service.wallet,
                 amount,

package/dist/agents/payment-approval.js

@@ -0,0 +1,142 @@
+/**
+ * payment-approval.ts — 人工支付审批 (2026-08-13)
+ *
+ * YAML 支付验证门 (payment-gate) 判定 confirm 的支付请求 → 进入人工审批流程:
+ *   - createApproval: 创建 pending 审批请求 (持久化)
+ *   - approve(id): 人工批准 → 自动重试支付 (executor)
+ *   - reject(id): 人工拒绝
+ *   - list/pending: 查询
+ *
+ * 持久化: ~/.bolloon/payment-approvals.json
+ * 审批后执行: 注入 executor (serviceCall 重试 / 链上支付), 由调用方提供.
+ */
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+const home = () => process.env.HOME || os.homedir() || '/tmp';
+let _executor = null;
+/** 注入批准后执行器 (serviceCall 重试 / 链上支付) */
+export function setApprovalExecutor(fn) {
+    _executor = fn;
+}
+export class PaymentApprovalStore {
+    file;
+    approvals = [];
+    constructor(file = path.join(home(), '.bolloon', 'payment-approvals.json')) {
+        this.file = file;
+    }
+    async load() {
+        try {
+            const raw = JSON.parse(await fs.readFile(this.file, 'utf-8'));
+            if (Array.isArray(raw))
+                this.approvals = raw;
+        }
+        catch {
+            this.approvals = [];
+        }
+    }
+    async persist() {
+        try {
+            await fs.mkdir(path.dirname(this.file), { recursive: true });
+            await fs.writeFile(this.file, JSON.stringify(this.approvals, null, 2), 'utf-8');
+        }
+        catch { /* 静默 */ }
+    }
+    /** 创建审批请求 (pending) */
+    async create(req) {
+        await this.load();
+        const approval = {
+            id: `pay-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+            service: req.service,
+            amount: req.amount,
+            recipient: req.recipient,
+            reason: req.reason,
+            status: 'pending',
+            createdAt: Date.now(),
+            retryPayload: req.retryPayload,
+        };
+        this.approvals.push(approval);
+        await this.persist();
+        return approval;
+    }
+    /** 待审批列表 */
+    async pending() {
+        await this.load();
+        return this.approvals.filter((a) => a.status === 'pending');
+    }
+    /** 全部 (含历史) */
+    async list() {
+        await this.load();
+        return [...this.approvals].reverse();
+    }
+    async get(id) {
+        await this.load();
+        return this.approvals.find((a) => a.id === id) ?? null;
+    }
+    /**
+     * 人工批准 → 执行支付 (executor) → executed/failed.
+     * 未注入 executor 时直接标记 approved (调用方自行处理).
+     */
+    async approve(id, approver = 'user') {
+        await this.load();
+        const a = this.approvals.find((x) => x.id === id);
+        if (!a)
+            return { ok: false, error: `审批 ${id} 不存在` };
+        if (a.status !== 'pending')
+            return { ok: false, error: `审批 ${id} 状态 ${a.status}, 不可批准` };
+        a.status = 'approved';
+        a.decidedAt = Date.now();
+        await this.persist();
+        // 批准后执行支付
+        if (_executor) {
+            const r = await _executor(a);
+            a.status = r.ok ? 'executed' : 'failed';
+            a.result = r.ok ? r.result : r.error;
+            await this.persist();
+            if (!r.ok)
+                return { ok: false, approval: a, error: r.error };
+        }
+        return { ok: true, approval: a };
+    }
+    /** 人工拒绝 */
+    async reject(id, approver = 'user') {
+        await this.load();
+        const a = this.approvals.find((x) => x.id === id);
+        if (!a)
+            return { ok: false, error: `审批 ${id} 不存在` };
+        if (a.status !== 'pending')
+            return { ok: false, error: `审批 ${id} 状态 ${a.status}, 不可拒绝` };
+        a.status = 'rejected';
+        a.decidedAt = Date.now();
+        await this.persist();
+        return { ok: true, approval: a };
+    }
+    /** 清理过期 pending (超时自动标记 rejected) */
+    async expireStale(timeoutMs = 60 * 60 * 1000) {
+        await this.load();
+        const now = Date.now();
+        let expired = 0;
+        for (const a of this.approvals) {
+            if (a.status === 'pending' && now - a.createdAt > timeoutMs) {
+                a.status = 'rejected';
+                a.decidedAt = now;
+                a.result = '审批超时自动拒绝';
+                expired++;
+            }
+        }
+        if (expired > 0)
+            await this.persist();
+        return expired;
+    }
+}
+let _store = null;
+/** 单例 */
+export function getApprovalStore() {
+    if (!_store)
+        _store = new PaymentApprovalStore();
+    return _store;
+}
+export function resetApprovalStore() {
+    _store = null;
+    _executor = null;
+}

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

@@ -2446,6 +2446,65 @@ export function registerBuiltinTools(ctx) {
             }
         },
     });
+    // 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 {

package/dist/web/server.js

@@ -2811,6 +2811,66 @@ ${goalDesc}
             res.status(500).json({ error: e?.message });
         }
     });
+    // 2026-08-13: 人工支付审批 API — YAML 验证门 confirm 的支付请求
+    app.get('/api/payments/pending', async (_req, res) => {
+        try {
+            const { getApprovalStore } = await import('../agents/payment-approval.js');
+            const approvals = await getApprovalStore().pending();
+            res.json({ approvals });
+        }
+        catch (e) {
+            res.status(500).json({ error: e?.message });
+        }
+    });
+    app.get('/api/payments', async (_req, res) => {
+        try {
+            const { getApprovalStore } = await import('../agents/payment-approval.js');
+            const approvals = await getApprovalStore().list();
+            res.json({ approvals });
+        }
+        catch (e) {
+            res.status(500).json({ error: e?.message });
+        }
+    });
+    app.post('/api/payments/:id/approve', async (req, res) => {
+        try {
+            const { getApprovalStore, setApprovalExecutor } = await import('../agents/payment-approval.js');
+            const store = getApprovalStore();
+            // 批准后执行: 重试 serviceCall (带 retryPayload)
+            setApprovalExecutor(async (approval) => {
+                const payload = approval.retryPayload;
+                if (!payload)
+                    return { ok: false, error: '无重试载荷' };
+                const { serviceCall } = await import('../agents/agent-service-client.js');
+                const r = await serviceCall({
+                    serviceName: payload.serviceName,
+                    args: payload.args,
+                    privateKey: payload.privateKey,
+                    maxPaymentAmount: payload.maxPaymentAmount,
+                });
+                return { ok: r.success, result: r.output, error: r.error };
+            });
+            const r = await store.approve(String(req.params.id));
+            if (!r.ok)
+                return res.status(400).json({ error: r.error });
+            res.json({ ok: true, approval: r.approval });
+        }
+        catch (e) {
+            res.status(500).json({ error: e?.message });
+        }
+    });
+    app.post('/api/payments/:id/reject', async (req, res) => {
+        try {
+            const { getApprovalStore } = await import('../agents/payment-approval.js');
+            const r = await getApprovalStore().reject(String(req.params.id));
+            if (!r.ok)
+                return res.status(400).json({ error: r.error });
+            res.json({ ok: true, approval: r.approval });
+        }
+        catch (e) {
+            res.status(500).json({ error: e?.message });
+        }
+    });
     // 2026-08-12: MCP 工具列表 (MCP 前端支持 — 手机端/桌面 UI 展示可用 MCP 工具)
     app.get('/api/mcp/tools', async (_req, res) => {
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bolloon/bolloon-agent",
-  "version": "0.4.12",
+  "version": "0.4.13",
   "type": "module",
   "description": "P2P AI Document Agent - 全局安装后执行 `bolloon` 启动产品",
   "main": "dist/cli-entry.js",
@@ -101,6 +101,7 @@
     "helia": "^7.1.3",
     "ink": "^7.1.1",
     "ink-text-input": "^6.0.0",
+    "js-yaml": "^5.2.3",
     "libp2p": "^3.3.8",
     "mammoth": "^1.12.1",
     "pdf-parse": "^2.4.5",