@bolloon/bolloon-agent 0.4.32 → 0.5.0

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';
@@ -87,7 +103,34 @@ function writeEvents(list, h) {
         /* 统计失败绝不影响主路径 */
     }
 }
-// ── 匿名化 ──────────────────────────────────────────────────────────────────
+export function tallySignatureAudit(h, opts = {}) {
+    const now = opts.now ?? Date.now();
+    const windowMs = opts.windowMs ?? PULSE_LIMITS.windowMs;
+    const file = path.join(home(h), '.bolloon', 'wallet-signatures.jsonl');
+    if (!fs.existsSync(file))
+        return { available: false, count: 0, window_ms: windowMs };
+    let count = 0;
+    try {
+        for (const line of fs.readFileSync(file, 'utf8').split('\n')) {
+            if (!line.trim())
+                continue;
+            let row = null;
+            try {
+                row = JSON.parse(line);
+            }
+            catch {
+                continue;
+            } // 坏行跳过, 不让一行坏数据毁掉整个计数
+            const at = Number(row?.at);
+            if (Number.isFinite(at) && at >= now - windowMs)
+                count += 1;
+        }
+    }
+    catch {
+        return { available: false, count: 0, window_ms: windowMs };
+    }
+    return { available: true, count, window_ms: windowMs };
+}
 /** 节点摘要: sha256(值) 前 16 位。不可逆, 不暴露原值。 */
 export function nodeDigest(value) {
     return crypto.createHash('sha256').update(`bolloon-pulse|${String(value)}`).digest('hex').slice(0, 16);
@@ -167,6 +210,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 +260,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 +368,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 +463,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 +472,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 +495,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 +513,10 @@ export function buildConfirmedActivityFromIndex(entries, opts = {}) {
                 confirmations,
                 finality: finalityFromConfirmations(confirmations, gates),
                 at,
+                // 公开链上事实 (白名单键; 老字段 tx 已在上方保留)
+                tx_hash: txHash,
+                ...(contract ? { contract } : {}),
+                ...(explorerTx ? { explorer_tx: explorerTx } : {}),
             },
         });
     }
@@ -471,6 +614,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 +753,10 @@ 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 地址跑到别的键 (或白名单键形状不对) 就拒绝导出
+ *   ⑧ ★ **同一概念不许并排两个数** (2026-09-24, 见 `totalsScopeIssues`): 顶部计数与表格行数/
+ *      同源计数矛盾, 或者某个数没有来源却不标「未接入」→ 拒绝导出 (这道门在 UI 侧还有一份镜像)
  */
 export function snapshotConsistencyIssues(snap) {
     const issues = [];
@@ -635,28 +783,258 @@ export function snapshotConsistencyIssues(snap) {
         if (!explained)
             issues.push(`totals.tasks=0 与 ${rows.length} 行任务并存, 却没有口径说明 note`);
     }
+    issues.push(...auditPublicHexLeaks(snap)); // ⑥ 0x 长 hex 越界 → 拒绝导出 (不静默放行)
+    issues.push(...openTasksIssues(snap)); // ⑦ 待接单任务的字段白名单与「只含未认领」不变式
+    issues.push(...totalsScopeIssues(snap)); // ⑧ ★ 同一概念不得并排两个数 (顶部 vs 表格)
     return issues;
 }
