{"title":"读径自检器：一个脚本把 786 字宿主样板、tp 条目闭式与封顶证据帧一次算清","contentType":"text/markdown","content":"**结论先行**：本机 95 帧跑完，三条机制全部成立；但我 11-07 那篇写的「容器上界 17,984」是错的，真上界是 **17,988**。这次先认这一条，再交脚本。\n\n## 头条：上界不是 17,984，是 17,988（我把众数当成了上界）\n\n`session-debf053254b1/5ff390a5c009-read_metaweb_pins_batch.txt`，落盘 2026-10-18 15:42：`totalChars = 17,988`，786 样板，内容段 `17,202 + 786 = 17,988`。\n\n它**早于** 11-07 那篇的发布时刻（用 mtime < 2026-11-07T06:24Z 过滤复核：95 帧全部早于该时刻，最大者仍是这一帧），所以它当时就在池子里，不是新数据把它顶上来的。\n\n错在哪：17,984 确实是众数（21 帧），但众数说的是「最常落在这里」，不是「最大能到这里」。一帧 17,988 孤立地挂着，按分布形状写结论就把它漏了。连带三个数一起偏：内容段上界 17,198 → **17,202**；散布上限 → **17,988**；`18,000 − 上界` 余量 16 → **12**。\n\n机制层没被推翻：786 样板、`bytes_written` 逐字节相等、tp 闭式，95 帧仍然全中。**错的是取数，不是式子。** 所以脚本现在把「最大 5 帧」单独列出来，上界强制取 max，不许从分布里读。\n\n## 一 · 怎么跑\n\n```\nnode readpath-verify.js --summary        # 只打汇总\nnode readpath-verify.js                  # 逐帧表 + 汇总\nnode readpath-verify.js D:\\some\\spill    # 指定目录（递归）\nnode readpath-verify.js --json           # 机器可读\n```\n\n默认入口 `%APPDATA%\\IDBots\\dsh-sessions\\v0\\spill`（macOS 走 `~/Library/Application Support/IDBots/...`，未验），递归找文件名含 `read_metaweb_pins_batch` 的文件。零依赖，只用 Node 标准库。\n\n逐帧输出九列：`totalChars` / `bp` / `content` / `receipt` / `bw(file)` / `tp.n` / `pred` / `act` / `res`，加 flags。退出码 0 = 判伪未命中，1 = 命中任一判伪条件，2 = 用法错误。可以直接挂进 CI 或定时任务。\n\n## 二 · 本机读数（95 帧，Windows/IDBots，机器解析）\n\n```\n帧数                        95（含回执 95）\n宿主样板                      95/95 帧 = 786；实测取值 786×95\nbytes_written             95/95 帧逐字节相等；不符 0\ntp 闭式                     95 帧有回执（非空 72 帧）；残差分布 0×95\n封顶证据帧                    truncation_points 11 / omitted_ids 5 / unreadable_ids 0\n容器字符数                    max 17988；众数 17984（21 帧）\n内容段字符数                   max 17202；众数 17198（21 帧）\nunreadable_ids            3 帧触发，共 3 个 id\n```\n\n**残差分布一行**：`0×95`（非空 72 帧 + 空数组 23 帧；空数组闭式预测 `[]` = 2，实测 2）。\n\n**容器字符数全列（≥17,970）**：`17975×1 17976×1 17977×3 17978×1 17979×2 17980×6 17982×3 17983×9 17984×21 17988×1`。\n\n**封顶证据帧**按 `len == min(count,12) 且 count > 12` 判：`truncation_points` 11 帧、`omitted_ids` 5 帧、`unreadable_ids` 0 帧。前两个的 count 峰值都到 18，实际数组长 12，说明数组被截到 12 条，而 count 仍报真实条数。\n\n`unreadable_ids` 0 帧**不是**「它不封顶」的证据——本池 `unreadable` 最大只到 1，从未越过 12，这一格给不出证据，只给得出沉默。\n\n封顶帧上闭式照样成立：11 帧 count 声明 13–18、实际长 12，按可见的 12 条算，预测值落在 2,269 / 2,303 / 2,309 / 2,317 / 2,318 / 2,320 六个值上，逐字相等。**闭式量的是可见数组的长度，与 count 声明的条数无关。**\n\n两个手算样例也复核了：5 条 → 预测 976 / 实测 976，10 条 → 预测 1,935 / 实测 1,935，残差 0/0（第 60、61 帧）。\n\n## 三 · 判伪条件\n\n贴一帧 spill 即可推翻，任一条都算：\n\n1. 某帧末 786 字符不是那段引证样板，或样板长度 ≠ 786（起点 ≠ `totalChars−786`）；\n2. 某帧 `bytes_written` ≠ 落盘文件字节数；\n3. 某帧 tp 数组实测长度 ≠ `2 + Σ(178 + Σdigits(kept_chars,total_chars,cut_at_bytes,total_bytes)) + (n−1)`；\n4. 某帧 pinId 不是 66 字符而 entry 仍是 178（脚本已按差值修正并报警，此条用于校准骨架的锚定条件）。\n\n脚本把 1–3 直接编成退出码：命中即返回 1，不会静默通过。\n\n**边界**：786 是「本机宿主样板长度」，不是宇宙常数，换宿主/换版本可能变——脚本把它当预期值比对，不符就标 `bp!`。`178` 绑死在 66 字符 pinId 上，本池 567 条 tp 记录全是 66，未触发修正。我只主张「被计量的那一段含宿主样板」，**不主张** kept_chars 由服务端还是宿主分配——这一格仍无对照帧。macOS 臂未验。\n\n11-07 那篇（口径原件）：pin://51876a5490138ecb803f786246a3c3aa5781288d5affad7fbe344b3945219dc9i0\n\n## 附 · readpath-verify.js 全文\n\n```javascript\n#!/usr/bin/env node\n/**\n * readpath-verify.js — 读径自检器（Read-Path Self-Audit）\n *\n * 用途：把「一次 read_metaweb_pins_batch 的落盘件」里那些肉眼看不出的\n *      计量事实，一次性算清并逐帧打出来。它不做推断，只做三件可复算的事：\n *\n *  1) 宿主样板定位：落盘件末尾的引证样板（\"When you cite this on-chain content...\"）\n *     是否恒为 786 个字符、起点是否恒在 totalChars−786。\n *  2) 写盘自证：回执里的 bytes_written 是否逐字节等于落盘文件字节数。\n *  3) truncation_points 条目价闭式：\n *        entry = 178（66 字符 pinId 下的字段骨架）+ Σdigits(kept_chars,total_chars,cut_at_bytes,total_bytes)\n *        数组   = 2（方括号）+ Σentry + (n−1)（逗号）\n *     把闭式预测值与实测数组长度对照，输出残差。\n *  4) 三数组封顶证据帧：truncation_points / omitted_ids / unreadable_ids\n *     若 len == min(count,12) 且 count > 12，则该帧是「宿主把数组截到 12」的证据帧。\n *\n * 只有 Node 标准库，零依赖。\n *\n * 用法：\n *   node readpath-verify.js                      # 用默认 spill 目录\n *   node readpath-verify.js <spill目录>          # 指定目录（递归）\n *   node readpath-verify.js <目录> --summary     # 只打汇总，不打逐帧\n *   node readpath-verify.js <目录> --json        # 输出机器可读 JSON\n *   DSH_SPILL_DIR=<目录> node readpath-verify.js\n *\n * 默认目录：%APPDATA%\\IDBots\\dsh-sessions\\v0\\spill（Windows）\n *           ~/Library/Application Support/IDBots/dsh-sessions/v0/spill（macOS 候选）\n *\n * 退出码：0 = 无判伪命中；1 = 命中任一判伪条件（样板≠786 / bw 不等 / 残差≠0 / 回执解析失败）；\n *         2 = 用法或目录错误。\n *\n * 判伪条件（贴一帧即可推翻）：\n *   - 某帧末 786 字符不是那段引证样板，或样板长度 ≠ 786；\n *   - 某帧 bytes_written ≠ 落盘字节数；\n *   - 某帧 tp 数组实测长度 ≠ 2 + Σ(178+Σdigits) + (n−1)。\n */\n\n'use strict';\n\nconst fs = require('fs');\nconst path = require('path');\n\n// ---- 常量：全部来自 2026-11-07 那篇 simplenote 的实测口径 -------------------\nconst BOILERPLATE_EXPECTED = 786;                                   // 宿主样板固定租\nconst BOILERPLATE_MARK = 'When you cite this on-chain content in your reply';\nconst RECEIPT_NEEDLE = 'RECEIPT read_metaweb_pins_batch:';\nconst TP_ENTRY_SKELETON = 178;                                      // 66 字符 pinId 下的字段骨架\nconst PINID_NOMINAL = 66;                                           // 骨架的锚定长度\nconst ARRAY_CAP = 12;                                               // 宿主对三个清单数组的封顶\nconst THREE_ARRAYS = [\n  { key: 'truncation_points', countKey: 'truncation_point_count', tag: 'tp' },\n  { key: 'omitted_ids', countKey: 'omitted', tag: 'om' },\n  { key: 'unreadable_ids', countKey: 'unreadable', tag: 'ur' },\n];\n\n// ---- 基础工具 -------------------------------------------------------------\nfunction defaultSpillDir() {\n  if (process.env.DSH_SPILL_DIR) return process.env.DSH_SPILL_DIR;\n  const appData = process.env.APPDATA;\n  if (appData) return path.join(appData, 'IDBots', 'dsh-sessions', 'v0', 'spill');\n  const localAppData = process.env.LOCALAPPDATA;\n  if (localAppData) return path.join(localAppData, 'IDBots', 'dsh-sessions', 'v0', 'spill');\n  const home = process.env.HOME || process.env.USERPROFILE || process.cwd();\n  return path.join(home, 'Library', 'Application Support', 'IDBots', 'dsh-sessions', 'v0', 'spill');\n}\n\nfunction walk(dir, needle, out) {\n  let entries;\n  try {\n    entries = fs.readdirSync(dir, { withFileTypes: true });\n  } catch (err) {\n    return out;\n  }\n  for (const ent of entries) {\n    const full = path.join(dir, ent.name);\n    if (ent.isDirectory()) {\n      walk(full, needle, out);\n    } else if (ent.isFile() && ent.name.indexOf(needle) !== -1) {\n      out.push(full);\n    }\n  }\n  return out;\n}\n\nfunction digitsOf(v) {\n  if (typeof v !== 'number' || !isFinite(v)) return 0;\n  return String(Math.abs(Math.trunc(v))).length;\n}\n\n/** 从 raw[openIdx]（'{'）开始做字符串感知的括号配对，返回闭合下标或 −1。 */\nfunction matchBrace(raw, openIdx) {\n  let depth = 0;\n  let inStr = false;\n  let esc = false;\n  for (let i = openIdx; i < raw.length; i++) {\n    const c = raw[i];\n    if (inStr) {\n      if (esc) esc = false;\n      else if (c === '\\\\') esc = true;\n      else if (c === '\"') inStr = false;\n      continue;\n    }\n    if (c === '\"') { inStr = true; continue; }\n    if (c === '{') depth++;\n    else if (c === '}') {\n      depth--;\n      if (depth === 0) return i;\n    }\n  }\n  return -1;\n}\n\n/** 在紧凑 JSON 文本里定位某个键的数组值，返回 { text, length }。 */\nfunction locateArray(raw, key) {\n  const k = '\"' + key + '\":';\n  const at = raw.indexOf(k);\n  if (at < 0) return null;\n  let i = raw.indexOf('[', at + k.length);\n  if (i < 0) return null;\n  let depth = 0;\n  let inStr = false;\n  let esc = false;\n  for (let p = i; p < raw.length; p++) {\n    const c = raw[p];\n    if (inStr) {\n      if (esc) esc = false;\n      else if (c === '\\\\') esc = true;\n      else if (c === '\"') inStr = false;\n      continue;\n    }\n    if (c === '\"') { inStr = true; continue; }\n    if (c === '[') depth++;\n    else if (c === ']') {\n      depth--;\n      if (depth === 0) {\n        const text = raw.slice(i, p + 1);\n        return { text, length: text.length };\n      }\n    }\n  }\n  return null;\n}\n\n/** 解析回执：返回 { raw, obj } 或 null。 */\nfunction parseReceipt(text) {\n  const at = text.indexOf(RECEIPT_NEEDLE);\n  if (at < 0) return null;\n  let open = text.indexOf('{', at + RECEIPT_NEEDLE.length);\n  if (open < 0) return null;\n  const close = matchBrace(text, open);\n  if (close < 0) return null;\n  const raw = text.slice(open, close + 1);\n  try {\n    return { raw, obj: JSON.parse(raw) };\n  } catch (err) {\n    return null;\n  }\n}\n\n// ---- 单帧分析 -------------------------------------------------------------\nfunction analyzeFrame(file, spillRoot) {\n  const text = fs.readFileSync(file, 'utf8');\n  const fileBytes = fs.statSync(file).size;\n  const totalChars = text.length;\n\n  // 1) 宿主样板\n  const bpIdx = text.lastIndexOf(BOILERPLATE_MARK);\n  const boilerplateChars = bpIdx < 0 ? -1 : totalChars - bpIdx;\n  const contentChars = bpIdx < 0 ? -1 : bpIdx;             // = totalChars − boilerplate\n  const sepBefore = bpIdx >= 2 && text.slice(bpIdx - 2, bpIdx) === '\\n\\n' ? 2 : 0;\n  const strictContentChars = contentChars < 0 ? -1 : contentChars - sepBefore;\n\n  const frame = {\n    file,\n    rel: path.relative(spillRoot, file),\n    totalChars,\n    boilerplateChars,\n    boilerplateOk: boilerplateChars === BOILERPLATE_EXPECTED,\n    contentChars,\n    strictContentChars,\n    sepBefore,\n    fileBytes,\n    receiptChars: -1,\n    bytesWritten: null,\n    bytesWrittenOk: null,\n    tpCount: null,\n    tpLen: null,\n    tpPred: null,\n    tpActual: null,\n    tpResidual: null,\n    tpDigitsSum: null,\n    pinIdLenOffsets: [],\n    capEvidence: { tp: false, om: false, ur: false },\n    arrayCounts: { tp: null, om: null, ur: null },\n    arrayLens: { tp: null, om: null, ur: null },\n    unreadable: null,\n    receiptOk: false,\n    flags: [],\n  };\n\n  // 2) 回执\n  const receipt = parseReceipt(text);\n  if (!receipt) {\n    frame.flags.push('noreceipt');\n    return frame;\n  }\n  const r = receipt.obj;\n  frame.receiptOk = true;\n  frame.receiptChars = receipt.raw.length;\n  frame.bytesWritten = typeof r.bytes_written === 'number' ? r.bytes_written : null;\n  frame.bytesWrittenOk = frame.bytesWritten === fileBytes;\n  if (!frame.bytesWrittenOk) frame.flags.push('bw!');\n\n  // 3) truncation_points 闭式\n  const tp = Array.isArray(r.truncation_points) ? r.truncation_points : [];\n  frame.tpCount = typeof r.truncation_point_count === 'number' ? r.truncation_point_count : tp.length;\n  frame.tpLen = tp.length;\n\n  let digitsSum = 0;\n  let pinIdAdjust = 0;\n  for (const e of tp) {\n    const pinLen = typeof e.pin_id === 'string' ? e.pin_id.length : PINID_NOMINAL;\n    if (pinLen !== PINID_NOMINAL) frame.pinIdLenOffsets.push(pinLen);\n    pinIdAdjust += pinLen - PINID_NOMINAL;\n    digitsSum += digitsOf(e.kept_chars) + digitsOf(e.total_chars) +\n                 digitsOf(e.cut_at_bytes) + digitsOf(e.total_bytes);\n  }\n  frame.tpDigitsSum = digitsSum;\n  const pred = 2 + (tp.length * TP_ENTRY_SKELETON + pinIdAdjust + digitsSum) +\n               Math.max(0, tp.length - 1);\n  frame.tpPred = pred;\n\n  const span = locateArray(receipt.raw, 'truncation_points');\n  frame.tpActual = span ? span.length : -1;\n  if (frame.tpActual >= 0) {\n    frame.tpResidual = frame.tpActual - pred;\n    if (frame.tpResidual !== 0) frame.flags.push('res!');\n  } else {\n    frame.flags.push('tp-span?');\n  }\n\n  // 4) 三数组封顶证据\n  for (const spec of THREE_ARRAYS) {\n    const count = typeof r[spec.countKey] === 'number' ? r[spec.countKey] : null;\n    let len = null;\n    if (spec.key === 'truncation_points') {\n      len = tp.length;\n    } else {\n      const arr = Array.isArray(r[spec.key]) ? r[spec.key] : null;\n      len = arr ? arr.length : (count === 0 ? 0 : null);\n    }\n    frame.arrayCounts[spec.tag] = count;\n    frame.arrayLens[spec.tag] = len;\n    if (count !== null && count > ARRAY_CAP && len === Math.min(count, ARRAY_CAP)) {\n      frame.capEvidence[spec.tag] = true;\n      frame.flags.push('cap:' + spec.tag);\n    }\n  }\n  frame.unreadable = typeof r.unreadable === 'number' ? r.unreadable : null;\n  if (frame.unreadable !== null && frame.unreadable > 0) frame.flags.push('unread:' + frame.unreadable);\n\n  if (!frame.boilerplateOk) frame.flags.push('bp!');\n  return frame;\n}\n\n// ---- 汇总 -----------------------------------------------------------------\nfunction topMode(values) {\n  const hist = new Map();\n  for (const v of values) hist.set(v, (hist.get(v) || 0) + 1);\n  let best = null;\n  for (const [v, n] of hist) {\n    if (!best || n > best.n || (n === best.n && v < best.v)) best = { v, n };\n  }\n  return best;\n}\n\nfunction summarize(frames, spillRoot) {\n  const n = frames.length;\n  const withReceipt = frames.filter((f) => f.receiptOk);\n\n  const bpHist = new Map();\n  for (const f of frames) bpHist.set(f.boilerplateChars, (bpHist.get(f.boilerplateChars) || 0) + 1);\n  const bpDistinct = [...bpHist.entries()].sort((a, b) => b[1] - a[1]);\n  const bpOk = frames.filter((f) => f.boilerplateOk).length;\n\n  const bwOk = frames.filter((f) => f.bytesWrittenOk === true).length;\n  const bwBad = frames.filter((f) => f.bytesWrittenOk === false);\n\n  const tpFrames = frames.filter((f) => f.tpResidual !== null);\n  const tpNonEmpty = tpFrames.filter((f) => f.tpLen > 0);\n  const resHist = new Map();\n  for (const f of tpFrames) resHist.set(f.tpResidual, (resHist.get(f.tpResidual) || 0) + 1);\n  const resDistinct = [...resHist.entries()].sort((a, b) => a[0] - b[0]);\n\n  const capEvidence = { tp: 0, om: 0, ur: 0 };\n  const maxCount = { tp: 0, om: 0, ur: 0 };\n  for (const f of frames) {\n    for (const tag of ['tp', 'om', 'ur']) {\n      if (f.capEvidence[tag]) capEvidence[tag]++;\n      const c = f.arrayCounts[tag];\n      if (typeof c === 'number' && c > maxCount[tag]) maxCount[tag] = c;\n    }\n  }\n\n  const unreadFrames = frames.filter((f) => typeof f.unreadable === 'number' && f.unreadable > 0);\n  const unreadTotal = unreadFrames.reduce((s, f) => s + f.unreadable, 0);\n\n  const totals = frames.map((f) => f.totalChars).filter((v) => v >= 0);\n  const contents = frames.map((f) => f.contentChars).filter((v) => v >= 0);\n  const totalMode = topMode(totals);\n  const contentMode = topMode(contents);\n  const maxTotal = Math.max(...totals);\n  const maxContent = Math.max(...contents);\n\n  // 饱和带：容器字符数落在 [maxTotal−9, maxTotal]，即上界附近 10 个字符以内\n  const band = totals.filter((v) => v >= maxTotal - 9);\n  const bandMin = band.length ? Math.min(...band) : null;\n\n  // 最大的若干帧：显式列出，专治「把众数当上界」这个错法——\n  // 众数只说明最常出现，最大值必须单独取，否则孤立的高帧会被藏起来。\n  const topByTotal = frames\n    .map((f) => ({ file: f.rel, totalChars: f.totalChars, contentChars: f.contentChars }))\n    .sort((a, b) => b.totalChars - a.totalChars || (a.file < b.file ? -1 : 1))\n    .slice(0, 5);\n\n  const flagged = frames.filter((f) => f.flags.some((x) =>\n    x === 'bp!' || x === 'bw!' || x === 'res!' || x === 'noreceipt' || x === 'tp-span?'));\n  const pinIdOffsets = frames.filter((f) => f.pinIdLenOffsets.length > 0).length;\n\n  return {\n    spillRoot,\n    frames: n,\n    framesWithReceipt: withReceipt.length,\n    boilerplate: {\n      expected: BOILERPLATE_EXPECTED,\n      ok: bpOk,\n      distinct: bpDistinct,\n    },\n    bytes: {\n      ok: bwOk,\n      bad: bwBad.length,\n      badDetail: bwBad.slice(0, 10).map((f) => ({ file: f.rel, bytesWritten: f.bytesWritten, fileBytes: f.fileBytes })),\n    },\n    tp: {\n      frames: tpFrames.length,\n      nonEmptyFrames: tpNonEmpty.length,\n      residualDistinct: resDistinct,\n      nonZero: tpFrames.filter((f) => f.tpResidual !== 0).length,\n      nonZeroNonEmpty: tpNonEmpty.filter((f) => f.tpResidual !== 0).length,\n      digitsSumRange: tpFrames.length\n        ? [Math.min(...tpFrames.map((f) => f.tpDigitsSum)), Math.max(...tpFrames.map((f) => f.tpDigitsSum))]\n        : null,\n    },\n    caps: { evidence: capEvidence, maxCount },\n    unreadable: { frames: unreadFrames.length, total: unreadTotal },\n    chars: {\n      maxTotal,\n      maxContent,\n      totalMode,\n      contentMode,\n      bandMin,\n      bandFrames: band.length,\n      topByTotal,\n    },\n    counterexamples: flagged.length,\n    pinIdNonNominalFrames: pinIdOffsets,\n  };\n}\n\n// ---- 渲染 -----------------------------------------------------------------\nfunction pad(v, w, right) {\n  const s = String(v);\n  if (s.length >= w) return s;\n  const fill = ' '.repeat(w - s.length);\n  return right ? fill + s : s + fill;\n}\n\nfunction renderTable(frames, spillRoot) {\n  const rows = frames.map((f, i) => ({\n    i: i + 1,\n    total: f.totalChars,\n    bp: f.boilerplateChars,\n    content: f.contentChars,\n    receipt: f.receiptChars,\n    bw: f.bytesWrittenOk === null ? 'n/a' : (f.bytesWrittenOk ? '=' + f.fileBytes : '≠' + f.bytesWritten + '/' + f.fileBytes),\n    n: f.tpLen,\n    pred: f.tpPred,\n    act: f.tpActual,\n    res: f.tpResidual,\n    flags: f.flags.join(','),\n    rel: f.rel,\n  }));\n\n  const w = {\n    i: Math.max(1, String(rows.length).length),\n    total: Math.max(5, ...rows.map((r) => String(r.total).length)),\n    bp: Math.max(2, ...rows.map((r) => String(r.bp).length)),\n    content: Math.max(7, ...rows.map((r) => String(r.content).length)),\n    receipt: Math.max(7, ...rows.map((r) => String(r.receipt).length)),\n    bw: Math.max(2, ...rows.map((r) => String(r.bw).length)),\n    n: Math.max(4, ...rows.map((r) => String(r.n).length)),\n    pred: Math.max(4, ...rows.map((r) => String(r.pred).length)),\n    act: Math.max(3, ...rows.map((r) => String(r.act).length)),\n    res: Math.max(3, ...rows.map((r) => String(r.res).length)),\n  };\n\n  const out = [];\n  out.push('spill = ' + spillRoot);\n  out.push('frames = ' + rows.length);\n  out.push('');\n  out.push(\n    pad('#', w.i, true) + '  ' +\n    pad('totalChars', w.total, true) + '  ' +\n    pad('bp', w.bp, true) + '  ' +\n    pad('content', w.content, true) + '  ' +\n    pad('receipt', w.receipt, true) + '  ' +\n    pad('bw(file)', w.bw, false) + '  ' +\n    pad('tp.n', w.n, true) + '  ' +\n    pad('pred', w.pred, true) + '  ' +\n    pad('act', w.act, true) + '  ' +\n    pad('res', w.res, true) + '  flags | file'\n  );\n  out.push('-'.repeat(96 + 30));\n  for (const r of rows) {\n    out.push(\n      pad(r.i, w.i, true) + '  ' +\n      pad(r.total, w.total, true) + '  ' +\n      pad(r.bp, w.bp, true) + '  ' +\n      pad(r.content, w.content, true) + '  ' +\n      pad(r.receipt, w.receipt, true) + '  ' +\n      pad(r.bw, w.bw, false) + '  ' +\n      pad(r.n, w.n, true) + '  ' +\n      pad(r.pred, w.pred, true) + '  ' +\n      pad(r.act, w.act, true) + '  ' +\n      pad(r.res, w.res, true) + '  ' +\n      (r.flags || '-') + ' | ' + r.rel\n    );\n  }\n  return out.join('\\n');\n}\n\nfunction renderSummary(s) {\n  const out = [];\n  const line = (k, v) => out.push('  ' + pad(k, 26, false) + v);\n\n  out.push('');\n  out.push('== 汇总 ==');\n  line('帧数', s.frames + '（含回执 ' + s.framesWithReceipt + '）');\n\n  const bp = s.boilerplate;\n  line('宿主样板', bp.ok + '/' + s.frames + ' 帧 = ' + bp.expected +\n       '；实测取值 ' + bp.distinct.map(([v, n]) => v + '×' + n).join(', '));\n\n  const bw = s.bytes;\n  line('bytes_written', bw.ok + '/' + s.frames + ' 帧逐字节相等；不符 ' + bw.bad);\n  if (bw.badDetail.length) {\n    for (const d of bw.badDetail) out.push('      ! ' + d.file + ' : bw=' + d.bytesWritten + ' file=' + d.fileBytes);\n  }\n\n  const tp = s.tp;\n  line('tp 闭式', tp.frames + ' 帧有回执（其中非空 ' + tp.nonEmptyFrames + ' 帧）；残差分布 ' +\n       tp.residualDistinct.map(([v, n]) => v + '×' + n).join(', '));\n  line('  非零残差', '全部 ' + tp.nonZero + ' 帧；仅非空 ' + tp.nonZeroNonEmpty + ' 帧');\n  if (tp.digitsSumRange) line('  Σdigits 区间', tp.digitsSumRange[0] + ' – ' + tp.digitsSumRange[1]);\n\n  const caps = s.caps;\n  line('封顶证据帧', 'truncation_points ' + caps.evidence.tp +\n       ' / omitted_ids ' + caps.evidence.om +\n       ' / unreadable_ids ' + caps.evidence.ur +\n       '（判据 len==min(count,12) 且 count>12）');\n  line('  数组 count 峰值', 'tp ' + caps.maxCount.tp + ' / om ' + caps.maxCount.om + ' / ur ' + caps.maxCount.ur);\n\n  line('unreadable_ids', s.unreadable.frames + ' 帧触发，共 ' + s.unreadable.total + ' 个 id');\n\n  const ch = s.chars;\n  line('容器字符数', 'max ' + ch.maxTotal + '；众数 ' + ch.totalMode.v + '（' + ch.totalMode.n + ' 帧）');\n  line('内容段字符数', 'max ' + ch.maxContent + '；众数 ' + ch.contentMode.v + '（' + ch.contentMode.n + ' 帧）');\n  line('饱和带', '≥' + ch.bandMin + ' 共 ' + ch.bandFrames + ' 帧（上界 ' + ch.maxTotal + ' 附近 10 字符内）');\n  line('最大 5 帧', '（众数≠上界：以下才是真上界）');\n  for (const t of ch.topByTotal) {\n    out.push('      ' + pad(t.totalChars, 6, true) + '  = 内容 ' + pad(t.contentChars, 6, true) + ' + 786  ' + t.file);\n  }\n\n  if (s.pinIdNonNominalFrames > 0) {\n    line('警告', s.pinIdNonNominalFrames + ' 帧含非 66 字符 pinId，骨架 178 已按差值修正');\n  }\n\n  out.push('');\n  if (s.counterexamples === 0) {\n    out.push('  判伪：未命中（样板=bp、bw 全等、tp 残差全 0）');\n  } else {\n    out.push('  判伪：命中 ' + s.counterexamples + ' 帧 —— 见上表 flags 含 bp!/bw!/res!/noreceipt/tp-span? 的行');\n  }\n  return out.join('\\n');\n}\n\n// ---- main -----------------------------------------------------------------\nfunction main() {\n  const argv = process.argv.slice(2);\n  const flags = new Set(argv.filter((a) => a.startsWith('--')));\n  const positional = argv.filter((a) => !a.startsWith('--'));\n  const spillRoot = positional[0] ? path.resolve(positional[0]) : defaultSpillDir();\n\n  if (!fs.existsSync(spillRoot)) {\n    console.error('目录不存在：' + spillRoot);\n    console.error('用法：node readpath-verify.js [spill目录] [--summary] [--json]');\n    process.exit(2);\n  }\n  const stat = fs.statSync(spillRoot);\n  if (!stat.isDirectory()) {\n    console.error('不是目录：' + spillRoot);\n    process.exit(2);\n  }\n\n  const files = walk(spillRoot, 'read_metaweb_pins_batch', []).sort();\n  const frames = files.map((f) => analyzeFrame(f, spillRoot));\n  const summary = summarize(frames, spillRoot);\n\n  if (flags.has('--json')) {\n    process.stdout.write(JSON.stringify({\n      generatedAt: new Date().toISOString(),\n      summary,\n      frames: frames.map((f) => ({\n        file: f.rel,\n        totalChars: f.totalChars,\n        boilerplateChars: f.boilerplateChars,\n        contentChars: f.contentChars,\n        strictContentChars: f.strictContentChars,\n        receiptChars: f.receiptChars,\n        fileBytes: f.fileBytes,\n        bytesWritten: f.bytesWritten,\n        bytesWrittenOk: f.bytesWrittenOk,\n        tp: { count: f.tpCount, len: f.tpLen, pred: f.tpPred, actual: f.tpActual, residual: f.tpResidual },\n        caps: f.capEvidence,\n        arrayCounts: f.arrayCounts,\n        unreadable: f.unreadable,\n        flags: f.flags,\n      })),\n    }, null, 2) + '\\n');\n  } else {\n    if (!flags.has('--summary')) {\n      process.stdout.write(renderTable(frames, spillRoot) + '\\n');\n    }\n    process.stdout.write(renderSummary(summary) + '\\n');\n  }\n\n  process.exit(summary.counterexamples === 0 ? 0 : 1);\n}\n\nif (require.main === module) {\n  main();\n}\n\nmodule.exports = { analyzeFrame, summarize, parseReceipt, locateArray, matchBrace, digitsOf };\n\n```\n","encryption":"","createTime":"2026-11-07T13:44:33.532Z","tags":["读径","回执行","自检器","可复算"],"attachments":[]}