@bolloon/bolloon-agent 0.4.32 → 0.4.33

package/dist/agents/chain/explorer.js

@@ -0,0 +1,52 @@
+/**
+ * explorer.ts — 区块浏览器映射 (chainId → 公网浏览器) + **交易**链接构造
+ *
+ * 只回答一件事: **这条链有没有已知的公网浏览器**。
+ *   · 有 → `https://<explorer>/tx/0x…` (公开可核验的链上事实)
+ *   · 认不出 / 本机隔离开发链 (31337) → **null** —— 没有公网浏览器就**不给链接**,
+ *     绝不编造 `href="#"`、死链或猜一个域名 (宁缺勿错)。
+ *
+ * 隐私红线 (2026-09-23 leo 拍板; 同日收窄):
+ *   · 允许出现在公开快照里的 0x 字符串**只有两种**: 交易哈希 (0x+64 hex) 与 escrow **合约**地址
+ *     (0x+40 hex) —— 它们本来就是公开链上事实。
+ *   · 但**页面只可点交易**: escrow 合约地址保留在行数据里供索引/诊断, **不渲染、不生成合约链接**
+ *     (所以本文件**没有** address 链接构造器 —— 少一个能凭空造出合约链接的入口)。
+ *   · EOA / 钱包地址 (买方·卖方·payTo 之类)、taskKey 原文、taskId、args 里的地址、DID、
+ *     peer IP / multiaddr、私钥 —— **一个都不许**经这里或别处进快照。
+ *   · 本文件只构造 URL, 不读盘不发 RPC, 也从不接受「调用方说它是合约地址」的自我声明。
+ */
+/** chainId → 公网浏览器 base URL (白名单; 认不出的一律没有) */
+export const EXPLORER_BY_CHAIN = Object.freeze({
+    8453: 'https://basescan.org', // Base 主网
+    84532: 'https://sepolia.basescan.org', // Base Sepolia 测试网
+    1: 'https://etherscan.io', // Ethereum 主网
+    11155111: 'https://sepolia.etherscan.io', // Sepolia 测试网
+});
+/** 交易哈希: 小写 0x + 64 位十六进制 (词法唯一形状) */
+export const TX_HASH_RE = /^0x[0-9a-f]{64}$/;
+/** 地址: 小写 0x + 40 位十六进制 (合约地址同样长这样 —— 是**谁**由调用方的白名单决定) */
+export const ADDRESS_RE = /^0x[0-9a-f]{40}$/;
+/**
+ * 浏览器**交易**链接形状 (反向校验用): https + 已知浏览器域名 + `/tx/0x64hex`。
+ * 给守卫 / 单测一把「这不是我们造的链接」的尺子 —— 端口 / 凭据 / 别的路径 (含 `/address/`) 一律不认。
+ */
+export const EXPLORER_URL_RE = /^https:\/\/(?:[a-z0-9-]+\.)*(?:basescan\.org|etherscan\.io)\/tx\/0x[0-9a-f]{64}$/;
+/** chainId 有没有已知公网浏览器 → base URL; 认不出 (含本机 31337) → null */
+export function explorerBaseUrl(chainId) {
+    const id = Number(chainId);
+    if (!Number.isInteger(id) || id < 0)
+        return null;
+    return EXPLORER_BY_CHAIN[id] ?? null;
+}
+/** 交易链接; 链没浏览器 / 哈希非法 → null (调用方**不要**填 null 之外的占位) */
+export function explorerTxUrl(chainId, txHash) {
+    const base = explorerBaseUrl(chainId);
+    const h = String(txHash ?? '').toLowerCase();
+    if (!base || !TX_HASH_RE.test(h))
+        return null;
+    return `${base}/tx/${h}`;
+}
+/** 这个字符串是不是我们亲手造的那种**交易**浏览器链接 (守卫 / 单测用) */
+export function isExplorerUrl(url) {
+    return typeof url === 'string' && EXPLORER_URL_RE.test(url);
+}

package/dist/agents/chain/index.js

@@ -9,6 +9,7 @@
  *   · chain-state-store   — 落盘 / 重启恢复 / 重组对账
  *   · chain-indexer       — P5: v2 事件索引器 (分页扫 / 增量 / 去重 / 重组回退 / 全量重建)
  *   · chain-index-query   — P5: 只读查询 (时间线 / cursor 增量 / 统计 / 索引高度)
+ *   · explorer            — chainId → 公网区块浏览器 (**只造交易链接**: 合约地址不页面化; 认不出的链不给链接)
  */
 export * from './chain-config.js';
 export * from './escrow-client.js';
@@ -18,3 +19,4 @@ export * from './chain-state-store.js';
 export * from './onchain-trade.js';
 export * from './chain-indexer.js';
 export * from './chain-index-query.js';
