dsh-bili-watch 0.2.23 → 0.2.24

package/README.md

@@ -54,7 +54,7 @@ dsh plugin --profile web remove dsh-bili-watch
 - **删除**：面板按实际路径判断——装在插件目录里的（yt-dlp、转写模型、登录凭证）可直接删；装在插件目录外的（比如复用系统 ffmpeg 或已有的 Python 环境）按钮置灰，旁边标出它实际在哪。
 - **批量**：标题行的「批量下载 / 批量清理」打开勾选清单，默认勾上所有可操作的项，删除前会再确认一次。
 - **抽帧缓存**：显示当前占用与文件数，「立即清除」一键清空；不点则会按规则自动清理——保留天数（默认 7 天）与总量上限（默认 2048 MB），超过则从最旧的删起。规则存在 `deps/cache-config.json`，插件启动和打开面板时各检查一次。
-- **缓存位置**：默认在系统临时目录（`tmpdir()/bili-watch`）。要换位置就设环境变量 `BILI_WATCH_CACHE`，或在 `deps/deps-config.json` 里写 `"cache": "D:\\你想要的目录"`；改完重启 DSH 生效，面板「抽帧缓存 → 位置」会显示当前实际路径。
+- **缓存位置**：默认在 DSH 家目录（`$DSH_HOME/bili-watch`；`$DSH_HOME` 就是 DSH 的家目录，Windows 下通常是用户目录里的 `.dsh`）。要换位置就设环境变量 `BILI_WATCH_CACHE`，或在 `deps/deps-config.json` 里写 `"cache": "D:\你想要的目录"`；改完重启 DSH 生效，面板「抽帧缓存 → 位置」会显示当前实际路径。
 - **最近一次调用**：显示命令、时间、成败，用来判断上一次看视频是否卡住。
 
 装完第一次重启 DSH，面板才会出现。
@@ -137,7 +137,7 @@ macOS/Linux 的 ffmpeg 用系统包管理器装，脚本只给提示。其余目
 | `search <关键词> [--days 3]` | 搜视频 |
 | `hot [--limit 10]` | 综合热门榜 |
 | `login [--check] [--poll]` | 扫码登录 |
-| `clean` | 清空系统临时目录下的 `bili-watch`（Windows 是 `%TEMP%\bili-watch`） |
+| `clean` | 清空缓存根（默认 `$DSH_HOME/bili-watch`） |
 
 工具侧的等价入口：`bili_watch` 工具（参数 `command` + `bv`），或 `/bili` 命令。
 
@@ -157,7 +157,7 @@ macOS/Linux 的 ffmpeg 用系统包管理器装，脚本只给提示。其余目
 `view` / `text` / `asr` / `frames` 接受非 B 站 URL（YouTube、X、直链 mp4 等），走 yt-dlp：
 
 - `yt-dlp.exe` 放进 `deps/`，或设 `BILI_WATCH_YTDLP`，或让它出现在 PATH 里。
