@bolloon/bolloon-agent 0.4.26 → 0.4.28

package/dist/agents/execution-supervisor.js

@@ -203,6 +203,35 @@ export class ExecutionSupervisor {
                 this.reconciledOnce = true;
                 if (report.reconciled.interrupted.length)
                     this.log(`[supervisor] 对账: ${report.reconciled.interrupted.length} 条僵尸 run → interrupted`);
+                // 1.1 (2026-09-18, Phase 3): 支付中断对账 —— 只把结算事实钉死, **绝不代替付款方花钱**
+                try {
+                    const { reconcileInterruptedPayments } = await import('./x402/payment-recovery.js');
+                    const home = process.env.HOME || os.homedir();
+                    report.payments = await reconcileInterruptedPayments({
+                        home,
+                        reconcile: async (rec) => {
+                            // 对账依据: 记录里既有的链上证据。查真链上历史属 Phase 1 (需 RPC/facilitator), 这里不猜。
+                            if (rec.chainSettled === true && rec.txHash)
+                                return { fact: 'payment_verified', txHash: rec.txHash, note: '对账: 记录自带 txHash 与链上结算事实' };
+                            if (rec.txHash)
+                                return { fact: 'payment_verified', txHash: rec.txHash, note: '对账: 发现 txHash → 结算事实升级' };
+                            if (rec.paymentReceipt)
+                                return { fact: 'unknown', note: '有支付凭据但无 txHash → 维持 unknown, 需 facilitator 澄清 (不重付)' };
+                            return { fact: 'unpaid', note: '没有任何支付凭据 → 确认没付过 (可安全重试)' };
+                        },
+                        persist: async (transactionId, patch, event) => {
+                            const { updateTransaction } = await import('./x402/transaction-store.js');
+                            await updateTransaction(transactionId, { ...patch, event }, home);
+                        },
+                    });
+                    if (report.payments.reconciled.length || report.payments.mustNotRepay.length || report.payments.goalsWoken.length) {
+                        this.log(`[supervisor] 支付对账: ${report.payments.reconciled.length} 条已钉结算事实 · ${report.payments.mustNotRepay.length} 条绝不重付 · `
+                            + `${report.payments.awaitingPayment.length} 条等付款 · **唤醒 ${report.payments.goalsWoken.length} 个 Goal** · ${report.payments.goalsFlagged.length} 个转人工`);
+                    }
+                }
+                catch (err) {
+                    report.payments.errors.push(String(err?.message || err).slice(0, 120));
+                }
             }
             report.supervised = await superviseRuns();
             // 1.5 (2026-09-16, 2-C.4): 外部等待超时 → 明确转人工 (不允许无限等待)
