@bolloon/bolloon-agent 0.4.31 → 0.4.33

package/dist/electron-build/agents/network-pulse.js

@@ -11,6 +11,19 @@
  *   · 快照过期 → `stale` (不许伪装实时); 观察层不可用 → `unavailable`
  *   · 类别小于隐私阈值 → 合并进 other
  *   · 事件数 / 时间窗 / capability 数都有上限
+ *   · **冻结形状 `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 的 "注册总量 / 当前活跃 / 最近出现" 时间窗统计、服务端生成匿名活动文本、
@@ -50,7 +63,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FORBIDDEN_PUBLIC_KEYS = exports.MAX_AGENT_SITES = exports.pulseDir = exports.NETWORK_EVENT_TYPES = exports.PULSE_LIMITS = void 0;
+exports.PUBLIC_HEX_KEYS = exports.FORBIDDEN_PUBLIC_KEYS = exports.OPEN_TASK_KEYS = exports.CHAIN_LABELS = exports.PUBLIC_MAINNET_CHAIN_ID = exports.PUBLIC_TESTNET_CHAIN_ID = exports.PULSE_EVENT_ACTIVITY = exports.CHAIN_EVENT_ACTIVITY = exports.CONFIRMED_ACTIVITY_LIMIT = exports.MAX_OPEN_TASKS = exports.MAX_AGENT_SITES = exports.pulseDir = exports.NETWORK_EVENT_TYPES = exports.PULSE_LIMITS = void 0;
 exports.nodeDigest = nodeDigest;
 exports.capabilityGroup = capabilityGroup;
 exports.bucketOf = bucketOf;
@@ -58,7 +71,22 @@ exports.recordNetworkEvent = recordNetworkEvent;
 exports.renderActivityText = renderActivityText;
 exports.normalizeIpns = normalizeIpns;
 exports.readAgentSites = readAgentSites;
+exports.readOpenTasks = readOpenTasks;
 exports.emitTradePulse = emitTradePulse;
+exports.anonShortRef = anonShortRef;
+exports.isoSeconds = isoSeconds;
+exports.normalizeActivityGates = normalizeActivityGates;
+exports.finalityFromConfirmations = finalityFromConfirmations;
+exports.buildConfirmedActivityFromIndex = buildConfirmedActivityFromIndex;
+exports.buildConfirmedActivityFromEvents = buildConfirmedActivityFromEvents;
+exports.confirmedActivityFromEvents = confirmedActivityFromEvents;
+exports.resolveConfirmedActivity = resolveConfirmedActivity;
+exports.chainLabelOf = chainLabelOf;
+exports.isPublicChainId = isPublicChainId;
+exports.summarizeActivityRows = summarizeActivityRows;
+exports.buildChainIdScope = buildChainIdScope;
+exports.snapshotConsistencyIssues = snapshotConsistencyIssues;
+exports.openTasksIssues = openTasksIssues;
 exports.computeSnapshot = computeSnapshot;
 exports.getNetworkPulse = getNetworkPulse;
 exports.snapshotStatus = snapshotStatus;
@@ -67,10 +95,18 @@ exports.lastSnapshotSignError = lastSnapshotSignError;
 exports.signSnapshot = signSnapshot;
 exports.verifySnapshotSignature = verifySnapshotSignature;
 exports.assertNoPrivateFields = assertNoPrivateFields;
+exports.auditPublicHexLeaks = auditPublicHexLeaks;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const crypto = __importStar(require("crypto"));
+// 确认数门槛来自 chain-config (单一实现; 默认 confirmed=1 / finalized=12) —— 只借常量, 不借 RPC
+const chain_config_js_1 = require("./chain/chain-config.js");
+// 区块浏览器映射 (chainId → 公网浏览器); 认不出的链没有链接 —— 宁缺勿错, 不编死链
+const explorer_js_1 = require("./chain/explorer.js");
+// 「待接单任务」的数据源 = 本机公告板目录 (~/.bolloon/tasks/board)。只借**路径常量**,
+// 公告的解析/发布/接单一律留在 task-board.ts (这里不做第二套实现)。
+const task_board_js_1 = require("./task-board.js");
 // ── 常量 (上限 + 时间边界) ─────────────────────────────────────────────────
 exports.PULSE_LIMITS = {
     /** 最多留多少条事件 (超出丢最旧) */
@@ -89,6 +125,8 @@ exports.PULSE_LIMITS = {
     snapshotTtlMs: 30 * 1000,
     /** 活动流最多几条 */
     maxActivity: 8,
+    /** confirmed_activity (冻结形状的真实活动行) 上限 */
+    maxConfirmedActivity: 25,
 };
 /** 事件类型白名单 —— 只允许这些进统计 (其余一律丢弃) */
 exports.NETWORK_EVENT_TYPES = [
@@ -100,6 +138,8 @@ exports.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';
@@ -212,6 +252,7 @@ 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' };
     }
 }
@@ -261,6 +302,82 @@ function readAgentSites(h) {
         return [];
     }
 }
+/** 上限: 公开页最多列几条待接单任务 (超出按最近截止排序取前 N) */
+exports.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 / 缺字段 → 该条跳过 (一条都不编); 整个目录不可读 → 空数组 + 不抛。
+ */
+function readOpenTasks(h, now = Date.now()) {
+    const out = [];
+    try {
+        const dir = (0, task_board_js_1.boardDir)(h);
+        let names;
+        try {
+            names = fs.readdirSync(dir);
+        }
+        catch {
+            return [];
+        }
+        for (const name of names.slice().sort()) {
+            if (!name.endsWith('.json') || name === `${task_board_js_1.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, exports.MAX_OPEN_TASKS);
+}
 /**
  * 把**真实交易活动**投影成脉冲事件 (由交易写路径调用, fire-and-forget)。
  * 只按事实发: 交付 → task_completed · 真验真 → trade_verified · **链上口径**结算 → trade_settled。
@@ -290,10 +407,472 @@ async function emitTradePulse(before, after, h) {
         /* 统计失败绝不影响交易主路径 */
     }
 }