-- 下载按 URL 哈希隔离在 `%TEMP%\bili-watch\`，不会串目录。
+- 下载按 URL 哈希隔离在缓存根下，不会串目录。
 - `peek` / `sub` / `comments` / `danmaku` / `sheet` / `substrip` / `ocr` 只支持 B 站。
 
 ## 转写可信度
@@ -183,6 +183,24 @@ AI 字幕（需登录）
 
 降级时会说明原因，不会静默跳过。
 
+## 字幕可能是诱饵
+
+有些视频的标题、简介、字幕跟画面是故意错开的：字幕讲一套数据，画面却在放歌词。只看字幕就复述，会写出一段不存在的内容。
+
+`text` 会做一次便宜的判断，命中任一条就打一行提示：
+
+- 字幕语速不在 2–8.5 字/秒（真人口播的常见区间）
+- 关键词命中不到 30%（字幕和标题/UP 名对不上）
+- 字幕里自称「实验 / 钓鱼 / 测试」
+
+想进一步确认就加 `--verify`：它会抽 5 帧做 OCR，拿画面文字跟字幕比一遍，报「首帧写着某实验说明」或「画面与字幕几乎不重合」。
+
+```
+node tools/look.mjs text BV1xxxxxxxxx --verify
+```
+
+默认不抽帧：语速偏慢在 MV、纯音乐、风景片里很常见，为了少数钓鱼视频让每条都多花十几秒下载和 OCR 不划算。提示归提示，**结论还得你自己看画面再下**。
+
 ## 环境变量
 
 | 变量 | 作用 |
@@ -221,3 +239,13 @@ AI 字幕（需登录）
 ## 许可
 
 MIT
+
+## 长文本保护（2026-10-26）
+
+`text` / `sub` / `asr` 的正文超过 **800 字**时，终端只给开头 400 字摘要 + 一行落盘路径，全文写进缓存目录下按视频分的文件夹：`<缓存目录>/<BV>/<命令>.txt`。
+
+- `--head N`：自定义摘要长度
+- `--full`：打全文
+- 工具层（`bili_watch`）与 `/bili` 命令同理，阈值 2000 字（摘要 800），超了同样落盘并回摘要
+
+这么做的原因：一段 14 分钟视频的字幕 4,449 字，整段塞进上下文会把会话挤爆（2026-10-26 实测两次）。

package/index.js

@@ -11,11 +11,52 @@
  */
 import { spawn } from 'node:child_process'
 import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
+import { tmpdir, homedir } from 'node:os'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 // @deepseek-ai/dsh-tools 是可选 peer：桌面版 autoInstallPeers:false，市场安装时不会自动装上。
 // 缺了只少一个 bili_watch 工具，/bili 命令、插件面板与路由照常工作，不能因此整块加载失败。
+// 工具输出上限：超了就把全文落文件、只回摘要。
+// 由来：2026-10-26 一段 14 分钟视频的字幕 4,449 字整段塞进上下文，把会话挤爆两次。
+const TOOL_TEXT_CAP = 2000
+const TOOL_TEXT_HEAD = 800
+
+function cleanKey(s) {
+  // 只留字母数字与 _ . -；挡掉 .. / . / Windows 保留设备名，避免输入直接决定磁盘路径
+  const k = String(s || '').replace(/[^\w.-]/g, '').replace(/^\.+$/, '').slice(0, 40)
+  if (!k || /^(con|prn|aux|nul|com[0-9]|lpt[0-9])$/i.test(k)) return '_misc'
+  return k
+}
+
+/** 按视频分目录：CACHE/<BV>/<cmd>.txt —— 同一个视频各命令的输出收在一处 */
+function videoDir(key) {
+  const base = cleanKey(key)
+  mkdirSync(CACHE, { recursive: true })
+  // 同一个 BV 已经有目录（可能被 CLI 改成「BV_标题」）就用它，别建第二个兄弟目录（2026-10-26 审查 T01/T02）
+  try {
+    for (const d of readdirSync(CACHE)) {
+      if (d === base || d.startsWith(base + '_')) return join(CACHE, d)
+    }
+  } catch {}
+  const d = join(CACHE, base)
+  mkdirSync(d, { recursive: true })
+  return d
+}
+
+/** 长文本 → 落盘 + 摘要；短文本原样返回（不论长短都先落一份到缓存） */
+function trimForModel(text, tag = 'out', bv = '') {
+  const s = String(text ?? '')
+  let f = ''
+  try {
+    const name = String(tag || 'out').replace(/[^\w.-]/g, '') || 'out'
+    f = join(videoDir(bv), `${name}.tool.txt`) // .tool 后缀：别覆盖 CLI 落的同名全文
+    writeFileSync(f, s, 'utf8')
+  } catch { f = '' }
+  if (!f) return s // 落盘失败：原样返回，不截断（保护是 best-effort，正确性优先）
+  if (s.length <= TOOL_TEXT_CAP) return s
+  return `${s.slice(0, TOOL_TEXT_HEAD)}\n\n…（全文 ${s.length} 字，只回了前 ${TOOL_TEXT_HEAD} 字${f ? '；全文已存：' + f : ''}）\n要看完整版：用 read 工具打开上面的文件（别再跑一遍命令）；或换更细的 command 分段取。`
+}
+
 let defineTool = null
 try {
   ({ defineTool } = await import('@deepseek-ai/dsh-tools'))
@@ -60,7 +101,7 @@ const LAST_RUN = join(DEPS, 'last-run.json')
 // 缓存位置：env BILI_WATCH_CACHE > deps\deps-config.json 的 cache > 系统临时目录。发布版不含本机路径。
 // 自定义目录不可写时不让功能哑掉：回退到临时目录，并把原因挂进 /status.warnings。
 function pickCacheDir() {
-  const want = process.env.BILI_WATCH_CACHE || depsCfg().cache || join(tmpdir(), 'bili-watch')
+  const want = process.env.BILI_WATCH_CACHE || depsCfg().cache || join(process.env.DSH_HOME || join(homedir(), '.dsh'), 'bili-watch')
   try {
     mkdirSync(want, { recursive: true })
     const probe = join(want, `.write-test-${process.pid}`)
@@ -68,7 +109,7 @@ function pickCacheDir() {
     rmSync(probe, { force: true })
     return { dir: want, fallback: null }
   } catch (e) {
-    const fb = join(tmpdir(), 'bili-watch')
+    const fb = join(process.env.DSH_HOME || join(homedir(), '.dsh'), 'bili-watch')
     try { mkdirSync(fb, { recursive: true }) } catch {}
     return { dir: fb, fallback: String(e?.message || e) }
   }
@@ -665,6 +706,10 @@ function parseCommandLine(raw) {
       else extra.push('--out', out)
     } else if (t === '--ffmpeg' && tokens.length) {
       extra.push('--ffmpeg', tokens.shift())
+    } else if (t === '--head' && tokens.length) {
+      extra.push('--head', tokens.shift())
+    } else if (t === '--full' || t === '--verify') {
+      extra.push(t)
     } else if (t === '--format' && tokens.length) {
       extra.push('--format', tokens.shift())
     } else if (t === '--fresh' || t === '--ocr' || t === '--poll' || t === '--check' || t === '--fast' || t === '--scene' || t === '--mark-seen') {
@@ -696,7 +741,8 @@ async function lookup({ command, bv, extra = [], badOut = false }) {
   const r = await runLook(args)
   // login 只生成二维码，真正的登录成功由面板 poll 写；命令层不记 lastRun，避免「生成成功」被读成「已登录」
   if (command !== 'login') writeLastRun(command, r.code)
-  const text = (r.out || r.err || '').trim() || '（没有输出）'
+  const body = (r.out || r.err || '').trim()
+  const text = body || `（${command} 没有输出，退出码 ${r.code ?? '?'}；完整日志看 bili-watch 的 stderr）`
   return { ok: r.code === 0, text }
 }
 
@@ -718,7 +764,7 @@ function apply(ctx) {
     handler: async (invocation) => {
       const { command, bv, extra, badOut } = parseCommandLine(invocation?.rawInput)
       const r = await lookup({ command, bv, extra, badOut })
-      return { kind: r.ok ? 'success' : 'error', text: r.text }
+      return { kind: r.ok ? 'success' : 'error', text: trimForModel(r.text, command, bv) }
     },
   })
 
@@ -841,7 +887,7 @@ function apply(ctx) {
           text: { type: 'string', description: '输出文本' },
         },
       },
-      render: (_args, value) => [{ type: 'text', text: String(value?.text ?? '').slice(0, 24000) }],
+      render: (_args, value) => [{ type: 'text', text: String(value?.text ?? '').slice(0, 2500) }],
     },
     execute: async (args) => {
       const extra = []
@@ -864,13 +910,13 @@ function apply(ctx) {
       }
       if (args.command === 'hot') {
         const r = await lookup({ command: 'hot', bv: '', extra })
-        return { ok: r.ok, text: r.text }
+        return { ok: r.ok, text: trimForModel(r.text, 'hot', '_hot') }
       }
       const target = args.command === 'search' ? String(args.keyword ?? '').trim() : String(args.bv ?? '').trim()
       if (args.command === 'search' && !target) return { ok: false, text: 'search 需要 keyword 参数（要搜什么词）' }
       if (!target) return { ok: false, text: '缺少 BV 号或分享链接' }
       const r = await lookup({ command: args.command, bv: target, extra })
-      return { ok: r.ok, text: r.text }
+      return { ok: r.ok, text: trimForModel(r.text, args.command, target) }
     },
   }))
   } else {

package/package.json

@@ -1,78 +1,78 @@
 {
-  "name": "dsh-bili-watch",
-  "version": "0.2.23",
-  "private": false,
-  "description": "把 B 站视频读成文本给 DSH agent 用：元数据、评论、弹幕、字幕、本地转写、抽帧 OCR；支持 b23.tv 短链与 av 号，抽帧缓存目录可换。只读命令零依赖。",
-  "type": "module",
-  "main": "index.js",
-  "bin": {
-    "bili-watch": "tools/look.mjs"
-  },
-  "exports": {
-    ".": "./index.js",
-    "./client": "./client.js",
-    "./cordis.patch.yml": "./cordis.patch.yml",
-    "./package.json": "./package.json"
-  },
-  "dsh": {
-    "bundle": {
-      "patch": "./cordis.patch.yml"
-    },
-    "client": {
-      "platform": "web",
-      "inject": [
-        "@deepseek-ai/dsh-client-runtime",
-        "@deepseek-ai/dsh-client-ui-settings"
-      ]
-    }
-  },
-  "files": [
-    "index.js",
-    "client.js",
-    "cordis.patch.yml",
-    "tools/",
-    "scripts/",
-    "deps/.gitkeep",
-    "deps/_bili-asr.py",
-    "auto-trigger.js",
-    "LICENSE"
-  ],
-  "keywords": [
-    "bilibili",
-    "video",
-    "asr",
-    "ocr",
-    "danmaku",
-    "dsh",
-    "deepseek",
-    "subtitles"
-  ],
-  "author": "Sacredbluedragon",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Sacredbluedragon/dsh-bili-watch.git"
-  },
-  "bugs": {
-    "url": "https://github.com/Sacredbluedragon/dsh-bili-watch/issues"
-  },
-  "homepage": "https://github.com/Sacredbluedragon/dsh-bili-watch#readme",
-  "engines": {
-    "node": ">=22"
-  },
-  "dependencies": {
-    "qrcode": "^1.5.4"
-  },
-  "peerDependencies": {
-    "@deepseek-ai/dsh": ">=0.2.0-rc.1 <0.3.0-0",
-    "@deepseek-ai/dsh-tools": ">=0.2.0-rc.1 <0.3.0-0"
-  },
-  "peerDependenciesMeta": {
-    "@deepseek-ai/dsh": {
-      "optional": true
-    },
-    "@deepseek-ai/dsh-tools": {
-      "optional": true
-    }
-  }
+    "name":  "dsh-bili-watch",
+    "version":  "0.2.24",
+    "private":  false,
+    "description":  "把 B 站视频读成文本给 DSH agent 用：元数据、评论、弹幕、字幕、本地转写、抽帧 OCR；支持 b23.tv 短链与 av 号，抽帧缓存目录可换。只读命令零依赖。",
+    "type":  "module",
+    "main":  "index.js",
+    "bin":  {
+                "bili-watch":  "tools/look.mjs"
+            },
+    "exports":  {
+                    ".":  "./index.js",
+                    "./client":  "./client.js",
+                    "./cordis.patch.yml":  "./cordis.patch.yml",
+                    "./package.json":  "./package.json"
+                },
+    "dsh":  {
+                "bundle":  {
+                               "patch":  "./cordis.patch.yml"
+                           },
+                "client":  {
+                               "platform":  "web",
+                               "inject":  [
+                                              "@deepseek-ai/dsh-client-runtime",
+                                              "@deepseek-ai/dsh-client-ui-settings"
+                                          ]
+                           }
+            },
+    "files":  [
+                  "index.js",
+                  "client.js",
+                  "cordis.patch.yml",
+                  "tools/",
+                  "scripts/",
+                  "deps/.gitkeep",
+                  "deps/_bili-asr.py",
+                  "auto-trigger.js",
+                  "LICENSE"
+              ],
+    "keywords":  [
+                     "bilibili",
+                     "video",
+                     "asr",
+                     "ocr",
+                     "danmaku",
+                     "dsh",
+                     "deepseek",
+                     "subtitles"
+                 ],
+    "author":  "Sacredbluedragon",
+    "license":  "MIT",
+    "repository":  {
+                       "type":  "git",
+                       "url":  "git+https://github.com/Sacredbluedragon/dsh-bili-watch.git"
+                   },
+    "bugs":  {
+                 "url":  "https://github.com/Sacredbluedragon/dsh-bili-watch/issues"
+             },
+    "homepage":  "https://github.com/Sacredbluedragon/dsh-bili-watch#readme",
+    "engines":  {
+                    "node":  "\u003e=22"
+                },
+    "dependencies":  {
+                         "qrcode":  "^1.5.4"
+                     },
+    "peerDependencies":  {
+                             "@deepseek-ai/dsh":  "\u003e=0.2.0-rc.1 \u003c0.3.0-0",
+                             "@deepseek-ai/dsh-tools":  "\u003e=0.2.0-rc.1 \u003c0.3.0-0"
+                         },
+    "peerDependenciesMeta":  {
+                                 "@deepseek-ai/dsh":  {
+                                                          "optional":  true
+                                                      },
+                                 "@deepseek-ai/dsh-tools":  {
+                                                                "optional":  true
+                                                            }
+                             }
 }

package/tools/look.mjs

@@ -19,6 +19,8 @@
  *                                      下载 360p 抽帧；加 --ocr 顺带识别画面文字
  *   node look.mjs ocr <BV> [--step 2]  抽帧 + RapidOCR 出文字（不读图）
  *   node look.mjs text <BV> [--cred 凭证]  四级链：字幕 → ASR → OCR，输出最可信的一份文本
+ *                                      超过 800 字只给开头 400 字摘要，全文落 <缓存目录>/<BV>/<命令>.txt
+ *                                      （--head N 自定义摘要长度，--full 打全文）
  *   node look.mjs peek <BV>            先看标题/简介/热评 + 5 帧 OCR
  *   node look.mjs clean                清空 %TEMP%\bili-watch
  *
@@ -32,7 +34,7 @@ import { createHash, randomBytes } from 'node:crypto'
 import { createRequire } from 'node:module'
 import { join, dirname, basename } from 'node:path'
 import * as zlib from 'node:zlib'
-import { tmpdir } from 'node:os'
+import { tmpdir, homedir } from 'node:os'
 import { fileURLToPath } from 'node:url'
 
 const HERE = dirname(fileURLToPath(import.meta.url))
@@ -60,7 +62,9 @@ const FFMPEG_CAND = process.env.BILI_WATCH_FFMPEG || depsCfg.ffmpeg || ''
 const FFMPEG_HINT =
   '跑 scripts/fetch-deps.ps1 -Target ffmpeg（macOS/Linux：bash scripts/fetch-deps.sh 或系统包管理器装），或设 BILI_WATCH_FFMPEG，或用 --ffmpeg 传路径'
 // 缓存位置：env BILI_WATCH_CACHE > deps\deps-config.json 的 cache > 系统临时目录（与 index.js 同一口径）。
-const CACHE = process.env.BILI_WATCH_CACHE || depsCfg.cache || join(tmpdir(), 'bili-watch')
+const DSH_HOME = process.env.DSH_HOME || join(homedir(), '.dsh')
+// 缓存根：环境变量 / 插件配置优先，兜底落 DSH_HOME。曾用 tmpdir，会跟着临时清理一起没（2026-10-26 改）
+const CACHE = process.env.BILI_WATCH_CACHE || depsCfg.cache || join(DSH_HOME, 'bili-watch')
 const require = createRequire(import.meta.url)
 const CRED_FILE = join(DEPS, 'credential.json')
 const LOGIN_KEY_FILE = join(DEPS, 'login-key.json')
@@ -291,6 +295,63 @@ function speedScore(subText, durSec) {
   const ok = rate >= 2.0 && rate <= 8.5
   return { ok, rate: Math.round(rate * 10) / 10, why: ok ? '' : `${rate.toFixed(1)} 字/秒，超出 2.0–8.5 正常口播区间` }
 }
+// ── 反钓鱼自查（2026-10-26 加，来源 BV19bna6NE7i 那类实验）──────────────
+// 有些视频的标题/简介/字幕是故意错配的诱饵（画面放歌词、字幕讲假的日报），
+// 只读字幕就会复述一套不存在的内容。默认不抽帧，只有字幕自己露出马脚才付抽帧成本。
+const BAIT_WORD = /实验说明|实验\s*\d+\s*[/／]\s*\d+|这是实验|钓鱼视频|钓鱼视频|测试视频|诱饵| bait\b/i
+
+function bigramSet(s) {
+  const t = String(s || '').replace(/[^\u4e00-\u9fa5a-zA-Z0-9]/g, '')
+  const set = new Set()
+  for (let i = 0; i < t.length - 1; i++) set.add(t.slice(i, i + 2))
+  return set
+}
+
+/** 可疑判据：语速不在口播区间、字幕自称实验/钓鱼，任一命中；关键词命中率低只在语速也异常时作为补充理由。 */
+function baitSignals(text, v, c) {
+  const reasons = []
+  let speedBad = false
+  if (c?.sp && typeof c.sp.rate === 'number' && Number.isFinite(c.sp.rate)) {
+    if (c.sp.rate < 2.0) { reasons.push(`语速 ${c.sp.rate} 字/秒（低于口播常见的 2–8.5）`); speedBad = true }
+    else if (c.sp.rate > 8.5) { reasons.push(`语速 ${c.sp.rate} 字/秒（高于口播常见的 2–8.5）`); speedBad = true }
+  }
+  if (BAIT_WORD.test(String(text || ''))) reasons.push('字幕自称「实验/钓鱼」')
+  // 命中率不能单独触发：ASR 常把英文读成中文谐音（DeepSeek→deep sick），
+  // 正常视频也会低命中（2026-10-26 实测 BV19dJQ6sE9F 命中 2/13、语速 5 字/秒）。
+  if (speedBad && c?.ks && c.ks.total >= 8 && c.ks.hit / c.ks.total < 0.3) {
+    reasons.push(`关键词只命中 ${c.ks.hit}/${c.ks.total}（字幕和标题/UP 对不上）`)
+  }
+  return { suspect: reasons.length > 0, reasons }
+}
+
+/** 可疑时抽 5 帧（复用 peek 的缓存）+ OCR，拿画面文字跟字幕对一遍。 */
+async function checkBaitFrames(bv, v, subtitleText, opts = {}) {
+  if (!ocrReady()) return { ok: false, why: 'OCR 环境不可用，核实不了画面' }
+  try {
+    const r = await peekFrames(bv, v, { ffmpeg: opts.ffmpeg })
+    const lines = await peekOcrLines(r.dir)
+    if (!lines || !lines.length) return { ok: false, why: '画面里没 OCR 出字' }
+    const frameText = lines.map((x) => x.text || '').join(' ')
+    const first = String(lines.map((x) => String(x?.text || '').trim()).find(Boolean) || '')
+    const a = bigramSet(subtitleText)
+    const b = bigramSet(frameText)
+    const small = Math.min(a.size, b.size)
+    const shared = small ? [...a].filter((g) => b.has(g)).length : 0
+    const overlap = small ? shared / small : 0
+    return {
+      ok: true,
+      overlap,
+      first,
+      flagFirst: BAIT_WORD.test(first),
+      frameText: frameText.slice(0, 400),
+      dir: r.dir,
+      cached: !!r.cached,
+    }
+  } catch (e) {
+    return { ok: false, why: `抽帧/OCR 失败：${String(e?.message ?? e).slice(0, 160)}` }
+  }
+}
+
 function credibility(v, text) {
   const sp = speedScore(text, v.dur)
   const ks = keywordScore(text, extractKeywords(v.title, v.owner))
@@ -472,6 +533,8 @@ async function cmdPeek(bv, opts = {}) {
   console.log(`视频: ${v.title}`)
   console.log(`UP: ${v.owner}  时长 ${fmtSec(v.dur)}  播放 ${v.view ?? '?'}  评论 ${v.reply ?? '?'}${pTag}`)
   if (v.desc) console.log(`简介: ${v.desc.replace(/\s+/g, ' ').slice(0, 260)}`)
+  // 目录名带标题（view 通常最先跑，正好把目录定下来）
+  try { writeMeta(bv, { title: v.title, up: v.owner, dur: v.dur, aid: v.aid }, nameVideoDir(bv, v.title)) } catch (e) { console.error("[meta-debug]", e.message) }
   const c = await topComments(v.aid, 5)
   if (c.ok && c.list.length) {
     console.log('\n热评:')
@@ -508,8 +571,8 @@ async function grabFrames(bv, { step = 0, outDir, ffmpeg, fresh = false, p: page
   const useStep = step > 0 ? step : autoStep(v.dur)
   const dirTag = scene ? `scene-${useStep}s` : `${useStep}s`
   const dir = outDir || join(CACHE, 'frames', `${bv}-p${v.p}-${dirTag}`)
-  // --out 指向用户目录时绝不整目录递归删：只覆盖本工具产物（下面 :505/:506 会重下 mp4、清 jpg）
-  if (fresh && !outDir && existsSync(dir)) rmSync(dir, { recursive: true, force: true })
+  // --out 指向用户目录时绝不整目录递归删：只覆盖本工具产物（下面会重下 mp4、清 jpg）
+  // --fresh 的清理**必须等拿到锁之后**：锁外删会把别人刚写的 .lock 一起删掉，两个进程都以为持锁（2026-10-26 审查 T24）
   mkdirSync(dir, { recursive: true })
   const mp4 = join(dir, `${bv}.mp4`)
   const jpgs = () => readdirSync(dir).filter((f) => f.endsWith('.jpg'))
@@ -526,6 +589,12 @@ async function grabFrames(bv, { step = 0, outDir, ffmpeg, fresh = false, p: page
     throw new Error('同目录有另一个实例在抽帧，等不到结果')
   }
   try {
+    if (fresh && !outDir) {
+      for (const e of readdirSync(dir)) {
+        if (e === '.lock') continue // 锁留着，只清产物
+        try { rmSync(join(dir, e), { recursive: true, force: true }) } catch {}
+      }
+    }
     const p = await jget(
       `https://api.bilibili.com/x/player/playurl?avid=${v.aid}&cid=${v.cid}&qn=16&fnval=1&platform=html5&fourk=0`,
     )