@@ -256,6 +285,7 @@ export class ExecutionSupervisor {
         return {
             at: new Date().toISOString(), owner: this.owner, tick: this.tickCount,
             reconciled: { interrupted: [], stillRunning: [], failed: [] },
+            payments: { scanned: 0, reconciled: [], awaitingPayment: [], mustNotRepay: [], closed: [], goalsWoken: [], goalsFlagged: [], errors: [] },
             supervised: { stalled: [], failed: [] },
             claimed: [], executed: [], skipped: [], errors: [], dryRun: !this.runner,
         };
@@ -278,6 +308,27 @@ export class ExecutionSupervisor {
             this.emit({ kind: 'retry_woke', goalId: goal.goalId, message: `到点唤醒, 第 ${(goal.continuation?.attempts || 0) + 1} 次自动继续` });
             this.log(`[supervisor] goal=${goal.goalId} retry_wait 到点 → 唤醒并清 wakeAt`);
         }
+        // ★ 2026-09-18 (M2 收口): `bolloon task` 建的目标走**同一个恢复决策函数**
+        //   (`decideTaskRecovery`) —— CLI `task --resume` 与 Supervisor 不再各判一次。
+        //   决策说"不能动钱/已经执行过"就跳过 (不重复付款、不重复执行非幂等操作)。
+        if (goal.createdBy === 'cli:task' && process.env.BOLLOON_SUPERVISOR_TASK_RESUME !== '0') {
+            try {
+                const { decideTaskRecovery, resumeTask } = await import('./task/task-runner.js');
+                const decision = await decideTaskRecovery({ goalId: goal.goalId });
+                const actionable = ['retry_payment', 'deliver', 'verify'].includes(decision.action);
+                if (!actionable) {
+                    report.skipped.push({ goalId: goal.goalId, reason: `任务恢复决策=${decision.action} (${decision.reason}) → 本周期不动` });
+                    return { goalId: goal.goalId, status: 'task_no_action' };
+                }
+                const res = await resumeTask({ goalId: goal.goalId });
+                this.log(`[supervisor] task 目标接回: goal=${goal.goalId} decision=${decision.action} → 状态 ${res.card.status}`);
+                this.emit({ kind: res.ok ? 'goal_done' : 'needs_human', goalId: goal.goalId, message: `任务接回: ${decision.action} → ${res.card.status}` });
+                return { goalId: goal.goalId, runId: res.runId, status: res.card.status, error: res.ok ? undefined : res.reason };
+            }
+            catch (err) {
+                return { goalId: goal.goalId, status: 'task_resume_failed', error: String(err?.message || err).slice(0, 160) };
+            }
+        }
         const prevRunId = goal.currentRunId;
         const prevRun = prevRunId ? await readRun(prevRunId) : null;
         const plan = prevRunId ? await buildContinuationPlan(prevRunId).catch(() => null) : null;

package/dist/agents/p2p-info.js

@@ -0,0 +1,175 @@
+/**
+ * p2p-info.ts — 本机 P2P 连接信息出口 (2026-09-18)
+ *
+ * 目的: 把"我这台机器/这台手机怎么被别的智能体拨通"变成**一条可抄走的连接信息**
+ *   (peerId + 可拨入 multiaddr),好递给名片/交接串/对方智能体。
+ * 诚实原则: 只报真实拿到的;拿不到就说清原因与下一步,不编 peerId、不假装"能连通"。
+ */
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+function home() { return process.env.HOME || os.homedir(); }
+function readJsonSafe(p) {
+    try {
+        return JSON.parse(fs.readFileSync(p, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function readIdentity() {
+    const p = path.join(home(), '.bolloon', 'identity', 'user.json');
+    const j = readJsonSafe(p);
+    return { did: j?.did, name: j?.name };
+}
+function readGatewayJoin() {
+    return readJsonSafe(path.join(home(), '.bolloon', 'gateway-join.json'));
+}
+/** 确保地址带 /p2p/<peerId> 段 (没有就补上, 否则对端拨不通) */
+export function ensureDialable(addr, peerId) {
+    const a = String(addr || '').trim();
+    if (!a)
+        return a;
+    if (a.includes('/p2p/'))
+        return a;
+    return peerId ? `${a}/p2p/${peerId}` : a;
+}
+export async function getLocalP2pInfo() {
+    const info = { ok: false, source: 'none', multiaddrs: [], relayAddrs: [], isRelay: false };
+    const id = readIdentity();
+    info.did = id.did;
+    info.name = id.name;
+    // ① 先看本进程里节点是否真的在跑
+    try {
+        const mod = await import('../network/p2p.js');
+        const net = mod.p2pNetwork;
+        const node = net?.getNode?.();
+        if (net && node) {
+            const peerId = String(net.getNodePeerId?.() || '');
+            if (peerId) {
+                info.source = 'live';
+                info.peerId = peerId;
+                // 优先给浏览器/手机能用的 ws 地址; 没有 ws 时回退到节点真实全部地址 (不编造)
+                let raw = (net.getWsMultiaddrs?.() || []).map((m) => String(m));
+                if (!raw.length) {
+                    try {
+                        raw = (node.getMultiaddrs?.() || []).map((m) => String(m));
+                    }
+                    catch {
+                        raw = [];
+                    }
+                }
+                info.multiaddrs = raw.map((m) => ensureDialable(m, peerId));
+                try {
+                    const ra = (net.getRelayAddrs?.() || []).map((m) => String(m));
+                    info.relayAddrs = ra.map((m) => ensureDialable(m, peerId));
+                }
+                catch { /* 没有中继也能继续 */ }
+                try {
+                    const svc = net.getRelayServiceInfo?.();
+                    if (svc) {
+                        info.isRelay = !!svc.active;
+                        info.relayService = {
+                            active: !!svc.active,
+                            protocol: svc.protocol,
+                            maxReservations: svc.maxReservations,
+                            reservations: svc.reservations,
+                        };
+                    }
+                }
+                catch { /* 忽略 */ }
+                try {
+                    const nat = net.getNatStatus?.();
+                    if (nat)
+                        info.natStatus = String(nat.status || nat.kind || JSON.stringify(nat).slice(0, 60));
+                }
+                catch { /* 忽略 */ }
+            }
+        }
+    }
+    catch { /* 客户端环境没有 p2p 模块 → 走落盘记录 */ }
+    // ② 落盘记录兜底 (CLI 一次性命令里节点通常没跑)
+    const gj = readGatewayJoin();
+    if (gj) {
+        info.joinedAt = gj.joinedAt;
+        info.capabilities = Array.isArray(gj.capabilities) ? gj.capabilities : undefined;
+        if (!info.peerId && gj.peerId) {
+            info.peerId = String(gj.peerId);
+            info.source = 'persisted';
+        }
+        if (!info.did && gj.did)
+            info.did = String(gj.did);
+        if (!info.name && gj.name)
+            info.name = String(gj.name);
+    }
+    if (info.peerId && !info.multiaddrs.length) {
+        info.note = '只拿到 peerId (落盘记录), 当前进程没有运行中的 P2P 节点 → 可拨入地址需要一个在跑的节点来生成 '
+            + '(启动: `bolloon --web` 或让智能体执行 join_global_gateway; 之后在此重跑 `bolloon p2p`)';
+    }
+    else if (!info.peerId) {
+        info.note = '还没有本机 peerId: 先让智能体入网 (read https://bolloon.cn/bolloon-gateway-join.md) 或启动 P2P 节点, 再跑 `bolloon p2p`';
+    }
+    else if (!info.multiaddrs.length) {
+        info.note = '节点在跑, 但当前没有被拨入地址 (可能只有拨出能力); 若在手机端需先建立 relay 预约';
+    }
+    else {
+        info.note = undefined;
+    }
+    info.ok = !!info.peerId;
+    return info;
+}
+/** 人可读 + 可直接抄进小工具/名片 (peerId 与 multiaddr 分开列, 方便逐项粘贴) */
+export function formatP2pInfoText(info) {
+    const lines = [];
+    lines.push('── 本机 P2P 连接信息 ──────────────────────────────');
+    lines.push(`来源: ${info.source === 'live' ? '运行中的节点 (live)' : info.source === 'persisted' ? '落盘记录 (persisted)' : '无'}`);
+    if (info.name)
+        lines.push(`名称: ${info.name}`);
+    if (info.did)
+        lines.push(`身份: ${info.did}`);
+    lines.push(`peerId: ${info.peerId || '(未拿到)'}`);
+    if (info.capabilities?.length)
+        lines.push(`能力: ${info.capabilities.join(', ')}`);
+    if (info.natStatus)
+        lines.push(`NAT: ${info.natStatus}`);
+    lines.push(`本机是中继: ${info.isRelay ? '是' : '否'}${info.relayService?.active ? ` (协议 ${info.relayService.protocol || '-'}, 预约 ${info.relayService.reservations ?? '-'}/${info.relayService.maxReservations ?? '-'})` : ''}`);
+    if (info.multiaddrs.length) {
+        lines.push('可拨入地址:');
+        for (const m of info.multiaddrs.slice(0, 6))
+            lines.push(`  ${m}`);
+    }
+    else {
+        lines.push('可拨入地址: (当前没有 —— 对端暂时拨不进来)');
+    }
+    if (info.relayAddrs.length) {
+        lines.push('经中继可拨入:');
+        for (const m of info.relayAddrs.slice(0, 4))
+            lines.push(`  ${m}`);
+    }
+    if (info.note)
+        lines.push(`说明: ${info.note}`);
+    lines.push('── 抄进小工具: 地址填上面的 multiaddr (含 /p2p/ 段), peerId 填上面的 peerId ──');
+    return lines.join('\n');
+}
+/** 机器可读 (给小工具/App/验收脚本用; 字段名与名片里的 p2p 结构对齐) */
+export function formatP2pInfoJson(info) {
+    const primary = info.relayAddrs[0] || info.multiaddrs[0] || '';
+    return JSON.stringify({
+        schema: 'bolloon-p2p-info/1',
+        ok: info.ok,
+        source: info.source,
+        did: info.did || '',
+        name: info.name || '',
+        peerId: info.peerId || '',
+        multiaddr: primary,
+        multiaddrs: info.multiaddrs,
+        relayAddrs: info.relayAddrs,
+        isRelay: info.isRelay,
+        relayService: info.relayService || null,
+        natStatus: info.natStatus || null,
+        capabilities: info.capabilities || [],
+        note: info.note || null,
+        /** 直接可用的名片字段 (小工具 agent-card 的 p2p 结构) */
+        cardP2p: { peerId: info.peerId || '', multiaddr: primary, relay: info.isRelay ? (info.peerId || '') : '' },
+    }, null, 2);
+}

package/dist/agents/run-store.js

@@ -485,6 +485,21 @@ export function argsDigestOf(v) {
  * 追加一步 (工具调用后立即落盘) —— 崩在这里也能看到做到哪一步。
  * 锁内读改写: 并发调用不会互相覆盖步骤。
  */
+/**
+ * 追加证据到 Run (2026-09-16): 交易等"外部事实"要能进 Run 的 evidence,
+ * 而不是只留在工具内部 (支付必须可审计)。
+ */
+export async function addRunEvidence(runId, lines) {
+    return withRunLock(runId, () => coreWrite('addRunEvidence', runId, async () => {
+        const rec = await readRun(runId);
+        if (!rec)
+            return null;
+        const merged = Array.from(new Set([...(rec.evidence || []), ...lines.map((l) => String(l).slice(0, 300))])).slice(-50);
+        rec.evidence = merged;
+        await writeRun(rec);
+        return rec;
+    }));
+}
 export async function recordStep(runId, step) {
     return withRunLock(runId, () => coreWrite('recordStep', runId, async () => {
         const rec = await readRun(runId);

package/dist/agents/task/local-seller.js

@@ -0,0 +1,149 @@
+/**
+ * local-seller.ts — M1 的"卖方" (本地 Registry 节点)
+ *
+ * M1 只做**本地 Registry**: 卖方就是你自己本机的报价端点。
+ * 这里**不重新实现协议** —— 直接把项目真实的卖方路由
+ * (`src/web/routes-x402-info.ts: registerX402InfoRoutes`) 挂到一个极小的
+ * express 风格适配器上, 用真 HTTP 跑真 402 → 付款校验 → 签名信封。
+ *
+ * 注意: 卖方路由内部用 `os.homedir()` 找 `~/.bolloon/{identity.json, x402-info/}`,
+ *       所以调用方若做隔离测试, 需要在启动前设好 `process.env.HOME`。
+ */
+import * as http from 'http';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+function matchPath(pattern, actual) {
+    const p = pattern.split('/').filter(Boolean);
+    const a = actual.split('/').filter(Boolean);
+    if (pattern.endsWith('/') && p.length !== a.length)
+        return { hit: false, params: {} };
+    if (p.length !== a.length)
+        return { hit: false, params: {} };
+    const params = {};
+    for (let i = 0; i < p.length; i++) {
+        if (p[i].startsWith(':'))
+            params[p[i].slice(1)] = decodeURIComponent(a[i]);
+        else if (p[i] !== a[i])
+            return { hit: false, params: {} };
+    }
+    return { hit: true, params };
+}
+function makeRes() {
+    let settle;
+    const done = new Promise((r) => { settle = r; });
+    const headers = {};
+    const res = {
+        _status: 200,
+        status(n) { res._status = n; return res; },
+        set(k, v) { headers[k] = String(v); return res; },
+        json(obj) {
+            headers['content-type'] = 'application/json';
+            settle({ status: res._status, headers, body: JSON.stringify(obj ?? null) });
+            return res;
+        },
+        send(text) {
+            settle({ status: res._status, headers, body: String(text ?? '') });
+            return res;
+        },
+    };
+    return { res, done };
+}
+/** 极小的 express 风格 app (只实现卖方路由用到的 get/post/delete + res.json/status/set) */
+export function createMiniApp() {
+    const routes = [];
+    const add = (method) => (p, h) => { routes.push({ method, path: p, handler: h }); };
+    const app = { get: add('GET'), post: add('POST'), delete: add('DELETE') };
+    const dispatch = async (method, url, headers, body) => {
+        const u = new URL(url, 'http://127.0.0.1');
+        for (const r of routes) {
+            if (r.method !== method)
+                continue;
+            const m = matchPath(r.path, u.pathname);
+            if (!m.hit)
+                continue;
+            const { res, done } = makeRes();
+            let parsed = undefined;
+            if (body) {
+                try {
+                    parsed = JSON.parse(body);
+                }
+                catch {
+                    parsed = undefined;
+                }
+            }
+            const req = {
+                method,
+                url,
+                headers,
+                params: m.params,
+                query: Object.fromEntries(u.searchParams.entries()),
+                body: parsed,
+                protocol: 'http',
+            };
+            try {
+                await r.handler(req, res);
+            }
+            catch (e) {
+                return { status: 500, headers: { 'content-type': 'application/json' }, body: JSON.stringify({ error: String(e?.message || e) }) };
+            }
+            return await done;
+        }
+        return null;
+    };
+    return { app, dispatch };
+}
+/** 卖方的 DIAP 身份 (签发信封用) — 缺失就生成一个本机身份, 不静默跳过 */
+export async function ensureSellerIdentity(home = os.homedir()) {
+    const dir = path.join(home, '.bolloon');
+    const file = path.join(dir, 'identity.json');
+    if (fs.existsSync(file)) {
+        try {
+            const raw = JSON.parse(fs.readFileSync(file, 'utf8'));
+            return { created: false, did: raw?.did };
+        }
+        catch {
+            return { created: false };
+        }
+    }
+    try {
+        const { KeyManager } = await import('@diap/sdk');
+        const kp = KeyManager.generate();
+        fs.mkdirSync(dir, { recursive: true });
+        await KeyManager.saveToFile(kp, file);
+        return { created: true, did: kp?.did };
+    }
+    catch (e) {
+        return { created: false };
+    }
+}
+/** 启动本地卖方节点: 真 HTTP + 项目真实卖方路由 */
+export async function startLocalSeller(opts = {}) {
+    const { registerX402InfoRoutes } = await import('../../web/routes-x402-info.js');
+    const { app, dispatch } = createMiniApp();
+    registerX402InfoRoutes(app);
+    const { listInfo } = await import('../x402/paid-info-store.js');
+    const server = http.createServer((req, res) => {
+        const chunks = [];
+        req.on('data', (c) => chunks.push(c));
+        req.on('end', async () => {
+            const body = Buffer.concat(chunks).toString('utf8');
+            const out = await dispatch(req.method || 'GET', req.url || '/', req.headers, body);
+            if (!out) {
+                res.writeHead(404, { 'content-type': 'application/json' });
+                res.end(JSON.stringify({ error: 'not found' }));
+                return;
+            }
+            res.writeHead(out.status, out.headers);
+            res.end(out.body);
+        });
+    });
+    await new Promise((resolve) => server.listen(opts.port ?? 0, '127.0.0.1', () => resolve()));
+    const port = server.address()?.port;
+    return {
+        url: `http://127.0.0.1:${port}`,
+        port,
+        itemCount: async () => (await listInfo()).length,
+        close: async () => { await new Promise((resolve) => server.close(() => resolve())); },
+    };
+}

package/dist/agents/task/report-card.js

@@ -0,0 +1,146 @@
+/**
+ * report-card.ts — M1 薄层 ③: 报告卡
+ *
+ * M1 **唯一面向人的主出口**。用户只看到这里的东西:
+ *   任务 / 结论 / 本次使用(Skill·版本·花费·来源) / 三项校验 / 状态(4 态) / 证据指针 / 卡在哪。
+ *
+ * 两条硬门 (leo 定, 任一不满足 → M1 失败):
+ *   买到 Skill 但没有执行        → 卡片必须"需要你处理", 不许变绿
+ *   执行成功但没有报告/证据      → 卡片必须"需要你处理", 不许变绿
+ *
+ * 内部 10 态生命周期 / 8 态结算事实**只在这里被映射成 4 个人类状态**, 不外泄术语。
+ */
+/** 内部生命周期 → 人类 4 态 (术语不外泄) */
+export function humanStatusFrom(opts) {
+    if (opts.verdict === 'blocked')
+        return '需要你处理';
+    const lc = String(opts.lifecycle || '');
+    switch (lc) {
+        case 'verified':
+            return '已完成';
+        case 'settled':
+        case 'delivered':
+            return '正在执行';
+        case 'discovered':
+        case 'quoted':
+        case 'payment_required':
+        case 'paying':
+            return '正在获取能力';
+        case 'policy_denied':
+        case 'delivery_failed':
+        case 'verification_failed':
+        case 'disputed':
+        case 'failed':
+            return '需要你处理';
+        default:
+            break;
+    }
+    switch (opts.stage) {
+        case 'prepare':
+            return '准备中';
+        case 'acquire':
+            return '正在获取能力';
+        case 'execute':
+            return '正在执行';
+        default:
+            return '已完成';
+    }
+}
+/**
+ * 组装报告卡。两条硬门在这里落地 (不是靠调用方记得检查):
+ * 只要"付了没执行"或"执行了没证据", 一律 `需要你处理` + 结论降级为"证据不足"。
+ */
+export function buildReportCard(input) {
+    const checks = {
+        outputContract: input.outputContract ?? '未执行',
+        resourceVerified: input.resourceVerified ?? '未执行',
+        taskEvidence: input.evidenceComplete ? '完整' : '不完整',
+    };
+    let status = humanStatusFrom({ stage: input.stage, lifecycle: input.lifecycle, verdict: input.blocker ? 'blocked' : 'ok' });
+    let hardGate;
+    let conclusion = input.conclusion ?? (status === '已完成' ? '证据不足' : '证据不足');
+    let blocker = input.blocker;
+    if (input.paid && !input.executed) {
+        hardGate = 'bought_not_executed';
+        status = '需要你处理';
+        conclusion = '证据不足';
+        blocker = blocker || '买到了 Skill 但没有执行 —— 这一次不算完成任务 (M1 硬门)';
+    }
+    else if (input.executed && !input.evidenceComplete) {
+        hardGate = 'executed_without_evidence';
+        status = '需要你处理';
+        conclusion = '证据不足';
+        blocker = blocker || '执行了但没有留下完整证据 —— 这一次不算完成任务 (M1 硬门)';
+    }
+    else if (input.outputContract === '未通过') {
+        status = '需要你处理';
+        conclusion = '证据不足';
+        blocker = blocker || '输出不符合资源契约 —— 不计成功 (M1 硬门)';
+    }
+    if (status === '已完成' && (checks.taskEvidence !== '完整' || checks.resourceVerified !== '通过' || checks.outputContract !== '通过')) {
+        // 三项校验没全过就不许显示"已完成" (防假绿)
+        status = '需要你处理';
+        hardGate = hardGate || 'executed_without_evidence';
+        conclusion = '证据不足';
+        blocker = blocker || `三项校验未全过 (输出契约=${checks.outputContract} · 资源验证=${checks.resourceVerified} · 证据=${checks.taskEvidence})`;
+    }
+    return {
+        task: input.task,
+        conclusion,
+        conclusionDetail: input.conclusionDetail,
+        skill: input.skill,
+        cost: input.cost,
+        payment: input.payment,
+        sources: input.sources,
+        checks,
+        status,
+        executed: input.executed,
+        paid: input.paid,
+        durationMs: input.durationMs,
+        evidenceRef: input.evidenceRef,
+        blocker,
+        hardGate,
+        budgetLines: input.budgetLines,
+    };
+}
+/** CLI 文本渲染 —— M1 的唯一主出口形状 */
+export function renderReportCard(card) {
+    const L = [];
+    L.push(`任务: ${card.task}`);
+    L.push('');
+    L.push(`结论: ${card.conclusion}${card.conclusionDetail ? ` (${card.conclusionDetail})` : ''}`);
+    L.push('');
+    L.push('本次使用:');
+    if (card.skill)
+        L.push(`- Skill: ${card.skill.name}${card.skill.version ? ` @ ${card.skill.version}` : ''}`);
+    if (card.cost)
+        L.push(`- 花费: ${card.cost.amount} ${card.cost.currency} (${card.cost.network})`);
+    if (card.payment) {
+        const modeZh = card.payment.mode === 'local-dev' ? '本机联调 (local-dev)' : card.payment.mode === 'facilitator' ? 'facilitator' : card.payment.mode;
+        L.push(`- 支付方式: ${modeZh}`);
+        L.push(`- 链上已验证: ${card.payment.chainSettled ? '是' : '否'}${card.payment.chainSettled ? '' : ' (本机联调不冒充链上结算)'}`);
+    }
+    if (card.sources)
+        L.push(`- 来源: ${card.sources.length} 个${card.sources.length ? ` (${card.sources.slice(0, 3).join(', ')}${card.sources.length > 3 ? ', …' : ''})` : ''}`);
+    L.push(`- 输出契约: ${card.checks.outputContract}`);
+    L.push(`- 资源验证: ${card.checks.resourceVerified}`);
+    L.push(`- 任务证据: ${card.checks.taskEvidence}`);
+    if (typeof card.durationMs === 'number')
+        L.push(`- 耗时: ${(card.durationMs / 1000).toFixed(1)} 秒`);
+    L.push(`- 状态: ${card.status}`);
+    if (card.blocker) {
+        L.push('');
+        L.push(`卡在哪: ${card.blocker}`);
+    }
+    if (card.budgetLines && card.budgetLines.length) {
+        L.push('');
+        L.push('预算:');
+        for (const b of card.budgetLines)
+            L.push(`- ${b}`);
+    }
+    L.push('');
+    const ref = card.evidenceRef;
+    const parts = [ref.goalId ? `Goal ${ref.goalId}` : null, ref.runId ? `Run ${ref.runId}` : null, ref.transactionId ? `交易 ${ref.transactionId}` : null].filter(Boolean);
+    L.push(parts.length ? `查看完整证据: ${parts.join(' · ')}` : '查看完整证据: (无)');
+    return L.join('\n');
+}