+/** 顶部逐字段口径的键 (与 `TotalsFieldKey` 逐字一致; 少一个 = 那个数没有来源说明) */
+export const TOTALS_FIELD_KEYS = [
+    'nodes', 'agents', 'active_agents', 'seen_last_24h',
+    'tasks', 'tasks_completed', 'tasks_verified', 'tasks_settled', 'signatures',
+];
+const TOTALS_FIELD_SOURCES = ['pulse-events', 'chain-index', 'signature-audit', 'none'];
+const TOTALS_FIELD_WINDOWS = ['window-24h', 'full', 'unknown'];
+/** 「未接入」类措辞 (无源时必须出现, 否则等于没说清为什么没有数) */
+const UNAVAILABLE_WORDS = /未接入|not connected|无可用源|no available source/;
+/**
+ * ★ 新不变量门 (2026-09-24 leo:「数量怎么对不上」): **同一概念不许并排两个数**。
+ *
+ * 检查的是「页面会把它们放在同一屏里」的那几个数 —— 它们的口径必须各自挂得住:
+ *   ① 逐字段口径 `totals_scope.fields` 九个键必须齐 (source/window/short/label 双语都在) ——
+ *      缺了就只能靠 notes 辩解, 而那正是当初「顶部 0 个任务 vs 表格 25 行」能上线的路径;
+ *   ② 值 `null` ⇔ 口径标 `none` + 明说「未接入」; **有源却不给数** 或 **无源却拿 0 冒充** 都算矛盾;
+ *   ③ 同一概念对账 (表里有 5 个任务而顶部写 0 任务 → 判红):
+ *        · 链上索引可用时, 顶部 tasks/tasks_completed/tasks_settled **必须逐字等于** activity_totals
+ *          的同名字段 (同源即恒等, 任何解释都救不了);
+ *        · 表格行数/同源计数非零而顶部为 0 或缺值 → 必须有口径说明 (note 里写清) 才放行;
+ *        · 顶部说有 N 个任务而表格一行都没有 (反向矛盾) → 同样判红。
+ *   `status === 'unavailable'` 的整份快照不发布任何计数 (页面整块显示「快照读不到」), 故只查形状。
+ */
+export function totalsScopeIssues(snap) {
+    const out = [];
+    const t = snap?.totals || {};
+    const ts = snap?.totals_scope;
+    const at = snap?.activity_totals || {};
+    const rows = Array.isArray(snap?.confirmed_activity) ? snap.confirmed_activity : [];
+    const unavailableSnap = String(snap?.status || '') === 'unavailable';
+    if (!ts || typeof ts !== 'object')
+        return ['totals_scope 缺失 (顶部计数的口径必须随快照一起给)'];
+    if (!ts.fields || typeof ts.fields !== 'object') {
+        return ['totals_scope.fields 缺失 (顶部每个数都要能就地说明来自哪 —— 不许只靠 notes 辩解)'];
+    }
+    // ① 形状: 九个键齐 + 每个键的 source/window/short/label 都合法
+    for (const k of TOTALS_FIELD_KEYS) {
+        const f = ts.fields[k];
+        if (!f || typeof f !== 'object') {
+            out.push(`totals_scope.fields.${k} 缺失`);
+            continue;
+        }
+        if (!TOTALS_FIELD_SOURCES.includes(f.source))
+            out.push(`totals_scope.fields.${k}.source=${JSON.stringify(f.source)} 不在白名单`);
+        if (!TOTALS_FIELD_WINDOWS.includes(f.window))
+            out.push(`totals_scope.fields.${k}.window=${JSON.stringify(f.window)} 不在白名单`);
+        if (!f.label?.zh || !f.label?.en)
+            out.push(`totals_scope.fields.${k}.label 必须双语都给`);
+        if (!f.short?.zh || !f.short?.en)
+            out.push(`totals_scope.fields.${k}.short 必须双语都给 (页面要就地贴在数字旁)`);
+    }
+    if (out.length)
+        return out; // 形状都不对就不往下算数
+    if (!unavailableSnap) {
+        // ② 值 ⇔ 口径 (null = 未接入; 有源必须有数; 无源不许给 0)
+        for (const k of TOTALS_FIELD_KEYS) {
+            const f = ts.fields[k];
+            const v = t[k];
+            const isNull = v === null || v === undefined;
+            if (isNull) {
+                if (f.source !== 'none') {
+                    out.push(`totals.${k} 没有值 (未接入) 却标了源 ${f.source} —— 有源就必须给真值, 没源就标 none`);
+                }
+                if (!UNAVAILABLE_WORDS.test(`${f.short?.zh}${f.short?.en}${f.label?.zh}${f.label?.en}`)) {
+                    out.push(`totals.${k} 没有值却没有一句「未接入」说明 (读者会把空白读成 0)`);
+                }
+            }
+            else {
+                if (typeof v !== 'number' || !Number.isFinite(v) || v < 0) {
+                    out.push(`totals.${k}=${JSON.stringify(v)} 不是非负有限数`);
+                }
+                else if (f.source === 'none') {
+                    out.push(`totals.${k}=${v} 却标「无源」 —— 不许拿裸 0 冒充「没有接入」(那会被读成"没发生过")`);
+                }
+            }
+        }
+        // ③ 同一概念对账 (顶部计数 vs 表格行数/同源计数)
+        const notes = Array.isArray(snap.notes) ? snap.notes.join(' ') : '';
+        const pairs = [
+            ['tasks', t.tasks, at.tasks],
+            ['tasks_completed', t.tasks_completed, at.tasks_completed],
+            ['tasks_settled', t.tasks_settled, at.tasks_settled],
+        ];
+        const tableRows = Number(at.rows) || rows.length;
+        const sameSourceChain = String(at.source) === 'chain-index';
+        // ⑨ 声明与能力不符: 某字段自称「链上索引」口径, 而这一份快照的链上索引根本不可用 ——
+        //    那就是替一个不存在的源背书 (页面会写「链上索引·全量」, 而索引这一份没读出来)。
+        //    注: 本块必须放在 pairs / sameSourceChain 之后 (先声明后使用, 否则 TDZ 崩)。
+        if (!sameSourceChain) {
+            for (const [k] of pairs) {
+                const f = ts.fields[k];
+                if (f.source === 'chain-index') {
+                    out.push(`totals_scope.fields.${k}.source='chain-index' 而这一份快照的链上索引不可用 ` +
+                        `(activity_totals.source=${JSON.stringify(at.source)}) —— 声明与能力不符`);
+                }
+            }
+        }
+        for (const [k, top, src] of pairs) {
+            const n = Number(src) || 0;
+            const topN = (top === null || top === undefined) ? null : Number(top);
+            const topScope = ts.fields[k];
+            if (sameSourceChain && topScope.source === 'chain-index') {
+                // 同源: 必须逐字相等, 不需要任何"解释"
+                if (topN !== n) {
+                    out.push(`同一概念两个数: 顶部 totals.${k}=${topN === null ? '未接入' : topN} ≠ 链上索引同源计数 activity_totals.${k}=${n}` +
+                        ` (表格 ${tableRows} 行) —— 同源即恒等, 页面并排出现两个数就是矛盾`);
+                }
+                continue;
+            }
+            if (n > 0 && (topN === null || topN === 0)) {
+                const explained = notes.includes('口径') && notes.includes(String(tableRows)) && notes.includes('脉冲事件');
+                if (!explained) {
+                    out.push(`顶部 totals.${k}=${topN === null ? '未接入' : 0} 与表格里的 ${n} 个同类 (${tableRows} 行) 矛盾, 且没有任何口径说明`);
+                }
+            }
+            if (topN !== null && n === 0 && tableRows === 0 && topN > 0) {
+                out.push(`顶部 totals.${k}=${topN} 而表格一行都没有 (${tableRows} 行) —— 反向矛盾: 数不出行却报了数`);
+            }
+        }
+    }
+    // ④ 明说"数字不一样"时必须有解释 (老规矩保留; 不许只靠一句 label)
+    if (ts.differs_from_activity === true) {
+        const notes = Array.isArray(snap.notes) ? snap.notes.join(' ') : '';
+        if (!notes.includes('口径'))
+            out.push('totals_scope.differs_from_activity=true 但 notes 里没有任何口径说明');
+    }
+    return out;
+}
+/** 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;
+}
+// ── 顶部计数的逐字段口径 (2026-09-24) ────────────────────────────────────────
+// 页面把 8~9 个数字并排放在**一行**里, 一行一个总口径是解释不了它们的 —— 每个数必须自带来源。
+const WINDOW_HOURS = Math.round(PULSE_LIMITS.windowMs / 3600000);
+/** 「本节点 N h 脉冲事件」口径 (节点/智能体类计数, 以及链上索引不可用时的降级口径) */
+function pulseField(what) {
+    return {
+        source: 'pulse-events',
+        window: 'window-24h',
+        short: { zh: `${WINDOW_HOURS}h 脉冲`, en: `${WINDOW_HOURS}h pulse` },
+        label: {
+            zh: `本节点 ${WINDOW_HOURS}h 观察窗口内收到的脉冲事件 · ${what.zh}`,
+            en: `pulse events received by this node within the ${WINDOW_HOURS}h window · ${what.en}`,
+        },
+    };
+}
+/** 「链上索引 · 全量」口径 (与下方活动表**同源**: 同源即恒等, 页面不许并排两个数) */
+function chainField(what) {
+    return {
+        source: 'chain-index',
+        window: 'full',
+        short: { zh: '链上索引·全量', en: 'chain index · whole' },
+        label: {
+            zh: `链上索引全量 (与下方活动表同源) · ${what.zh}`,
+            en: `chain index, whole (same source as the activity table below) · ${what.en}`,
+        },
+    };
+}
+/** 「本机签名审计账」口径 (真源: `<home>/.bolloon/wallet-signatures.jsonl` 窗口内条数) */
+function signatureAuditField() {
+    return {
+        source: 'signature-audit',
+        window: 'window-24h',
+        short: { zh: `${WINDOW_HOURS}h 签名审计`, en: `${WINDOW_HOURS}h signature audit` },
+        label: {
+            zh: `本机签名审计账 (wallet-signatures.jsonl) ${WINDOW_HOURS}h 内条数 —— 只数条数, 不含签名内容`,
+            en: `rows in this node's signature audit log (wallet-signatures.jsonl) within ${WINDOW_HOURS}h — count only, no content`,
+        },
+    };
+}
+/** 「没有可用源」= 未接入 (值必须是 null; 页面必须写「未接入」, 不许拿 0 冒充「没发生过」) */
+function noneField(why) {
+    return {
+        source: 'none',
+        window: 'unknown',
+        short: { zh: '未接入', en: 'not connected' },
+        label: { zh: `没有可用源 → 报「未接入」而不是 0 · ${why.zh}`, en: `no available source → reported as "not connected", not 0 · ${why.en}` },
+        unavailable: true,
+    };
+}
 export function computeSnapshot(events, opts) {
     const now = opts.now;
     const fresh_until = now + PULSE_LIMITS.snapshotTtlMs;
     if (opts.unavailable) {
         const emptyRows = [];
         const gates = normalizeActivityGates(DEFAULT_CONFIRMATIONS);
+        // 观察层不可用 = **没有数** (不是 0): 计数一律 null/0 占位由页面整块隐藏, 口径逐字段标「未接入」。
+        const downField = noneField({ zh: '观察层不可用', en: 'observation layer unavailable' });
         return {
             status: 'unavailable',
             generated_at: now,
             fresh_until,
             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: {
+                nodes: 0, agents: 0, active_agents: 0, seen_last_24h: 0,
+                tasks: null, tasks_completed: null, tasks_verified: null, signatures: null, tasks_settled: null,
+            },
             totals_scope: {
                 source: 'pulse-events', window_ms: PULSE_LIMITS.windowMs,
                 label: {
-                    zh: `只统计本节点 ${PULSE_LIMITS.windowMs / 3600000}h 观察窗口内收到的脉冲事件 (本节点自己上报的)`,
-                    en: `Only pulse events received by this node within the ${PULSE_LIMITS.windowMs / 3600000}h observation window (reported by this node itself)`,
+                    zh: `本节点 ${WINDOW_HOURS}h 观察窗口的脉冲事件层不可用 → 没有数 (不是 0)`,
+                    en: `This node's ${WINDOW_HOURS}h pulse layer is unavailable → no counts (not zero)`,
                 },
                 differs_from_activity: false,
+                fields: {
+                    nodes: downField, agents: downField, active_agents: downField, seen_last_24h: downField,
+                    tasks: downField, tasks_completed: downField, tasks_verified: downField,
+                    tasks_settled: downField, signatures: downField,
+                },
             },
             capabilities: [],
             recent_activity: [],
@@ -664,6 +1042,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: ['观察层暂不可用 — 这不是"网络为空"'],
         };
     }
@@ -695,10 +1076,13 @@ export function computeSnapshot(events, opts) {
         capabilities.push({ key: 'other', count: otherCount.size });
         capabilities.sort((a, b) => b.count - a.count || (a.key < b.key ? -1 : 1));
     }
-    // 经济计数: 按**不同任务**去重 (同一任务重复事件不虚增), 且只给聚合数不给内容
+    // 经济计数 (**脉冲口径**) —— 注意: 顶部「任务/已完成/已结算」的**权威源是链上索引**
+    // (见下面 chainAuthoritative 那一段), 脉冲口径只在索引不可用时才顶上去。
+    // 按**不同任务**去重 (同一任务重复事件不虚增), 且只给聚合数不给内容
     const tasks = new Set();
     const tasksCompleted = new Set();
     const tasksVerified = new Set();
+    const tasksSettledPulse = new Set();
     for (const e of window) {
         const t = e.taskProof;
         if (!t)
@@ -707,6 +1091,8 @@ export function computeSnapshot(events, opts) {
             tasks.add(t);
         if (e.type === 'task_completed' || e.type === 'trade_settled')
             tasksCompleted.add(t);
+        if (e.type === 'trade_settled')
+            tasksSettledPulse.add(t);
         if (e.type === 'trade_verified')
             tasksVerified.add(t);
     }
@@ -731,15 +1117,62 @@ export function computeSnapshot(events, opts) {
     // 同源计数 + 链归属: **输入就是上表那批行**, 所以不可能与行数/链 id 打架
     const activity_totals = summarizeActivityRows(activity.rows, { source: activity.source, gates: activity.gates });
     const chain_id_scope = buildChainIdScope(activity.rows);
+    // ★ 2026-09-24 (leo: 「数量怎么对不上, 尤其是后面的任务和钱包」):
+    //   顶部任务类计数的**权威源改成链上索引** —— 它与下面那张表**同源**, 同源即恒等,
+    //   从根上消灭「顶部 0 个任务 / 表格 15 行任务」这种并排矛盾 (不再靠 notes 辩解)。
+    //   链上索引不可用 (降级 pulse-events) 时才退回旧的脉冲口径, 并在 fields 里如实标出降级。
+    const chainAuthoritative = activity.source === 'chain-index';
+    const totalsTasks = chainAuthoritative ? activity_totals.tasks : tasks.size;
+    const totalsCompleted = chainAuthoritative ? activity_totals.tasks_completed : tasksCompleted.size;
+    const totalsSettled = chainAuthoritative ? activity_totals.tasks_settled : tasksSettledPulse.size;
+    // 「验真」在链上索引里**没有**对应事件 → 链上口径下这个数没有源 (null + 未接入), 不拿结算数冒充已验证
+    const totalsVerified = chainAuthoritative ? null : tasksVerified.size;
+    // 钱包签名: 真源 = 本机签名审计账 (窗口内条数, 只计数); 没有审计账 → 退回脉冲事件上报数;
+    // 两个都没有 → null (未接入)。**绝不**在没有源的时候报 0 (那是「没发生过」, 是另一句话)。
+    const sigTally = opts.signatureAudit ?? null;
+    const auditWired = !!sigTally && sigTally.available === true;
+    const totalsSignatures = auditWired
+        ? Number(sigTally.count)
+        : (signatureKeys.size > 0 ? signatureKeys.size : null);
+    const fields = {
+        nodes: pulseField({ zh: '不同节点数', en: 'distinct nodes' }),
+        agents: pulseField({ zh: '不同 Agent 数', en: 'distinct agents' }),
+        active_agents: pulseField({ zh: '活跃 Agent 数', en: 'active agents' }),
+        seen_last_24h: pulseField({ zh: '24h 内出现过的不同 Agent', en: 'distinct agents seen within 24h' }),
+        tasks: chainAuthoritative
+            ? chainField({ zh: '有链上活动的不同任务', en: 'distinct tasks with on-chain activity' })
+            : pulseField({ zh: '观察到发起的任务', en: 'tasks observed as created' }),
+        tasks_completed: chainAuthoritative
+            ? chainField({ zh: '交付完成 (ProofSubmittedV2) 的不同任务', en: 'distinct tasks with ProofSubmittedV2' })
+            : pulseField({ zh: '交付完成的任务', en: 'tasks observed as completed' }),
+        tasks_settled: chainAuthoritative
+            ? chainField({ zh: '托管结算 (Released/Refunded/Expired/Disputed) 的不同任务', en: 'distinct tasks with an on-chain escrow settlement' })
+            : pulseField({ zh: '链上口径结算的任务', en: 'tasks with on-chain settlement' }),
+        tasks_verified: chainAuthoritative
+            ? noneField({ zh: '链上索引没有「验真」事件', en: 'the chain index has no verification event' })
+            : pulseField({ zh: '真验真 (trade_verified) 的任务', en: 'tasks truly verified (trade_verified)' }),
+        signatures: auditWired
+            ? signatureAuditField()
+            : (signatureKeys.size > 0
+                ? pulseField({ zh: '上报过的钱包签名 (按来源+时刻去重)', en: 'reported wallet signatures (deduped by source+time)' })
+                : noneField({ zh: '本节点既没有签名审计账, 也没有签名脉冲事件', en: 'this node has neither a signature audit log nor signature pulse events' })),
+    };
     const totals_scope = {
-        source: 'pulse-events',
+        source: chainAuthoritative ? 'mixed' : 'pulse-events',
         window_ms: PULSE_LIMITS.windowMs,
         label: {
-            zh: `只统计本节点 ${PULSE_LIMITS.windowMs / 3600000}h 观察窗口内收到的脉冲事件 (本节点自己上报的)`,
-            en: `Only pulse events received by this node within the ${PULSE_LIMITS.windowMs / 3600000}h observation window (reported by this node itself)`,
+            zh: chainAuthoritative
+                ? `节点/智能体 = 本节点 ${WINDOW_HOURS}h 脉冲事件; 任务/已完成/已结算 = 链上索引全量 (与下表同源); 钱包签名 = 本机签名审计`
+                : `只统计本节点 ${WINDOW_HOURS}h 观察窗口内收到的脉冲事件 (本节点自己上报的)`,
+            en: chainAuthoritative
+                ? `nodes/agents = this node's ${WINDOW_HOURS}h pulse events; tasks/completed/settled = chain index, whole (same source as the table below); wallet signatures = this node's signature audit log`
+                : `Only pulse events received by this node within the ${WINDOW_HOURS}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),
+            (totalsTasks !== activity_totals.tasks ||
+                totalsCompleted !== activity_totals.tasks_completed ||
+                totalsSettled !== activity_totals.tasks_settled),
+        fields,
     };
     if (activity.source === 'chain-index') {
         notes.push(`confirmed_activity 来自链上索引 (chain-index): ${activity_totals.rows} 行 · ${activity_totals.tasks} 个不同任务 · ` +
@@ -752,10 +1185,21 @@ export function computeSnapshot(events, opts) {
     }
     // 两套计数口径不同时**必须**解释 —— 页面不许出现「0 个任务」与「N 行任务」并存而不解释
     if (totals_scope.differs_from_activity) {
-        notes.push(`口径不同, 不是数据丢失: totals.tasks/tasks_completed/tasks_verified/signatures 只数本节点 ` +
-            `${PULSE_LIMITS.windowMs / 3600000}h 窗口内的脉冲事件 (本快照 tasks=${tasks.size} · tasks_completed=${tasksCompleted.size} · ` +
-            `tasks_verified=${tasksVerified.size} · signatures=${signatureKeys.size}); 上表 ${activity_totals.rows} 行来自链上索引 ` +
-            `(全量, 不是 ${PULSE_LIMITS.windowMs / 3600000}h 窗口) —— 同源计数见 activity_totals`);
+        notes.push(`口径不同, 不是数据丢失: 链上索引不可用 → 顶部任务类计数**降级为脉冲口径** (本快照 tasks=${tasks.size} · ` +
+            `tasks_completed=${tasksCompleted.size} · tasks_verified=${tasksVerified.size} · tasks_settled=${tasksSettledPulse.size} · ` +
+            `signatures=${signatureKeys.size}); 上表 ${activity_totals.rows} 行来自脉冲事件 (同源计数见 activity_totals, ` +
+            `不是链上索引全量) —— 每个数的来源见 totals_scope.fields`);
+    }
+    if (chainAuthoritative) {
+        notes.push(`顶部「任务/已完成/已结算」= 链上索引的**同源计数** (= activity_totals, 与下表同源, 同源即恒等): ` +
+            `tasks=${totalsTasks} · tasks_completed=${totalsCompleted} · tasks_settled=${totalsSettled}; ` +
+            `「节点/智能体」= 本节点 ${WINDOW_HOURS}h 脉冲事件; 「已验证」在链上索引里没有对应事件 → ` +
+            `该口径无对应事件源, 不下发该字段 (不是 0); 「钱包签名」= ${auditWired
+                ? `本机签名审计账 ${totalsSignatures} 条 (${WINDOW_HOURS}h 窗口, 只计数)`
+                : (totalsSignatures === null
+                    ? '无可用源 (本节点既没有签名审计账, 也没有签名脉冲事件), 不下发该字段'
+                    : `脉冲事件上报 ${totalsSignatures} 条`)} — ` +
+            `每个数的来源见 totals_scope.fields`);
     }
     if (activity_totals.rows > 0)
         notes.push(chain_id_scope.note.zh);
@@ -772,10 +1216,12 @@ export function computeSnapshot(events, opts) {
             agents: agents.size,
             active_agents: active.size,
             seen_last_24h: agents.size, // 24h 窗口内的不同 Agent
-            tasks: tasks.size, // 观察到发起的任务数 (聚合, 无内容)
-            tasks_completed: tasksCompleted.size,
-            tasks_verified: tasksVerified.size,
-            signatures: signatureKeys.size, // 真实签名次数 (只计数)
+            // ★ 任务类计数 = 链上索引同源值 (与下表恒等); 索引不可用才退回脉冲口径 (见 fields.tasks)
+            tasks: totalsTasks,
+            tasks_completed: totalsCompleted,
+            tasks_verified: totalsVerified, // 链上口径下 = null (未接入), 不冒充 0
+            signatures: totalsSignatures, // 真源 = 本机签名审计账; 无源 = null (未接入)
+            tasks_settled: totalsSettled, // 新增字段一律排最后 (老 8 个字段顺序逐字不变)
         },
         totals_scope,
         capabilities,
@@ -784,6 +1230,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,
     };
 }
@@ -801,8 +1248,10 @@ export async function getNetworkPulse(opts = {}) {
             const shapeOk = Array.isArray(cached?.confirmed_activity)
                 && typeof cached?.confirmed_activity_source === 'string'
                 && !!cached?.totals_scope
+                && !!cached?.totals_scope?.fields // 老缓存没有逐字段口径 → 过期形状, 重算
                 && !!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 +1266,11 @@ export async function getNetworkPulse(opts = {}) {
     }
     // 活动行优先取 P5 链上索引 (真链上事实); 索引不可用 → 退回脉冲事件, 并在快照里标出来源
     const confirmedActivity = await resolveConfirmedActivity({ home: opts.home, events, now });
-    const snap = computeSnapshot(events, { now, confirmedActivity });
+    // 钱包签名的**真源**: 本机签名审计账 (窗口内条数)。没有账 → 注入 available:false → 快照标「未接入」
+    // (不拿 0 冒充「没发生过」: 本机明明签过而脉冲事件丢了的那次真事故就是这么来的)
+    const signatureAudit = tallySignatureAudit(opts.home, { now, windowMs: PULSE_LIMITS.windowMs });
+    // 待接单任务: 只读本机公告板目录 (未认领且未过期), 投影成白名单 7 字段 —— 与脉冲事件层无关
+    const snap = computeSnapshot(events, { now, confirmedActivity, openTasks: readOpenTasks(opts.home, now), signatureAudit });
     try {
         fs.mkdirSync(pulseDir(opts.home), { recursive: true });
         fs.writeFileSync(snapshotFile(opts.home), JSON.stringify(snap), 'utf8');
@@ -910,3 +1363,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;
+}