@@ -745,6 +814,8 @@ async function cmdView(bv, p = 1) {
   console.log(`UP: ${v.owner} (mid ${v.ownerMid})  时长 ${fmtSec(v.dur)}  播放 ${v.view ?? '?'}  评论 ${v.reply ?? '?'}${pTag}`)
   console.log(`aid=${v.aid} cid=${v.cid}`)
   if (v.desc) console.log(`简介: ${v.desc.replace(/\s+/g, ' ').slice(0, 300)}`)
+  // 目录名带标题（view 常是第一个跑的，正好把目录定下来）
+  try { writeMeta(bv, { title: v.title, up: v.owner, dur: v.dur, aid: v.aid }, nameVideoDir(bv, v.title)) } catch (e) { console.error('[meta-debug]', e.message) }
   const c = await topComments(v.aid, 5)
   if (c.ok && c.list.length) {
     console.log('\n热评:')
@@ -913,7 +984,7 @@ async function cmdSub(bv, credPath, p = 1, opts = {}) {
       if (out) {
         writeFileSync(out, text, 'utf8')
         say(`✓ 已写入 ${out}（${usable} 条，官方时间戳）`)
-      } else console.log(text)
+      } else printText(text, { ...opts, dataOnly: true }, bv, 'sub-srt')
       return
     }
     if (format === 'txt') {
@@ -921,7 +992,7 @@ async function cmdSub(bv, credPath, p = 1, opts = {}) {
       if (out) {
         writeFileSync(out, r.text, 'utf8')
         say(`✓ 已写入 ${out}（${r.count} 行，纯文本）`)
-      } else console.log(r.text)
+      } else printText(r.text, { ...opts, dataOnly: true }, bv, 'sub-txt')
       return
     }
     if (format === 'md') {
@@ -929,7 +1000,7 @@ async function cmdSub(bv, credPath, p = 1, opts = {}) {
       if (out) {
         writeFileSync(out, r.text, 'utf8')
         say(`✓ 已写入 ${out}（${r.count} 条，时间戳可跳回原片）`)
-      } else console.log(r.text)
+      } else printText(r.text, { ...opts, dataOnly: true }, bv, 'sub-md')
       return
     }
     const payload = {
@@ -942,7 +1013,7 @@ async function cmdSub(bv, credPath, p = 1, opts = {}) {
     if (out) {
       writeFileSync(out, text, 'utf8')
       say(`✓ 已写入 ${out}（${payload.cues.length} 条）`)
-    } else console.log(text)
+    } else printText(text, { ...opts, dataOnly: true }, bv, 'sub-json')
     return
   }
   const c = credibility(v, s.text)
@@ -954,7 +1025,7 @@ async function cmdSub(bv, credPath, p = 1, opts = {}) {
   say(
     `  提示 · 关键词重合 ${c.ks.hit}/${c.ks.total}${c.ks.hits.length ? `（${c.ks.hits.join('、')}）` : ''}${c.ks.hit === 0 ? '（零命中，可能标题与主题词不同）' : ''}`,
   )
-  console.log(`\n字幕全文：\n${s.text}`)
+  printText(s.text, opts, bv, 'sub')
 }
 
 async function cmdComments(bv, ps = 10, opts = {}) {
@@ -1204,7 +1275,7 @@ async function cmdAsr(bv, p = 1, ffmpeg = '') {
   }
   const vf = r.verify
   const tag = vf ? (vf.suspect ? '⚠ 疑似幻觉' : '✓ 可信') : ''
-  console.log(`\n转写 ${r.chars} 字${tag ? `（${tag}）` : ''}：\n${r.text}`)
+  printText(r.text, { head: opt('head'), full: flag('full') }, bv, 'asr')
   if (vf?.suspect) {
     console.log(`\n⚠ 转写可信度存疑：${vf.reasons.join('；')}`)
     console.log('  可能是 ASR 在没人声时填的模板句，别当台词用；要确认先抽帧看画面或跑 OCR。')
@@ -1233,7 +1304,7 @@ async function cmdFrames(bv, opts = {}) {
     }
     console.log('\nOCR 识别画面文字…')
     const text = await runOcr(r.dir)
-    console.log(text || '（画面里没识别到文字）')
+    printText(text || '（画面里没识别到文字）', opts, bv, 'ocr-frames')
   }
 }
 
@@ -1247,7 +1318,7 @@ async function cmdOcr(bv, opts = {}) {
   console.log(`抽帧目录: ${r.dir}${r.cached ? '（复用）' : ''}`)
   console.log('OCR 识别画面文字…\n')
   const text = await runOcr(r.dir)
-  console.log(text || '（画面里没识别到文字）')
+  printText(text || '（画面里没识别到文字）', opts, bv, 'ocr')
 }
 
 // ── 拼图：N 帧拼一张，比逐帧读省好几倍 ──
@@ -1456,6 +1527,111 @@ function markSeen(bv, title) {
 }
 
 /** 四级链：字幕 → ASR → 抽帧 OCR。输出最可信的一份文本。 */
+const TEXT_LIMIT = 800 // 超过这个字数就不往终端打，落盘 + 给路径（上下文保护）
+
+/**
+ * 打印或落盘：
+ *   ≤800 字直接打全文；超过就只给摘要（开头 400 字）＋总字数＋落盘路径。
+ *   --head N 指定摘要长度；--full 强制打全文。
+ *   全文总是落盘到 CACHE/<BV>/<kind>.txt，深读直接 read 那个文件。
+ */
+function cleanKey(s) {
+  // 只留字母数字与 _ . -；挡掉 .. / . / Windows 保留设备名，避免输入直接决定磁盘路径
+  const k = String(s || '').replace(/[^\w.-]/g, '').replace(/^\.+$/, '').slice(0, 40)
+  if (!k || /^(con|prn|aux|nul|com[0-9]|lpt[0-9])$/i.test(k)) return '_misc'
+  return k
+}
+
+/** 按视频分目录：CACHE/<BV>/<kind>.txt —— 同一个视频识别到的各层都收在同一个文件夹里 */
+function videoDir(bv) {
+  const base = cleanKey(bv)
+  mkdirSync(CACHE, { recursive: true })
+  // 同一个 BV 已经有目录（可能带标题后缀）就用它，别建第二个
+  try {
+    for (const d of readdirSync(CACHE)) {
+      if (d === base || d.startsWith(base + '_')) return join(CACHE, d)
+    }
+  } catch {}
+  const d = join(CACHE, base)
+  mkdirSync(d, { recursive: true })
+  return d
+}
+
+/** 拿到标题后把目录改成「BV_标题」，人一眼能认；改名失败就用原目录 */
+/** 目录名用的标题片段：保留中文与字母数字，只去掉路径非法字符（cleanKey 会把中文删光，不能复用） */
+function slugTitle(s) {
+  return String(s || '')
+    .replace(/[\\/:*?"<>|]/g, '')
+    .replace(/[\u0000-\u001f]/g, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, 20)
+}
+
+function nameVideoDir(bv, title) {
+  const dir = videoDir(bv)
+  const base = cleanKey(bv)
+  if (!title || basename(dir) !== base) return dir
+  const slug = slugTitle(title)
+  if (!slug) return dir
+  const nice = join(dirname(dir), `${base}_${slug}`)
+  try { renameSync(dir, nice); return nice } catch { return dir }
+}
+
+/** 每个视频目录一份 meta.json：是哪条视频、什么时候抓的、抓了哪些文件各多少字节 */
+function writeMeta(bv, extra = {}, dirHint = '') {
+  const dir = dirHint || videoDir(bv)
+  const p = join(dir, 'meta.json')
+  let meta = {}
+  try { meta = JSON.parse(readFileSync(p, 'utf8')) } catch {}
+  Object.assign(meta, { bv, updatedAt: new Date().toISOString() }, extra)
+  if (!meta.createdAt) meta.createdAt = meta.updatedAt
+  try {
+    meta.files = readdirSync(dir)
+      .filter((f) => f !== 'meta.json')
+      .map((f) => ({ name: f, bytes: statSync(join(dir, f)).size }))
+    writeFileSync(p, JSON.stringify(meta, null, 2) + '\n', 'utf8')
+  } catch {}
+  return dir
+}
+
+function printText(text, opts, bv, kind = 'text') {
+  const full = String(text || '').trim()
+  if (!full) return
+  // 数据模式（--format json/srt/md/txt 且没给 --out）：stdout 只许有数据，不截断、不落盘、不打提示
+  if (opts && opts.dataOnly) { process.stdout.write(full + (full.endsWith('\n') ? '' : '\n')); return }
+  let file = ''
+  try {
+    file = join(videoDir(bv), `${kind}.txt`)
+    writeFileSync(file, full, 'utf8')
+  } catch { file = '' }
+  if (file) { try { writeMeta(bv, { [`${kind}Chars`]: full.length }) } catch {} }
+  if (!file) {
+    // 缓存目录不可写：宁可变长也不丢内容
+    console.log(`\n${full}`)
+    console.error('⚠ 全文落盘失败（缓存目录不可写），已直接打印全文；检查 BILI_WATCH_CACHE 或 deps 里的 cache')
+    return
+  }
+  const head = Number(opts.head) > 0 ? Number(opts.head) : 0
+  if (opts.full) {
+    console.log(`\n${full}`)
+    if (file) console.log(`[text] 全文 ${full.length} 字（--full）`)
+    return
+  }
+  if (head) {
+    console.log(`\n${full.slice(0, head)}`)
+    console.log(`\n[text] 全文 ${full.length} 字，这里给前 ${head} 字；全文：${file || '（落盘失败）'}`)
+    return
+  }
+  if (full.length <= TEXT_LIMIT) { console.log(`\n${full}`); return }
+  const brief = 400
+  console.log(`\n${full.slice(0, brief)}`)
+  console.log(`\n…（全文 ${full.length} 字，这里只给开头 ${brief} 字）`)
+  if (file) console.log(`全文已存：${file}`)
+  console.log('要看更多：--head 1200 给前 1200 字；--full 打全文')
+  if (file) console.log(`模型/agent：直接 read ${file} 拿全文，别再跑一遍命令`)
+}
+
 async function cmdText(bv, credPath, opts = {}) {
   QUIET = opts.format === 'json' || opts.format === 'md'
   const t0 = Date.now()
@@ -1481,6 +1657,26 @@ async function cmdText(bv, credPath, opts = {}) {
   }
   if (s.ok) {
     const c = credibility(v, s.text)
+    const bait = baitSignals(s.text, v, c)
+    let check = null
+    if (bait.suspect) {
+      // 默认只提示、不抽帧：语速异常在 MV / 音乐 / 风景片里很常见，
+      // 自动下载整片核对等于给常态任务加十几秒成本。要看画面加 --verify。
+      say(`[track] ⚠ 字幕可疑：${bait.reasons.join('；')}${opts.verify ? '' : '（要看画面加 --verify）'}`)
+      if (opts.verify) {
+        say('[track] 抽帧核对画面…')
+        check = await checkBaitFrames(bv, v, s.text, opts)
+        if (!check.ok) {
+          say(`[track] ⚠ 画面核对做不了：${check.why}（字幕仍给，但请自己看画面）`)
+        } else if (check.flagFirst) {
+          say(`[track] ⚠⚠ 首帧写着「${check.first.slice(0, 60)}」——这是实验/钓鱼片，字幕和简介都可能是饵`)
+        } else if (check.overlap < 0.05) {
+          say(`[track] ⚠⚠ 画面文字跟字幕几乎不重合（重合度 ${(check.overlap * 100).toFixed(1)}%，首帧「${check.first.slice(0, 50)}」）`)
+        } else {
+          say(`[track] 画面核对：重合度 ${(check.overlap * 100).toFixed(1)}%，未见诱饵迹象`)
+        }
+      }
+    }
   // 信道优先：官方字幕能拿到就是可信内容，语速/关键词只作提示，不拦
   // 口径差异（有意）：自动化选片链路会把「语速/关键词不合格」当硬拦，
   // 这里是人看的排查通道，取到就用、质量交给调用方判断。同一判据两种策略，别当 bug 报。
@@ -1491,12 +1687,13 @@ async function cmdText(bv, credPath, opts = {}) {
       timeline: { exact: true, source: 'official-subtitle' },
       cues: (s.cues || []).map((c) => ({ from: Number(c?.from ?? 0), to: Number(c?.to ?? 0), content: String(c?.content ?? '') })),
       text: s.text,
+      warnings: check ? { suspect: bait.suspect, reasons: bait.reasons, ...check } : undefined,
     })) {
       done()
       return
     }
     say(`[track] ${via}: ok ${s.text.length} 字（语速 ${c.sp.rate ?? '?'} 字/秒，关键词 ${c.ks.hit}/${c.ks.total}）`)
-    console.log(`\n${s.text}`)
+    printText(s.text, opts, bv)
     done()
     return
   }
@@ -1524,7 +1721,7 @@ async function cmdText(bv, credPath, opts = {}) {
           return
         }
         say(`[track] 转写: ok ${a.chars} 字（${rate.toFixed(1)} 字/秒${a.cached ? '，缓存命中' : ''}；机器转写，专有名词可能有错）`)
-        console.log(`\n${a.text}`)
+        printText(a.text, opts, bv)
         done()
         return
       }
@@ -1554,7 +1751,7 @@ async function cmdText(bv, credPath, opts = {}) {
         return
       }
       say(`[track] 画面 OCR: ok（${r.dir}；这是画面上的字，不是口播内容）`)
-      console.log(`\n${text}`)
+      printText(text, opts, bv)
       done()
       return
     }