+export * from './explorer.js';

package/dist/agents/chain/onchain-trade.js

@@ -116,7 +116,7 @@ function emptyStep(stage, partial) {
 async function judge(req, taskKey, txHash, expect, recorded) {
     const gate = req.gate || 'confirmed';
     const verify = req.verifyOnChain || (await defaultVerifyPaymentOnChain());
-    return verify({
+    const run = () => verify({
         txHash,
         chainSettlement: {
             verifier: createChainSettlementVerifier(req.client, { gate }),
@@ -125,6 +125,20 @@ async function judge(req, taskKey, txHash, expect, recorded) {
             recorded,
         },
     });
+    let v = await run();
+    // ★ 未定/读偏的有界重读: 交易已经发出去了 (钱/证明在链上), 一次读偏不该定案 —— 只重读, 不重发。
+    //   两种读偏形态都要覆盖:
+    //     · 'pending'        —— eth_blockNumber 还停在前一个块 → 确认数数成 0
+    //     · 'event_mismatch' —— 事件读到了 (receipt 按 txHash 取, 一定新), 但合约状态 eth_call 读回旧值
+    //   真 mismatch (event/taskKey 真对不上) 重读 3 次后结论不变 → 不会把错的判成对的。
+    const attempts = req.settleRetryAttempts ?? 3;
+    const delayMs = req.settleRetryDelayMs ?? 1500;
+    for (let i = 1; i <= attempts && !v.chainSettled && v.rpcAvailable !== false
+        && (v.status === 'pending' || v.status === 'event_mismatch'); i++) {
+        await new Promise((r) => setTimeout(r, delayMs));
+        v = await run();
+    }
+    return v;
 }
 /** 判定落盘 (P3 chain-state-store) */
 async function persist(req, method, taskKey, txHash, amountAtomic, verdict) {

package/dist/agents/network-pulse.js

@@ -10,10 +10,19 @@
  *   · 快照过期 → `stale` (不许伪装实时); 观察层不可用 → `unavailable`
  *   · 类别小于隐私阈值 → 合并进 other
  *   · 事件数 / 时间窗 / capability 数都有上限
- *   · **冻结形状 `confirmed_activity`** (2026-09-22): 公开页面要能列出「哪个任务 · 什么状态 ·
- *     哪个块 · 多少确认」, 而不是只有数字 —— 数据源优先 P5 链上索引, 不可用时退回脉冲事件并
- *     用 `confirmed_activity_source` 标注; 标识一律 sha256 短写 (前 8 位), 绝不落 taskKey /
- *     taskId / txHash 原文; 不够确认门槛的行只报 observed, 不冒充 confirmed。
+ *   · **冻结形状 `confirmed_activity`** (2026-09-22; 2026-09-23 加链上可核验字段): 公开页面要能列出
+ *     「哪个任务 · 什么状态 · 哪个块 · 多少确认」, 而不是只有数字 —— 数据源优先 P5 链上索引, 不可用时
+ *     退回脉冲事件并用 `confirmed_activity_source` 标注; 任务标识一律 sha256 短写 (前 8 位), 绝不落
+ *     taskKey / taskId 原文; 不够确认门槛的行只报 observed, 不冒充 confirmed。
+ *     2026-09-23 隐私决定**变更一处** (只放开公开链上事实, 别的一律不变): 交易哈希 (`tx_hash`) 与
+ *     escrow **合约**地址 (`contract`, 只给索引/诊断) 允许出现; 页面可点的只有**交易**链接 `explorer_tx`
+ *     (仅当该链有已知公网浏览器)。EOA / 钱包地址 (买方·卖方)、taskKey 原文、taskId、args 里的地址、
+ *     DID、peer IP/multiaddr、私钥 —— 仍然一个都不许出现; 老字段 `tx` (sha256 短写) 保留不删。
+ *   · **冻结形状 `open_tasks[]`** (2026-09-23): 公开页要能列「本节点公告板上哪些任务还没被接单」。
+ *     数据源 = `~/.bolloon/tasks/board/*.json` 里**未认领且未过期**的公告, 每行只含白名单 7 个字段:
+ *     `capability` / `budget`(原子单位) / `currency` / `network` / `deadline` / `claimed`(恒 false) /
+ *     `announcementId`(前 8 位)。**任务正文与它的摘要/预览、买方 DID 与公钥、认领者、公告签名
+ *     一律不进公开投影** —— 行由 `buildOpenTaskRow` 逐字段拷贝构造, 不做对象展平。
  *
  * 借鉴 (只借产品与工程思想, 不借 Go/Postgres/API 项目):
  *   EigenFlux 的 "注册总量 / 当前活跃 / 最近出现" 时间窗统计、服务端生成匿名活动文本、
@@ -25,6 +34,11 @@ import * as path from 'path';
 import * as crypto from 'crypto';
 // 确认数门槛来自 chain-config (单一实现; 默认 confirmed=1 / finalized=12) —— 只借常量, 不借 RPC
 import { DEFAULT_CONFIRMATIONS, LOCAL_DEV_CHAIN_ID } from './chain/chain-config.js';
+// 区块浏览器映射 (chainId → 公网浏览器); 认不出的链没有链接 —— 宁缺勿错, 不编死链
+import { ADDRESS_RE, EXPLORER_URL_RE, TX_HASH_RE, explorerTxUrl } from './chain/explorer.js';
+// 「待接单任务」的数据源 = 本机公告板目录 (~/.bolloon/tasks/board)。只借**路径常量**,
+// 公告的解析/发布/接单一律留在 task-board.ts (这里不做第二套实现)。
+import { boardDir, REMOTE_CLAIMS_FILE } from './task-board.js';
 // ── 常量 (上限 + 时间边界) ─────────────────────────────────────────────────
 export const PULSE_LIMITS = {
     /** 最多留多少条事件 (超出丢最旧) */
@@ -56,6 +70,8 @@ export const NETWORK_EVENT_TYPES = [
     // 经济事件 (P6 扩展; 原五类保持兼容, 老节点发来的事件仍被接受)
     'task_posted', 'task_accepted', 'task_completed', 'trade_settled', 'trade_verified',
     'wallet_signed',
+    // 2026-09-23 (C1): 任务对外发布 (公告板 publish) —— 只记"有节点公告了一个待接单任务", 正文/ID 原文不落盘
+    'task_announced',
 ];
 // ── 存储 ────────────────────────────────────────────────────────────────────
 const home = (h) => h || process.env.HOME || os.homedir() || '/tmp';
@@ -167,6 +183,7 @@ export function renderActivityText(kind) {
         case 'capability_announced': return { zh: '有节点公开声明了新能力', en: 'A node announced a capability' };
         case 'peer_connected': return { zh: '两个节点建立了连接', en: 'Two nodes connected' };
         case 'delegation_completed': return { zh: '一次能力委派完成', en: 'A delegation completed' };
+        case 'task_announced': return { zh: '有节点公告了一个待接单任务', en: 'A node announced an open task' };
         default: return { zh: '网络有活动', en: 'Network activity' };
     }
 }
@@ -216,6 +233,82 @@ export function readAgentSites(h) {
         return [];
     }
 }
+/** 上限: 公开页最多列几条待接单任务 (超出按最近截止排序取前 N) */
+export const MAX_OPEN_TASKS = 25;
+/** 公开页只列这条公告的这 7 个字段; 其余(正文/买方/摘要/签名)一律不出这个函数 */
+function buildOpenTaskRow(a) {
+    const capability = String(a?.capability ?? '').trim();
+    const id = String(a?.announcementId ?? '').trim();
+    const deadline = Number(a?.deadline);
+    if (!capability || !id || !Number.isFinite(deadline) || deadline <= 0)
+        return null;
+    const b = a?.budget && typeof a.budget === 'object' ? a.budget : null;
+    const maxAmount = b ? String(b.maxAmount ?? '').trim() : '';
+    const currency = b ? String(b.currency ?? '').trim() : '';
+    const network = b ? String(b.network ?? '').trim() : '';
+    return {
+        capability,
+        budget: maxAmount || null,
+        currency: currency || null,
+        network: network || null,
+        deadline,
+        claimed: (Array.isArray(a?.claims) ? a.claims.length : 0) > 0,
+        announcementId: id.slice(0, 8), // 前 8 位 (按字面, 不重新格式化)
+    };
+}
+/**
+ * 读本节点公告板上**未认领且未过期**的公告, 投影成公开「待接单任务」行。
+ *
+ * 三条筛选 (缺一个都会把不该上的东西露出来):
+ *   · `protocol= bolloon-task/1` + `kind= task_announcement` (同目录还有 `remote-claims.json`,
+ *     它是个数组 —— 不按 kind 判会把认领台账当公告解析)
+ *   · `status === 'open'` (已认领 / 已取消 → 不是「待接单」)
+ *   · `deadline > now` (过期只是不能再接单, 文件不删 → 必须在这里判掉)
+ *
+ * 读不到目录 / 坏 JSON / 缺字段 → 该条跳过 (一条都不编); 整个目录不可读 → 空数组 + 不抛。
+ */
+export function readOpenTasks(h, now = Date.now()) {
+    const out = [];
+    try {
+        const dir = boardDir(h);
+        let names;
+        try {
+            names = fs.readdirSync(dir);
+        }
+        catch {
+            return [];
+        }
+        for (const name of names.slice().sort()) {
+            if (!name.endsWith('.json') || name === `${REMOTE_CLAIMS_FILE}`)
+                continue;
+            let raw;
+            try {
+                raw = JSON.parse(fs.readFileSync(path.join(dir, name), 'utf-8'));
+            }
+            catch {
+                continue;
+            }
+            if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+                continue; // 认领台账是数组 → 这里就出局
+            if (raw.protocol !== 'bolloon-task/1' || raw.kind !== 'task_announcement')
+                continue;
+            if (String(raw.status) !== 'open')
+                continue;
+            const deadline = Number(raw.deadline);
+            if (!Number.isFinite(deadline) || deadline <= now)
+                continue;
+            const row = buildOpenTaskRow(raw);
+            if (row)
+                out.push(row);
+        }
+    }
+    catch {
+        return [];
+    }
+    // 稳定排序: 快到期在前 (读者最需要知道的先看); 同截止按短 id 定序 (排序必须确定, 否则快照每次都"变")
+    out.sort((x, y) => (x.deadline - y.deadline) || (x.announcementId < y.announcementId ? -1 : x.announcementId > y.announcementId ? 1 : 0));
+    return out.slice(0, MAX_OPEN_TASKS);
+}
 /**
  * 把**真实交易活动**投影成脉冲事件 (由交易写路径调用, fire-and-forget)。
  * 只按事实发: 交付 → task_completed · 真验真 → trade_verified · **链上口径**结算 → trade_settled。
@@ -248,10 +341,18 @@ export async function emitTradePulse(before, after, h) {
 // ── 冻结形状: confirmed_activity (真实智能体任务 / 链上活动行) ────────────────
 //
 // 公开网页要能列出「哪个任务 · 什么状态 · 哪个块 · 多少确认」, 而不是只有数字。这块就是那批行。
-// 形状**冻结** (字段名与取值域不许改), 内容一律**匿名短写**:
-//   · task = `sha256:` + sha256(域标签|taskKey) 的前 8 位十六进制 —— 绝不落 taskKey / taskId 原文
-//   · tx   = `sha256:` + sha256(域标签|txHash)  的前 8 位十六进制 —— 绝不落 txHash 原文
-//   · 不出现 DID / peerId / IP / 完整钱包地址 / 任务正文 —— `assertNoPrivateFields` 兜底
+// 形状**冻结** (老字段名与取值域不许改), 内容按用途分两类:
+//   · **匿名短写** (老口径, 保留不删): task = `sha256:` + sha256(域标签|taskKey) 的前 8 位;
+//     tx = `sha256:` + sha256(域标签|txHash) 的前 8 位 —— 绝不落 taskKey / taskId 原文
+//   · **公开链上事实** (2026-09-23 新增; 同日按 leo 拍板收窄): tx_hash (真交易哈希) /
+//     explorer_tx (交易浏览器链接, 仅当该链有已知公网浏览器) —— 网页上的行因此**可核验地**跳回区块
+//     浏览器; contract (escrow 合约地址) 仍保留在行里**供索引/诊断**, 但**不上页面、不生成合约链接**
+// 隐私红线 (违反即失败, **只放开上面那两种 0x 字符串**):
+//   · 允许: 交易哈希 (0x+64 hex) 与 escrow 合约地址 (0x+40 hex), 且只出现在 `tx_hash`/`contract`/`explorer_tx` 这 3 个键下
+//   · 禁止: EOA / 钱包地址 (买方/卖方/payTo)、taskKey 原文、taskId、args 里的地址、DID、peerId /
+//     IP / multiaddr、私钥 —— `assertNoPrivateFields`(键名) + `auditPublicHexLeaks`(越界 0x) 兜底
+//   · 拿不到链配置里的 escrow 地址, 或这条索引记录的 address 不是它 → **不填** contract
+//     (宁缺勿错: 宁可少一个字段, 也不把可能是别人的地址写成合约)
 // 数据源优先级: ① P5 链上索引 (真链上事实) → ② 索引不可用 → 退回脉冲事件, 并在快照里用
 //   `confirmed_activity_source` 如实标注 (chain-index / pulse-events / none)。
 // 确认数口径走 chain-config 门槛 (默认 confirmed=1 / finalized=12): 够不着门槛的行只报
@@ -335,6 +436,8 @@ function activityLimit(limit) {
  *   · 不认识的事件名 / 非法 taskKey·txHash / 缺观察时间 → 跳过 (不猜、不臆造)
  *   · confirmations: 有 headBlock → head - block + 1 复算 (无 RPC, 用索引快照里的 head); 否则用记录值
  *   · finality: 按 chain-config 门槛复算 (不够 → observed)
+ *   · 新增: `tx_hash` (真交易哈希) 恒给; `contract` 仅当 opts.escrowAddress 合法且 === 本条 address;
+ *     `explorer_tx` 仅当该 chainId 有**已知公网浏览器** (否则键整个不存在, 不填 null)
  *   · 最新在前 (blockNumber desc, logIndex desc), 上限 25 行
  */
 export function buildConfirmedActivityFromIndex(entries, opts = {}) {
@@ -342,6 +445,9 @@ export function buildConfirmedActivityFromIndex(entries, opts = {}) {
     const limit = activityLimit(opts.limit);
     const chainId = Number.isInteger(Number(opts.chainId)) && Number(opts.chainId) >= 0 ? Number(opts.chainId) : 0;
     const head = Number.isInteger(Number(opts.headBlock)) && Number(opts.headBlock) >= 0 ? Number(opts.headBlock) : null;
+    // escrow 合约地址白名单 (唯一权威): 只有索引文件自己记的这个地址算数, 别的地址一律不当合约
+    const escrow = typeof opts.escrowAddress === 'string' ? opts.escrowAddress.toLowerCase() : '';
+    const escrowOk = ADDRESS_RE.test(escrow) ? escrow : '';
     const out = [];
     for (const e of Array.isArray(entries) ? entries : []) {
         if (!e || e.suspect === true)
@@ -362,6 +468,12 @@ export function buildConfirmedActivityFromIndex(entries, opts = {}) {
         if (!at)
             continue; // 没观察时间 → 不臆造时间, 不成行
         const confirmations = head == null ? Math.max(0, Number(e.confirmations) || 0) : Math.max(0, head - block + 1);
+        // 合约地址: 只有「本条记录的 address 就是链配置里的 escrow 地址」才填 (宁缺勿错)
+        const entryAddr = String(e.address || '').toLowerCase();
+        const contract = escrowOk && entryAddr === escrowOk ? escrowOk : '';
+        // 浏览器链接: 该链没有已知公网浏览器 → 返回 null → 键整个不出现 (不编 href="#")
+        // 只有**交易**链接 (explorer_tx); 合约地址只在数据里 (contract), 不生成链接 (2026-09-23 收窄)
+        const explorerTx = explorerTxUrl(chainId, txHash);
         out.push({
             block, logIndex,
             row: {
@@ -374,6 +486,10 @@ export function buildConfirmedActivityFromIndex(entries, opts = {}) {
                 confirmations,
                 finality: finalityFromConfirmations(confirmations, gates),
                 at,
+                // 公开链上事实 (白名单键; 老字段 tx 已在上方保留)
+                tx_hash: txHash,
+                ...(contract ? { contract } : {}),
+                ...(explorerTx ? { explorer_tx: explorerTx } : {}),
             },
         });
     }
@@ -471,6 +587,7 @@ export async function resolveConfirmedActivity(q) {
                 headBlock: file?.headBlock,
                 chainId: file?.chainId,
                 limit,
+                escrowAddress: file?.escrowAddress, // 合约地址白名单 = 索引文件自己的部署身份
             });
             if (rows.length > 0)
                 return { source: 'chain-index', rows, gates };
@@ -609,6 +726,8 @@ export function buildChainIdScope(rows) {
  *   ④ `activity_totals.source` === `confirmed_activity_source` (两块来源标注必须一致)
  *   ⑤ 行里有任务 而 `totals.tasks === 0` 时, 必须有口径说明 note
  *      (页面不许出现「0 个任务」与「N 行任务」并存而**不解释**)
+ *   ⑥ 0x 长 hex 越界 (2026-09-23): 只许出现在 tx_hash/contract/explorer_* 四个白名单键下 ——
+ *      EOA 地址跑到别的键 (或白名单键形状不对) 就拒绝导出
  */
 export function snapshotConsistencyIssues(snap) {
     const issues = [];
@@ -635,8 +754,50 @@ export function snapshotConsistencyIssues(snap) {
         if (!explained)
             issues.push(`totals.tasks=0 与 ${rows.length} 行任务并存, 却没有口径说明 note`);
     }
+    issues.push(...auditPublicHexLeaks(snap)); // ⑥ 0x 长 hex 越界 → 拒绝导出 (不静默放行)
+    issues.push(...openTasksIssues(snap)); // ⑦ 待接单任务的字段白名单与「只含未认领」不变式
     return issues;
 }
+/** open_tasks 行的字段白名单 (与 `OpenTaskRow` 逐字一致; 多一个键 = 可能把正文/身份带出去了) */
+export const OPEN_TASK_KEYS = ['capability', 'budget', 'currency', 'network', 'deadline', 'claimed', 'announcementId'];
+/**
+ * 待接单任务行的自检 (空 = 通过)。这不是格式洁癖, 每条都对着一个真泄漏路径:
+ *   · 键集 ≠ 白名单 → 有人把 instruction / buyerDid / claims 之类**展平**进公开投影了;
+ *   · `claimed !== false` → 「只导出未认领」这个筛选坏了 (页面会把已接单的当待接单);
+ *   · `announcementId` 长于 8 位 → 短写丢了, 原始公告 id 上公开页 (页面上的 id 会被读者当完整 id 用);
+ *   · capability 空 / deadline 非正 → 页面上会出现一条说不出是什么、也不知道何时截止的行。
+ */
+export function openTasksIssues(snap) {
+    const out = [];
+    const rows = snap?.open_tasks;
+    if (!Array.isArray(rows))
+        return ['open_tasks 缺失 (公开「待接单任务」必须是数组, 没有就给空数组)'];
+    const allow = OPEN_TASK_KEYS;
+    rows.forEach((r, i) => {
+        const at = `open_tasks[${i}]`;
+        if (!r || typeof r !== 'object' || Array.isArray(r)) {
+            out.push(`${at} 不是对象`);
+            return;
+        }
+        const extra = Object.keys(r).filter((k) => !allow.includes(k));
+        if (extra.length)
+            out.push(`${at} 出现白名单外的键: ${extra.join(', ')} (公开投影只许 ${allow.join('/')})`);
+        if (typeof r.capability !== 'string' || !r.capability.trim())
+            out.push(`${at}.capability 缺失/为空`);
+        if (r.claimed !== false)
+            out.push(`${at}.claimed=${JSON.stringify(r.claimed)} —— 公开页只许列**未认领**的公告`);
+        if (typeof r.announcementId !== 'string' || r.announcementId.length === 0 || r.announcementId.length > 8) {
+            out.push(`${at}.announcementId 必须是 announcementId 的**前 8 位**(1..8 字符), 实得 ${JSON.stringify(r.announcementId)}`);
+        }
+        if (!Number.isFinite(r.deadline) || r.deadline <= 0)
+            out.push(`${at}.deadline 必须是正的 ms 时间戳`);
+        for (const k of ['budget', 'currency', 'network']) {
+            if (r[k] !== null && typeof r[k] !== 'string')
+                out.push(`${at}.${k} 只许字符串或 null (不替公告猜值)`);
+        }
+    });
+    return out;
+}
 export function computeSnapshot(events, opts) {
     const now = opts.now;
     const fresh_until = now + PULSE_LIMITS.snapshotTtlMs;
@@ -664,6 +825,9 @@ export function computeSnapshot(events, opts) {
             confirmed_activity_source: 'none',
             activity_totals: summarizeActivityRows(emptyRows, { source: 'none', gates }),
             chain_id_scope: buildChainIdScope(emptyRows),
+            // 观察层不可用 ≠ 公告板读不到: 这一支只说明「脉冲事件层」挂了, 待接单任务照实带出来
+            // (调用方没给就空数组 —— 不拿空数组冒充「板上没有」: 页面空态说的是「暂未观察到」)
+            open_tasks: Array.isArray(opts.openTasks) ? opts.openTasks : [],
             notes: ['观察层暂不可用 — 这不是"网络为空"'],
         };
     }
@@ -784,6 +948,7 @@ export function computeSnapshot(events, opts) {
         confirmed_activity_source: activity.source,
         activity_totals,
         chain_id_scope,
+        open_tasks: Array.isArray(opts.openTasks) ? opts.openTasks : [],
         notes,
     };
 }
@@ -802,7 +967,8 @@ export async function getNetworkPulse(opts = {}) {
                 && typeof cached?.confirmed_activity_source === 'string'
                 && !!cached?.totals_scope
                 && !!cached?.activity_totals
-                && !!cached?.chain_id_scope;
+                && !!cached?.chain_id_scope
+                && Array.isArray(cached?.open_tasks); // 老缓存没有待接单任务 → 过期形状, 重算
             if (shapeOk && cached && Number.isFinite(cached.generated_at) && cached.generated_at + PULSE_LIMITS.snapshotTtlMs > now)
                 return cached;
         }
@@ -817,7 +983,8 @@ export async function getNetworkPulse(opts = {}) {
     }
     // 活动行优先取 P5 链上索引 (真链上事实); 索引不可用 → 退回脉冲事件, 并在快照里标出来源
     const confirmedActivity = await resolveConfirmedActivity({ home: opts.home, events, now });
-    const snap = computeSnapshot(events, { now, confirmedActivity });
+    // 待接单任务: 只读本机公告板目录 (未认领且未过期), 投影成白名单 7 字段 —— 与脉冲事件层无关
+    const snap = computeSnapshot(events, { now, confirmedActivity, openTasks: readOpenTasks(opts.home, now) });
     try {
         fs.mkdirSync(pulseDir(opts.home), { recursive: true });
         fs.writeFileSync(snapshotFile(opts.home), JSON.stringify(snap), 'utf8');
@@ -910,3 +1077,48 @@ export function assertNoPrivateFields(value, at = '$') {
     walk(value, at);
     return issues;
 }
+/**
+ * 允许出现 0x 长 hex 的键 (**唯一白名单**, 2026-09-23 leo 拍板; 同日收窄): 交易哈希 / escrow 合约地址 /
+ * 交易浏览器链接 —— 都是公开链上事实。除了这 3 个键, 别处出现 0x 长 hex (尤其 EOA 钱包地址) 一律算泄露。
+ * 注意 `contract` **只在数据里**(供索引/诊断), 页面不渲染合约地址也不给合约链接 ⇒ 没有 `explorer_contract` 这个键。
+ */
+export const PUBLIC_HEX_KEYS = ['tx_hash', 'contract', 'explorer_tx'];
+/**
+ * 0x 长 hex 越界审计 (**粒度比 `assertNoPrivateFields` 更细**: 那个只看键名, 这个看值形态)。
+ *   · 白名单键下: 形状必须精确 —— `tx_hash` = 0x+64 hex; `contract` = 0x+40 hex;
+ *     `explorer_tx` = 我们造的**交易**浏览器链接形状 (`EXPLORER_URL_RE`)
+ *   · **其他任何键**的值里出现 `0x` + 40/64 位 hex → 报出来 (买方·卖方 EOA、taskKey 原文、
+ *     args 里的地址都属这一类); `explorer_contract` 之类不在白名单的键**同样**按泄露处理
+ * 返回越界说明列表 (空 = 干净)。这条尺子**只收紧不放松**: 老口径下「任何 0x 长 hex 都不许」
+ * 现在等价于「除了这 3 个白名单键, 任何 0x 长 hex 都不许」。
+ */
+export function auditPublicHexLeaks(value, at = '$') {
+    const issues = [];
+    const allow = PUBLIC_HEX_KEYS;
+    const walk = (v, p) => {
+        if (Array.isArray(v))
+            return v.forEach((x, i) => walk(x, `${p}[${i}]`));
+        if (v && typeof v === 'object') {
+            for (const [k, val] of Object.entries(v))
+                walk(val, `${p}.${k}`);
+            return;
+        }
+        if (typeof v !== 'string')
+            return;
+        const s = v;
+        const key = p.slice(p.lastIndexOf('.') + 1);
+        // 白名单键: 形状必须精确 —— 不管值长短都查 (拿短串/怪串冒充同样拒绝)
+        if (allow.includes(key)) {
+            const ok = (key === 'tx_hash' && TX_HASH_RE.test(s))
+                || (key === 'contract' && ADDRESS_RE.test(s))
+                || (key === 'explorer_tx' && EXPLORER_URL_RE.test(s));
+            if (!ok)
+                issues.push(`${p} = 白名单键 ${key} 下的形状不对 (只认精确形状, 不认"含 0x 就算")`);
+            return;
+        }
+        if (/0x[0-9a-fA-F]{40}/.test(s))
+            issues.push(`${p} = 0x 长 hex (只许出现在 ${allow.join('/')} 下) → 按泄露处理`);
+    };
+    walk(value, at);
+    return issues;
+}

package/dist/agents/task/task-onchain-runner.js

@@ -24,7 +24,7 @@ import { resolveTaskBudget } from './task-budget.js';
 import { adviseResource } from './resource-advisor.js';
 import { defaultRequestId, installBundle, deriveSkillInput, extractSources, extractConclusion } from './task-runner.js';
 import { buildReportCard, renderReportCard } from './report-card.js';
-import { loadResourceContract, executeContractSkill, validateResourceOutput, verifyInstallFidelity, } from '../x402/resource-contract.js';
+import { loadResourceContract, executeContractSkill, validateResourceOutput, validateResourceInput, verifyInstallFidelity, } from '../x402/resource-contract.js';
 import { beginTransaction, readTransaction, updateTransaction } from '../x402/transaction-store.js';
 import { writeDeliveryContent } from '../x402/settlement-state.js';
 import { computeContentHash } from '../x402/paid-info-protocol.js';
@@ -88,6 +88,23 @@ export async function runTaskOnchain(opts) {
         };
     }
     mark('acquire', `选中 ${chosen.name} (${(chosen.why || []).slice(0, 2).join(' / ') || '名字匹配'})`);
+    // ②.5 输入预检 (不花钱的前置门): 输入建不出来/不合 inputSchema → **绝不先注资**
+    // 教训: 先注资再执行, 执行不达标 → 钱卡在托管里 (只能 dispute+refund 才拿得回)。
+    // 契约的 inputSchema 在这里就能判, 所以把这道门放在任何链上写操作之前。
+    const preContract = chosen.contract || (await loadResourceContract(chosen.dir)).contract;
+    const preInput = opts.input ?? deriveSkillInput(preContract, opts.task);
+    const preChk = preContract ? validateResourceInput(preContract, preInput) : { ok: true, issues: [] };
+    if (!preChk.ok) {
+        const blocker = `输入不符合 inputSchema (${preChk.issues[0] || '未知'}) → 未开托管, 没花钱`;
+        const card = buildReportCard({ task: opts.task, executed: false, paid: false, evidenceRef: {}, blocker });
+        mark('report', '输入不完整 → 不开托管, 不花钱 (给 --input 或把数字写进任务文本)');
+        return {
+            ok: false, taskKey, requestId, transactionId: '', card, text: renderReportCard(card), budget,
+            skill: { name: chosen.name, version: chosen.version, dir: chosen.dir },
+            chain: { verified: false, reason: blocker, statuses: [] }, outputIssues: [...preChk.issues, blocker],
+            recovery: recoverOnchainTrade({ home: opts.home, taskKey }), stages,
+        };
+    }
     // ③ 金额 = 单次购买上限 (与 M1 硬约束一致); 转原子单位
     const amountAtomic = BigInt(Math.round(budget.perPurchase * 10 ** decimals));
     const amountChk = checkOnchainAmount({ amountAtomic, decimals, budget: { taskBudget: budget.taskBudget, perPurchase: budget.perPurchase } });
@@ -124,6 +141,7 @@ export async function runTaskOnchain(opts) {
         network: opts.network || 'unknown', tokenDecimals: decimals,
         buyerSigner: opts.buyerSigner, sellerSigner: opts.sellerSigner,
         env: opts.env, persistState: opts.persistState, verifyOnChain: opts.verifyOnChain,
+        settleRetryAttempts: opts.settleRetryAttempts, settleRetryDelayMs: opts.settleRetryDelayMs,
     };
     // ⑤ 幂等/恢复: 已经链上走过的任务**不新开托管** (先读盘重建)
     const before = recoverOnchainTrade({ home: opts.home, taskKey });

package/dist/agents/task/task-runner.js

@@ -55,6 +55,30 @@ function faultPoint(name) {
         process.exit(97); // 模拟进程被杀
     process.kill(process.pid, 'SIGKILL');
 }
+/**
+ * 数值字段的锚点词: 字段名本身 + 常见别名 —— 只有「锚点词紧邻数字」才算, 数字不搬家。
+ * 为什么需要: 早先的实现把「任务文本里第一个数字」塞给**每一个**数值字段。任务里出现
+ * 技术符号 (如 `μ0H_P`) 时第一个数字就是那个 `0` → field_T/tc_K/factor 全被编成 0 →
+ * 技能判「输入不合格→未知」→ 输出缺 required 字段 → 托管已注资但拿不到 proof (钱卡住)。
+ * 编造数字比缺输入更糟: 宁可让 inputSchema 报「缺字段」, 也不给一个看着像真值的假数字。
+ */
+const NUMBER_ANCHORS = {
+    budgetusd: ['预算', 'budget'], budget: ['预算', 'budget'],
+    price: ['价格', '单价', 'price'], amount: ['金额', 'amount'], usd: ['美元', 'usd'],
+    count: ['数量', 'count'], qty: ['数量', 'qty'], quantity: ['数量', 'quantity'],
+    tol: ['容差', 'tol'], tolerance: ['容差', 'tolerance'],
+};
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/** 只在任务里该字段有明确锚点 (字段名/别名 后紧跟数字) 时才取数; 取不到 = 不填, 不编 */
+function anchoredNumber(task, key) {
+    const anchors = [key, ...(NUMBER_ANCHORS[key.toLowerCase()] || [])].filter(Boolean);
+    for (const a of anchors) {
+        const m = task.match(new RegExp(`${escapeRe(a)}[^0-9\\n]{0,6}?(\\d+(?:\\.\\d+)?)`, 'i'));
+        if (m)
+            return Number(m[1]);
+    }
+    return undefined;
+}
 /** 从任务文本 + 契约 inputSchema 推导输入 (确定性; M1 不做语义抽取, 用 --input 兜底) */
 export function deriveSkillInput(contract, task) {
     const schema = contract?.inputSchema || {};
@@ -75,9 +99,9 @@ export function deriveSkillInput(contract, task) {
         const isRequired = required.includes(key);
         const type = String(p.type || 'string');
         if (type === 'number' || type === 'integer') {
-            const n = task.match(/\d+(\.\d+)?/);
-            if (n)
-                out[key] = Number(n[0]); // 任务里真有数字才填 (可选字段也不硬塞)
+            const n = anchoredNumber(task, key); // 任务里该字段有明确锚点才填 (可选字段也不硬塞)
+            if (n !== undefined)
+                out[key] = n;
             continue;
         }
         if (/market|国家|市场|地区|country|region/i.test(key)) {