+// ── 冻结形状: confirmed_activity (真实智能体任务 / 链上活动行) ────────────────
+//
+// 公开网页要能列出「哪个任务 · 什么状态 · 哪个块 · 多少确认」, 而不是只有数字。这块就是那批行。
+// 形状**冻结** (老字段名与取值域不许改), 内容按用途分两类:
+//   · **匿名短写** (老口径, 保留不删): 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): 够不着门槛的行只报
+//   `observed`, **绝不冒充** confirmed/finalized。
+/** 冻结形状: 活动行上限 */
+exports.CONFIRMED_ACTIVITY_LIMIT = exports.PULSE_LIMITS.maxConfirmedActivity;
+/**
+ * 链上 escrow 事件名 → (kind, state) 的**唯一**映射表 (改这里才对, 别在别处写 switch)。
+ *
+ * kind 只能取冻结枚举的 5 个值, 链上有 6 类事件 → 按「任务生命周期 / 托管资金路径」归并:
+ *   · EscrowCreatedV2  委托创建 + 资金入托管              → task_created   / active
+ *   · ProofSubmittedV2 交付物验真摘要落链 (= 该笔交付完成) → task_completed / active (托管仍 ACTIVE, 等结算)
+ *   · ReleasedV2       结算出金                            → trade_settled  / released
+ *   · RefundedV2       托管退款                            → trade_settled  / refunded
+ *   · ExpiredV2        托管到期                            → trade_settled  / expired
+ *   · DisputedV2       资金冻结进入争议 (托管资金路径)      → trade_settled  / disputed
+ * 真信号在 `state` (kind 只是粗桶); 事件名不在表里 → 该条**不成行** (不猜)。
+ */
+exports.CHAIN_EVENT_ACTIVITY = {
+    EscrowCreatedV2: { kind: 'task_created', state: 'active' },
+    ProofSubmittedV2: { kind: 'task_completed', state: 'active' },
+    ReleasedV2: { kind: 'trade_settled', state: 'released' },
+    RefundedV2: { kind: 'trade_settled', state: 'refunded' },
+    ExpiredV2: { kind: 'trade_settled', state: 'expired' },
+    DisputedV2: { kind: 'trade_settled', state: 'disputed' },
+};
+/** 脉冲事件 → 冻结 kind 的映射 (索引不可用时的降级路径; 没有 taskProof 的事件不成行) */
+exports.PULSE_EVENT_ACTIVITY = {
+    task_posted: 'task_created',
+    task_accepted: 'task_accepted',
+    task_completed: 'task_completed',
+    trade_settled: 'trade_settled',
+    trade_verified: 'trade_verified',
+};
+/** 标识 → `sha256:<前 8 位十六进制>`。域标签隔离用途: 同一原值稳定 (可 join), 不同用途不串, 不可逆。 */
+function anonShortRef(value, domain = 'id') {
+    return `sha256:${nodeDigest(`${domain}|${String(value)}`).slice(0, 8)}`;
+}
+/** ISO8601 UTC 秒级 (`2026-09-22T05:31:00Z`) —— 冻结形状里 `at` 的格式。非法时间 → null */
+function isoSeconds(at) {
+    const n = Number(at);
+    if (!Number.isFinite(n) || n <= 0)
+        return null;
+    try {
+        return new Date(n).toISOString().replace(/\.\d{3}Z$/, 'Z');
+    }
+    catch {
+        return null;
+    }
+}
+/** 确认门槛归一化: 缺/非法 → chain-config 默认 (1/12); finalized 不许低于 confirmed */
+function normalizeActivityGates(g) {
+    const c = Number(g?.confirmed);
+    const f = Number(g?.finalized);
+    const confirmed = Number.isInteger(c) && c > 0 ? c : chain_config_js_1.DEFAULT_CONFIRMATIONS.confirmed;
+    const finalized = Number.isInteger(f) && f >= confirmed ? f : Math.max(confirmed, chain_config_js_1.DEFAULT_CONFIRMATIONS.finalized);
+    return { confirmed, finalized };
+}
+/**
+ * finality **只按确认数复算** (单一实现): 够 finalized → finalized; 够 confirmed → confirmed;
+ * 不够 / 非法 / 被回退过 → observed。行里原本自报的 finality 一律不复用 —— 不满足就是 observed。
+ */
+function finalityFromConfirmations(confirmations, gates, opts = {}) {
+    if (opts.suspect)
+        return 'observed';
+    const g = normalizeActivityGates(gates);
+    const c = Number(confirmations);
+    if (!Number.isFinite(c) || c < g.confirmed)
+        return 'observed';
+    return c >= g.finalized ? 'finalized' : 'confirmed';
+}
+function activityLimit(limit) {
+    const n = Math.floor(Number(limit));
+    if (!Number.isFinite(n))
+        return exports.CONFIRMED_ACTIVITY_LIMIT;
+    return Math.max(0, Math.min(exports.CONFIRMED_ACTIVITY_LIMIT, n));
+}
+/**
+ * 链上索引条目 → 冻结活动行 (**纯函数**, 不读盘不发 RPC, 便于单测)。
+ *   · suspect (被回退 / 链上已消失) 的记录**不成行** —— 它已经不在规范链上, 不该当活动列出
+ *   · 不认识的事件名 / 非法 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 行
+ */
+function buildConfirmedActivityFromIndex(entries, opts = {}) {
+    const gates = normalizeActivityGates(opts.gates);
+    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 = explorer_js_1.ADDRESS_RE.test(escrow) ? escrow : '';
+    const out = [];
+    for (const e of Array.isArray(entries) ? entries : []) {
+        if (!e || e.suspect === true)
+            continue; // 回退过的记录不在规范链上 → 不成行
+        const map = exports.CHAIN_EVENT_ACTIVITY[String(e.eventName || '')];
+        if (!map)
+            continue; // 不认识的事件 → 跳过 (不猜)
+        const taskKey = String(e.taskKey || '').toLowerCase();
+        const txHash = String(e.txHash || '').toLowerCase();
+        if (!/^0x[0-9a-f]{64}$/.test(taskKey) || !/^0x[0-9a-f]{64}$/.test(txHash))
+            continue;
+        const block = Number(e.blockNumber);
+        const logIndex = Number(e.logIndex);
+        if (!Number.isInteger(block) || block < 0 || !Number.isInteger(logIndex) || logIndex < 0)
+            continue;
+        const atMs = Number(e.firstSeenAt);
+        const at = isoSeconds(atMs);
+        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 = (0, explorer_js_1.explorerTxUrl)(chainId, txHash);
+        out.push({
+            block, logIndex,
+            row: {
+                task: anonShortRef(taskKey, 'task'),
+                kind: map.kind,
+                state: map.state,
+                chain_id: chainId,
+                block,
+                tx: anonShortRef(txHash, 'tx'),
+                confirmations,
+                finality: finalityFromConfirmations(confirmations, gates),
+                at,
+                // 公开链上事实 (白名单键; 老字段 tx 已在上方保留)
+                tx_hash: txHash,
+                ...(contract ? { contract } : {}),
+                ...(explorerTx ? { explorer_tx: explorerTx } : {}),
+            },
+        });
+    }
+    out.sort((a, b) => b.block - a.block || b.logIndex - a.logIndex);
+    return out.slice(0, limit).map((x) => x.row);
+}
+/**
+ * 脉冲事件 → 冻结活动行 (**纯函数**, 索引不可用时的降级路径)。
+ *   · 只有带 taskProof 的经济事件成行; state 一律 `unknown` —— 脉冲事件不带 escrow 结局, 不推
+ *   · 没有链上事实: chain_id / block / confirmations = 0, finality = observed (绝不冒充已确认)
+ *   · tx = 事件摘要短写 (不是交易哈希 —— 降级行没有 txHash, 字段名冻结只能这样填)
+ *   · 同一 (task, kind) 只留最新一条; 最新在前, 上限 25 行
+ */
+function buildConfirmedActivityFromEvents(events, opts = {}) {
+    const limit = activityLimit(opts.limit);
+    if (limit <= 0)
+        return [];
+    const all = [];
+    for (const e of Array.isArray(events) ? events : []) {
+        if (!isValidEvent(e))
+            continue;
+        const kind = exports.PULSE_EVENT_ACTIVITY[e.type];
+        if (!kind)
+            continue; // 非经济事件 (入网/能力/连接…) → 不成行
+        const proof = String(e.taskProof || '').toLowerCase();
+        if (!/^[0-9a-f]{16}$/.test(proof))
+            continue; // 没有任务摘要 → 不成行
+        const at = isoSeconds(e.occurredAt);
+        if (!at)
+            continue;
+        all.push({
+            at: e.occurredAt,
+            row: {
+                task: `sha256:${proof.slice(0, 8)}`,
+                kind,
+                state: 'unknown',
+                chain_id: 0,
+                block: 0,
+                tx: anonShortRef(`pulse|${e.sourceProof}|${e.occurredAt}|${e.type}`, 'tx'),
+                confirmations: 0,
+                finality: 'observed',
+                at,
+            },
+        });
+    }
+    all.sort((a, b) => b.at - a.at); // 最新在前
+    const seen = new Set();
+    const rows = [];
+    for (const x of all) {
+        const key = `${x.row.task}|${x.row.kind}`;
+        if (seen.has(key))
+            continue; // 同一任务同一动作只留最新一条
+        seen.add(key);
+        rows.push(x.row);
+        if (rows.length >= limit)
+            break;
+    }
+    return rows;
+}
+/** 纯函数降级: 直接从脉冲事件算活动行 (没有索引时用, source 如实写 pulse-events / none) */
+function confirmedActivityFromEvents(events, limit) {
+    const rows = buildConfirmedActivityFromEvents(events, { limit });
+    return { source: rows.length ? 'pulse-events' : 'none', rows, gates: normalizeActivityGates(chain_config_js_1.DEFAULT_CONFIRMATIONS) };
+}
+/** 惰性加载链上索引只读查询模块 (只读索引文件, 不发 RPC; 加载/读取失败 → 降级) */
+let chainQueryModule = null;
+async function readChainIndex(home) {
+    try {
+        if (!chainQueryModule)
+            chainQueryModule = (await Promise.resolve().then(() => __importStar(require('./chain/chain-index-query.js'))));
+        return chainQueryModule.readIndexFile({ home });
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 解析活动行 (唯一入口): **先链上索引, 再脉冲降级**, 并如实报出来源。
+ * 索引文件不存在/读不出/没有任何可用行 → 退回脉冲事件; 两边都没有 → none (不编行)。
+ */
+async function resolveConfirmedActivity(q) {
+    const now = Number(q.now ?? Date.now());
+    const limit = activityLimit(q.limit);
+    const windowed = (Array.isArray(q.events) ? q.events : [])
+        .filter((e) => isValidEvent(e) && e.occurredAt >= now - exports.PULSE_LIMITS.windowMs);
+    // ① 链上索引优先 (真链上事实)
+    const reader = q.readIndex ?? readChainIndex;
+    try {
+        const file = await reader(q.home);
+        const entries = Array.isArray(file?.entries) ? file.entries : [];
+        if (entries.length > 0) {
+            const gates = normalizeActivityGates(file?.confirmations);
+            const rows = buildConfirmedActivityFromIndex(entries, {
+                gates,
+                headBlock: file?.headBlock,
+                chainId: file?.chainId,
+                limit,
+                escrowAddress: file?.escrowAddress, // 合约地址白名单 = 索引文件自己的部署身份
+            });
+            if (rows.length > 0)
+                return { source: 'chain-index', rows, gates };
+        }
+    }
+    catch { /* 索引不可用 → 降级 (来源会在快照里标明) */ }
+    // ② 降级: 脉冲事件
+    return confirmedActivityFromEvents(windowed, limit);
+}
+// ── 同源计数 · 口径说明 · 链归属 (2026-09-22: 公开页数字不许自相矛盾) ──────────
+//
+// 起因: 真快照里 `totals.tasks=0` 而 `confirmed_activity` 有 25 行真实任务 —— 两块数据来自
+// **两套口径** (totals = 24h 脉冲事件窗口; confirmed_activity = 链上索引全量), 但页面上它们同屏,
+// 读者只会读成"自相矛盾/在撒谎"。修法不是把数字改漂亮, 而是:
+//   ① `activity_totals` = 与 confirmed_activity **同源**的计数 (rows 恒等于该数组长度);
+//   ② `totals_scope`   = totals 的口径说明 + `differs_from_activity` 标记;
+//   ③ `chain_id_scope` = 上表各行属于哪条链 (本机 31337 ≠ 真网 Base Sepolia 84532);
+//   ④ `snapshotConsistencyIssues` = 导出前的自检 (两个数字打架就拒绝导出)。
+/** 公网测试网 (Base Sepolia) chainId —— 只做**归属说明**, 不代表快照观察到了公网事件 */
+exports.PUBLIC_TESTNET_CHAIN_ID = 84532;
+/** 公网主网 (Base) chainId —— 同上, 只做归属说明 */
+exports.PUBLIC_MAINNET_CHAIN_ID = 8453;
+/**
+ * chainId → 展示用网络名 (只回答"这一屏的行属于哪条链")。
+ * 认不出的 chain id **不编名字** (chainLabelOf → null), 也不许算成公网。
+ */
+exports.CHAIN_LABELS = {
+    [chain_config_js_1.LOCAL_DEV_CHAIN_ID]: { zh: '本机隔离开发链', en: 'local isolated dev chain', publicNetwork: false },
+    [exports.PUBLIC_TESTNET_CHAIN_ID]: { zh: 'Base Sepolia 测试网', en: 'Base Sepolia testnet', publicNetwork: true },
+    [exports.PUBLIC_MAINNET_CHAIN_ID]: { zh: 'Base 主网', en: 'Base mainnet', publicNetwork: true },
+};
+/** chainId 的展示名; 认不出的 chain id → null (不编名字) */
+function chainLabelOf(chainId) {
+    const id = Number(chainId);
+    return Number.isInteger(id) ? exports.CHAIN_LABELS[id] ?? null : null;
+}
+/** 是不是公网链 id (白名单; 认不出的一律**不算**公网 —— 不替读者认领归属) */
+function isPublicChainId(chainId) {
+    return chainLabelOf(chainId)?.publicNetwork === true;
+}
+/**
+ * 活动行 → 同源计数 (**纯函数**; 输入就是 `confirmed_activity` 本身)。
+ * 存在的唯一理由: 公开页同时显示 totals 与本表行数, 两个数字肉眼可能"打架" ——
+ * 那就让它们同源可核: `activity_totals.rows` 恒等于 `confirmed_activity.length`。
+ */
+function summarizeActivityRows(rows, opts) {
+    const list = (Array.isArray(rows) ? rows : []).filter((r) => !!r);
+    const tasks = new Set();
+    const completed = new Set();
+    const settled = new Set();
+    const by_finality = { observed: 0, confirmed: 0, finalized: 0 };
+    for (const r of list) {
+        const t = String(r.task || '');
+        if (t)
+            tasks.add(t);
+        if (t && r.kind === 'task_completed')
+            completed.add(t);
+        if (t && r.kind === 'trade_settled')
+            settled.add(t);
+        if (r.finality === 'observed' || r.finality === 'confirmed' || r.finality === 'finalized') {
+            by_finality[r.finality] += 1;
+        }
+    }
+    return {
+        source: opts.source,
+        rows: list.length,
+        tasks: tasks.size,
+        tasks_completed: completed.size,
+        tasks_settled: settled.size,
+        by_finality,
+        gates: normalizeActivityGates(opts.gates),
+    };
+}
+/** 活动行 → 链归属 (**纯函数**)。所有结论都从行本身推, 不引用外部状态 → 不可能与行数打架。 */
+function buildChainIdScope(rows) {
+    const list = (Array.isArray(rows) ? rows : []).filter((r) => !!r);
+    const counts = new Map();
+    for (const r of list) {
+        const id = Number(r.chain_id);
+        if (!Number.isInteger(id) || id < 0)
+            continue;
+        counts.set(id, (counts.get(id) || 0) + 1);
+    }
+    const chain_ids = Array.from(counts.keys()).sort((a, b) => a - b);
+    let primary = 0;
+    let best = 0;
+    for (const id of chain_ids) { // 升序遍历 + 严格大于 → 并列取小
+        const c = counts.get(id);
+        if (c > best) {
+            best = c;
+            primary = id;
+        }
+    }
+    const label = chain_ids.length ? chainLabelOf(primary) : null;
+    const publicIds = chain_ids.filter(isPublicChainId);
+    const publicRows = publicIds.reduce((n, id) => n + (counts.get(id) || 0), 0);
+    const pub = exports.CHAIN_LABELS[exports.PUBLIC_TESTNET_CHAIN_ID];
+    // 点名口径: 提示里写出的公网链必须是**行里真出现过的**; 一条都没有才退回对照链
+    // (否则会出现「上表 3 行来自 chainId 8453(Base 主网)」却说「公网链(Base Sepolia 84532) 3 行」的自相矛盾)
+    const pubZh = publicIds.length
+        ? publicIds.map((id) => `${exports.CHAIN_LABELS[id].zh} ${id}`).join('、')
+        : `${pub.zh} ${exports.PUBLIC_TESTNET_CHAIN_ID}`;
+    const pubEn = publicIds.length
+        ? publicIds.map((id) => `${exports.CHAIN_LABELS[id].en} ${id}`).join(', ')
+        : `${pub.en} ${exports.PUBLIC_TESTNET_CHAIN_ID}`;
+    const rows_ = list.length;
+    const multi = chain_ids.length > 1 ? `（上表共 ${chain_ids.length} 条链）` : '';
+    const note = rows_ === 0
+        ? {
+            zh: 'chain_id 归属: 本快照没有链上活动行 —— 不是"链上没事件", 而是这一轮没有可列出的行',
+            en: 'chain_id scope: no on-chain activity row in this snapshot — not "nothing happened on chain", just no listable row this round',
+        }
+        : {
+            zh: `chain_id 归属: 上表 ${rows_} 行来自 chainId ${primary}${label ? `（${label.zh}）` : ''}${multi} · ` +
+                `公网链（${pubZh}）${publicRows} 行` +
+                `${publicRows === 0 ? ' —— 这不是公网活动' : ''}`,
+            en: `chain_id scope: all ${rows_} rows above come from chainId ${primary}${label ? ` (${label.en})` : ''}${chain_ids.length > 1 ? ` (${chain_ids.length} chains in total)` : ''} · ` +
+                `public network (${pubEn}) rows: ${publicRows}` +
+                `${publicRows === 0 ? ' — this is not public-network activity' : ''}`,
+        };
+    return {
+        chain_ids,
+        activity_chain_id: primary,
+        activity_chain_label: label ? { zh: label.zh, en: label.en } : null,
+        is_public_network: chain_ids.length > 0 ? isPublicChainId(primary) : false,
+        public_network_rows: publicRows,
+        public_network: { chain_id: exports.PUBLIC_TESTNET_CHAIN_ID, label: { zh: pub.zh, en: pub.en } },
+        note,
+    };
+}
+/**
+ * 快照自检: 公开页会**同屏展示**的数字之间不许自相矛盾。返回问题清单 (空 = 通过)。
+ *   ① `activity_totals` 必须在 (与行同源的计数不能缺)
+ *   ② `activity_totals.rows` === `confirmed_activity.length`
+ *   ③ `by_finality` 三档之和 === 行数 (没有第四条腿)
+ *   ④ `activity_totals.source` === `confirmed_activity_source` (两块来源标注必须一致)
+ *   ⑤ 行里有任务 而 `totals.tasks === 0` 时, 必须有口径说明 note
+ *      (页面不许出现「0 个任务」与「N 行任务」并存而**不解释**)
+ *   ⑥ 0x 长 hex 越界 (2026-09-23): 只许出现在 tx_hash/contract/explorer_* 四个白名单键下 ——
+ *      EOA 地址跑到别的键 (或白名单键形状不对) 就拒绝导出
+ */
+function snapshotConsistencyIssues(snap) {
+    const issues = [];
+    const rows = Array.isArray(snap?.confirmed_activity) ? snap.confirmed_activity : [];
+    const at = snap?.activity_totals;
+    if (!at || typeof at !== 'object') {
+        return ['activity_totals 缺失 (与 confirmed_activity 同源的计数必须一起给)'];
+    }
+    if (Number(at.rows) !== rows.length)
+        issues.push(`activity_totals.rows=${at.rows} ≠ confirmed_activity.length=${rows.length}`);
+    const bf = at.by_finality || {};
+    const sum = ['observed', 'confirmed', 'finalized'].reduce((n, k) => n + (Number(bf[k]) || 0), 0);
+    if (sum !== rows.length)
+        issues.push(`by_finality 三档之和=${sum} ≠ 行数=${rows.length}`);
+    if (String(at.source || '') !== String(snap?.confirmed_activity_source || '')) {
+        issues.push(`activity_totals.source=${at.source} ≠ confirmed_activity_source=${snap?.confirmed_activity_source}`);
+    }
+    const tasks = Number(at.tasks) || 0;
+    const pulseTasks = Number(snap?.totals?.tasks) || 0;
+    if (rows.length > 0 && tasks > 0 && pulseTasks === 0) {
+        const notes = Array.isArray(snap.notes) ? snap.notes.join(' ') : '';
+        const explained = notes.includes('脉冲事件') && notes.includes(String(rows.length)) &&
+            (notes.includes('链上索引') || notes.includes('chain-index'));
+        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` 逐字一致; 多一个键 = 可能把正文/身份带出去了) */
+exports.OPEN_TASK_KEYS = ['capability', 'budget', 'currency', 'network', 'deadline', 'claimed', 'announcementId'];
+/**
+ * 待接单任务行的自检 (空 = 通过)。这不是格式洁癖, 每条都对着一个真泄漏路径:
+ *   · 键集 ≠ 白名单 → 有人把 instruction / buyerDid / claims 之类**展平**进公开投影了;
+ *   · `claimed !== false` → 「只导出未认领」这个筛选坏了 (页面会把已接单的当待接单);
+ *   · `announcementId` 长于 8 位 → 短写丢了, 原始公告 id 上公开页 (页面上的 id 会被读者当完整 id 用);
+ *   · capability 空 / deadline 非正 → 页面上会出现一条说不出是什么、也不知道何时截止的行。
+ */
+function openTasksIssues(snap) {
+    const out = [];
+    const rows = snap?.open_tasks;
+    if (!Array.isArray(rows))
+        return ['open_tasks 缺失 (公开「待接单任务」必须是数组, 没有就给空数组)'];
+    const allow = exports.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;
+}
 function computeSnapshot(events, opts) {
     const now = opts.now;
     const fresh_until = now + exports.PULSE_LIMITS.snapshotTtlMs;
     if (opts.unavailable) {
+        const emptyRows = [];
+        const gates = normalizeActivityGates(chain_config_js_1.DEFAULT_CONFIRMATIONS);
         return {
             status: 'unavailable',
             generated_at: now,
@@ -301,8 +880,23 @@ function computeSnapshot(events, opts) {
             scope: 'observed',
             scope_label: { zh: '当前节点观察到', en: 'Observed by this node' },
             totals: { nodes: 0, agents: 0, active_agents: 0, seen_last_24h: 0, tasks: 0, tasks_completed: 0, tasks_verified: 0, signatures: 0 },
+            totals_scope: {
+                source: 'pulse-events', window_ms: exports.PULSE_LIMITS.windowMs,
+                label: {
+                    zh: `只统计本节点 ${exports.PULSE_LIMITS.windowMs / 3600000}h 观察窗口内收到的脉冲事件 (本节点自己上报的)`,
+                    en: `Only pulse events received by this node within the ${exports.PULSE_LIMITS.windowMs / 3600000}h observation window (reported by this node itself)`,
+                },
+                differs_from_activity: false,
+            },
             capabilities: [],
             recent_activity: [],
+            confirmed_activity: emptyRows,
+            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: ['观察层暂不可用 — 这不是"网络为空"'],
         };
     }
@@ -365,6 +959,39 @@ function computeSnapshot(events, opts) {
         notes.push('单节点观察: 这是本节点能看到的部分网络, 不是全网精确总量');
     else
         notes.push(`多签名来源汇总 (${signedNodes} 个签名节点)`);
+    // 活动行来源如实标注 (chain-index = 真链上事实; pulse-events = 降级, 非链上确认)
+    const activity = opts.confirmedActivity ?? confirmedActivityFromEvents(window);
+    // 同源计数 + 链归属: **输入就是上表那批行**, 所以不可能与行数/链 id 打架
+    const activity_totals = summarizeActivityRows(activity.rows, { source: activity.source, gates: activity.gates });
+    const chain_id_scope = buildChainIdScope(activity.rows);
+    const totals_scope = {
+        source: 'pulse-events',
+        window_ms: exports.PULSE_LIMITS.windowMs,
+        label: {
+            zh: `只统计本节点 ${exports.PULSE_LIMITS.windowMs / 3600000}h 观察窗口内收到的脉冲事件 (本节点自己上报的)`,
+            en: `Only pulse events received by this node within the ${exports.PULSE_LIMITS.windowMs / 3600000}h observation window (reported by this node itself)`,
+        },
+        differs_from_activity: activity_totals.rows > 0 &&
+            (tasks.size !== activity_totals.tasks || tasksCompleted.size !== activity_totals.tasks_completed),
+    };
+    if (activity.source === 'chain-index') {
+        notes.push(`confirmed_activity 来自链上索引 (chain-index): ${activity_totals.rows} 行 · ${activity_totals.tasks} 个不同任务 · ` +
+            `finality 分布 observed=${activity_totals.by_finality.observed} / confirmed=${activity_totals.by_finality.confirmed} / ` +
+            `finalized=${activity_totals.by_finality.finalized} (三档之和 = 行数); 最新在前, 上限 ${exports.CONFIRMED_ACTIVITY_LIMIT} 行; ` +
+            `确认门槛 confirmed=${activity.gates.confirmed} · finalized=${activity.gates.finalized}`);
+    }
+    else if (activity.source === 'pulse-events') {
+        notes.push('confirmed_activity 降级为脉冲事件 (pulse-events): 非链上确认 —— chain_id/block/confirmations=0 且 finality=observed');
+    }
+    // 两套计数口径不同时**必须**解释 —— 页面不许出现「0 个任务」与「N 行任务」并存而不解释
+    if (totals_scope.differs_from_activity) {
+        notes.push(`口径不同, 不是数据丢失: totals.tasks/tasks_completed/tasks_verified/signatures 只数本节点 ` +
+            `${exports.PULSE_LIMITS.windowMs / 3600000}h 窗口内的脉冲事件 (本快照 tasks=${tasks.size} · tasks_completed=${tasksCompleted.size} · ` +
+            `tasks_verified=${tasksVerified.size} · signatures=${signatureKeys.size}); 上表 ${activity_totals.rows} 行来自链上索引 ` +
+            `(全量, 不是 ${exports.PULSE_LIMITS.windowMs / 3600000}h 窗口) —— 同源计数见 activity_totals`);
+    }
+    if (activity_totals.rows > 0)
+        notes.push(chain_id_scope.note.zh);
     return {
         status: 'live',
         generated_at: now,
@@ -383,8 +1010,14 @@ function computeSnapshot(events, opts) {
             tasks_verified: tasksVerified.size,
             signatures: signatureKeys.size, // 真实签名次数 (只计数)
         },
+        totals_scope,
         capabilities,
         recent_activity: recent,
+        confirmed_activity: activity.rows,
+        confirmed_activity_source: activity.source,
+        activity_totals,
+        chain_id_scope,
+        open_tasks: Array.isArray(opts.openTasks) ? opts.openTasks : [],
         notes,
     };
 }
@@ -396,7 +1029,16 @@ async function getNetworkPulse(opts = {}) {
     if (!opts.force) {
         try {
             const cached = JSON.parse(fs.readFileSync(snapshotFile(opts.home), 'utf-8'));
-            if (cached && Number.isFinite(cached.generated_at) && cached.generated_at + exports.PULSE_LIMITS.snapshotTtlMs > now)
+            // 老版本写的缓存缺冻结字段 `confirmed_activity` (或后来的 totals_scope / activity_totals /
+            // chain_id_scope) → 视为**过期形状**, 重算 (不能把缺字段的快照发出去 ——
+            // 缺 activity_totals 就会在页面上重新变成"两个数字打架"
+            const shapeOk = Array.isArray(cached?.confirmed_activity)
+                && typeof cached?.confirmed_activity_source === 'string'
+                && !!cached?.totals_scope
+                && !!cached?.activity_totals
+                && !!cached?.chain_id_scope
+                && Array.isArray(cached?.open_tasks); // 老缓存没有待接单任务 → 过期形状, 重算
+            if (shapeOk && cached && Number.isFinite(cached.generated_at) && cached.generated_at + exports.PULSE_LIMITS.snapshotTtlMs > now)
                 return cached;
         }
         catch { /* 无缓存 */ }
@@ -408,7 +1050,10 @@ async function getNetworkPulse(opts = {}) {
     catch (e) {
         return computeSnapshot([], { now, unavailable: true });
     }
-    const snap = computeSnapshot(events, { now });
+    // 活动行优先取 P5 链上索引 (真链上事实); 索引不可用 → 退回脉冲事件, 并在快照里标出来源
+    const confirmedActivity = await resolveConfirmedActivity({ home: opts.home, events, now });
+    // 待接单任务: 只读本机公告板目录 (未认领且未过期), 投影成白名单 7 字段 —— 与脉冲事件层无关
+    const snap = computeSnapshot(events, { now, confirmedActivity, openTasks: readOpenTasks(opts.home, now) });
     try {
         fs.mkdirSync((0, exports.pulseDir)(opts.home), { recursive: true });
         fs.writeFileSync(snapshotFile(opts.home), JSON.stringify(snap), 'utf8');
@@ -501,4 +1146,49 @@ function assertNoPrivateFields(value, at = '$') {
     walk(value, at);
     return issues;
 }
+/**
+ * 允许出现 0x 长 hex 的键 (**唯一白名单**, 2026-09-23 leo 拍板; 同日收窄): 交易哈希 / escrow 合约地址 /
+ * 交易浏览器链接 —— 都是公开链上事实。除了这 3 个键, 别处出现 0x 长 hex (尤其 EOA 钱包地址) 一律算泄露。
+ * 注意 `contract` **只在数据里**(供索引/诊断), 页面不渲染合约地址也不给合约链接 ⇒ 没有 `explorer_contract` 这个键。
+ */
+exports.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 都不许」。
+ */
+function auditPublicHexLeaks(value, at = '$') {
+    const issues = [];
+    const allow = exports.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' && explorer_js_1.TX_HASH_RE.test(s))
+                || (key === 'contract' && explorer_js_1.ADDRESS_RE.test(s))
+                || (key === 'explorer_tx' && explorer_js_1.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;
+}
 //# sourceMappingURL=network-pulse.js.map