@@ -1579,7 +1776,7 @@ async function cmdText(bv, credPath, opts = {}) {
 const argv = process.argv.slice(2)
 const cmd = argv[0]
 // 带值的选项：解析位置参数时必须跳过它们的值，否则 `hot --limit 2` 会把 "2" 当成 BV
-const VALUE_OPTS = new Set(['cred', 'days', 'ffmpeg', 'grid', 'key', 'limit', 'order', 'out', 'p', 'step', 'format'])
+const VALUE_OPTS = new Set(['cred', 'days', 'ffmpeg', 'grid', 'key', 'limit', 'order', 'out', 'p', 'step', 'format', 'head'])
 function positional(list) {
   const out = []
   for (let i = 0; i < list.length; i++) {
@@ -1941,8 +2138,7 @@ async function runGeneric(cmd, src, opts = {}) {
     const r = await transcribeLocal(dl.path, tag, { timeoutMs: cmd === 'text' ? 180_000 : 900_000 })
     if (!r.ok) { console.error(`✗ ${r.why}`); process.exit(1) }
     console.log(`\n转写 ${r.chars} 字：${r.cached ? '（缓存命中）' : ''}`)
-    if (cmd === 'text') console.log(`\n${r.text.slice(0, 6000)}`)
-    else console.log(`\n${r.text}`)
+    printText(r.text, {}, tag, cmd === 'text' ? 'text' : 'asr')
     return
   }
 }
@@ -1973,11 +2169,13 @@ const HELP = `用法:
   node look.mjs sheet <BV或链接> [--grid 3x3] [--step 2]   N 帧拼一张九宫格（仅 B 站）
   node look.mjs substrip <BV或链接> [--step 7]          底部字幕带竖拼一张图（仅 B 站）
   node look.mjs ocr <BV或链接> [--step 2]     抽帧 + OCR 出文字（仅 B 站）
-  node look.mjs text <BV或链接或URL> [--cred 凭证路径] [--step 2] [--fast] [--mark-seen] [--format json] [--out 文件]
+  node look.mjs text <BV或链接或URL> [--cred 凭证路径] [--step 2] [--fast] [--mark-seen] [--verify] [--head N] [--full] [--format json] [--out 文件]
   node look.mjs login [--poll] [--check]    扫码登录，拿 AI 字幕用的本地凭证
   node look.mjs clean
 
   多 P 视频加 --p N 指定第几个分P（默认 P1）。
+  --verify：text 拿到字幕后，若字幕可疑（语速不在 2–8.5 字/秒、关键词命中过低、字幕自称实验/钓鱼）
+            再加抽帧 OCR 核对画面，报「字幕与画面不重合」；不加只打一行提示，不花抽帧时间。
   --format：sub 支持 text|srt|json|md|txt（srt/md 带真时间戳，md 的时间戳可跳回原片，txt 是一行一句）；
   text 支持 text|json|md（json 带时间轴口径：字幕 exact / 转写与 OCR 是估算）；
   comments 与 danmaku 支持 json（stdout 只有 JSON，可接 jq）。
@@ -2004,7 +2202,7 @@ try {
   } else if (cmd === 'view') {
     await cmdView(BV, P)
   } else if (cmd === 'sub') {
-    await cmdSub(BV, CRED, P, { format: opt('format') || 'text', out: opt('out') || '' })
+    await cmdSub(BV, CRED, P, { format: opt('format') || 'text', out: opt('out') || '', head: opt('head') || '', full: flag('full') })
   } else if (cmd === 'comments') {
     await cmdComments(BV, Number(pos[2] || 10), { format: opt('format') || 'text', out: opt('out') || '' })
   } else if (cmd === 'danmaku') {
@@ -2020,7 +2218,7 @@ try {
   } else if (cmd === 'ocr') {
     await cmdOcr(BV, { step: STEP, p: P })
   } else if (cmd === 'text') {
-    await cmdText(BV, CRED, { step: STEP, p: P, fast: flag('fast'), mark: flag('mark-seen'), format: opt('format') || 'text', out: opt('out') || '' })
+    await cmdText(BV, CRED, { step: STEP, p: P, fast: flag('fast'), mark: flag('mark-seen'), verify: flag('verify'), format: opt('format') || 'text', out: opt('out') || '', head: opt('head') || '', full: flag('full') })
   } else if (cmd === 'clean') {
     if (existsSync(CACHE)) {
       rmSync(CACHE, { recursive: true, force: true })

package/tools/verify.mjs

@@ -0,0 +1,109 @@
+/**
+ * 发布前守卫：把「已经踩过一次的坑」变成可执行断言。
+ *
+ * 由来（2026-10-26 审查 T12）：0.2.23 的两个修复（.tool.txt 后缀隔离、--format json 的
+ * 数据模式短路）没有任何自动化守卫，改一下就可能悄悄退回去。这个文件只做一件事：
+ * 每条坑一条断言，跑完打印 PASS/FAIL，有 FAIL 就 exit 1。
+ *
+ * 用法：node tools/verify.mjs
+ * 不进 npm 包（files 里只留 tools/look.mjs，见 package.json）。
+ */
+import { readFileSync } from 'node:fs'
+import { execFileSync } from 'node:child_process'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const HERE = dirname(fileURLToPath(import.meta.url))
+const ROOT = join(HERE, '..')
+const read = (rel) => readFileSync(join(ROOT, rel), 'utf8')
+
+const results = []
+const check = (name, fn) => {
+  try {
+    const detail = fn()
+    results.push({ name, ok: true, detail: detail ?? '' })
+  } catch (e) {
+    results.push({ name, ok: false, detail: e?.message ?? String(e) })
+  }
+}
+const must = (cond, msg) => { if (!cond) throw new Error(msg) }
+// 依赖网络的断言默认跳过：网络抖动不该让守卫变红（静态断言永远可跑）。VERIFY_ONLINE=1 才联网验。
+const skip = (name, why) => results.push({ name, ok: true, skip: true, detail: why })
+const online = process.env.VERIFY_ONLINE === "1"
+
+// —— 静态断言 ——
+check('版本号不是 0.2.22（P0：sync-release 会把新版覆盖成旧版）', () => {
+  const v = JSON.parse(read('package.json')).version
+  must(v !== '0.2.22', `package.json version=${v}`)
+  return v
+})
+
+check('--fresh 的删除在 tryLock 之后（P0：锁外删会删掉别人的 .lock）', () => {
+  const t = read('tools/look.mjs')
+  const iLock = t.indexOf('const lock = tryLock(dir)')
+  const iFresh = t.indexOf("if (fresh && !outDir) {\n      for (const e of readdirSync(dir))")
+  must(iLock > 0, '找不到 tryLock')
+  must(iFresh > 0, '找不到锁内的 fresh 清理块')
+  must(iFresh > iLock, 'fresh 清理出现在 tryLock 之前')
+  must(!t.includes('if (fresh && !outDir && existsSync(dir)) rmSync'), '锁外那份 rmSync 还在')
+  return `lock@${iLock} < fresh@${iFresh}`
+})
+
+check('index.js 的 videoDir 复用「BV_标题」目录（P0：同一视频两个兄弟目录）', () => {
+  const t = read('index.js')
+  must(t.includes("d.startsWith(base + '_')"), 'videoDir 没有复用逻辑')
+  return 'ok'
+})
+
+check('index.js 的失败兜底带退出码（P0：别把错误抹成「没有输出」）', () => {
+  const t = read('index.js')
+  must(!t.includes("|| '（没有输出）'"), '旧的「（没有输出）」还在')
+  must(t.includes('退出码'), '兜底文案没带退出码')
+  return 'ok'
+})
+
+check('工具层落盘用 .tool.txt 后缀（P0：别覆盖 CLI 落的全文）', () => {
+  const t = read('index.js')
+  must(t.includes('`${name}.tool.txt`'), '找不到 .tool.txt')
+  return 'ok'
+})
+
+check('数据模式短路还在（P0：--format json 不许被提示污染）', () => {
+  const t = read('tools/look.mjs')
+  must(t.includes('opts.dataOnly'), 'printText 里没有 dataOnly 分支')
+  return 'ok'
+})
+
+// —— 行为断言（真跑，但都很快）——
+if (online) check('text 摘要里给出落盘路径（P0：摘要必须指路，别让人再跑一遍）', () => {
+  const out = execFileSync(process.execPath, [join(HERE, 'look.mjs'), 'text', 'BV19dJQ6sE9F', '--head', '40'], {
+    encoding: 'utf8', timeout: 120000,
+  })
+  must(/text\.txt/.test(out), '输出里没有 text.txt 路径')
+  must(/全文/.test(out), '输出里没有全文长度说明')
+  return 'ok'
+})
+
+if (online) check('sub --format json 的 stdout 是纯 JSON（P0：机器可读格式不许有中文提示）', () => {
+  const out = execFileSync(process.execPath, [join(HERE, 'look.mjs'), 'sub', 'BV19dJQ6sE9F', '--format', 'json'], {
+    encoding: 'utf8', timeout: 120000, maxBuffer: 16 * 1024 * 1024,
+  })
+  must(out.trimStart().startsWith('{'), `首字符是 ${JSON.stringify(out.slice(0, 12))}`)
+  JSON.parse(out)
+  return `${out.length} B`
+})
+
+if (!online) {
+  skip('text 摘要里给出落盘路径', '联网断言，设 VERIFY_ONLINE=1 才跑')
+  skip('sub --format json 纯 JSON', '联网断言，设 VERIFY_ONLINE=1 才跑')
+}
+
+// —— 汇总 ——
+let bad = 0
+for (const r of results) {
+  if (!r.ok) bad++
+  const tag = r.skip ? 'SKIP' : r.ok ? 'PASS' : 'FAIL'
+  console.log(`${tag}  ${r.name}${r.detail ? '  —  ' + r.detail : ''}`)
+}
+console.log(`\n${results.length - bad}/${results.length} 通过`)
+process.exit(bad ? 1 : 0)