master-skill 0.11.0 → 0.12.0

package/scripts/verify_citations.py

@@ -19,43 +19,455 @@
 from __future__ import annotations
 
 import argparse
+import functools
 import json
 import os
 import re
 import sys
+import threading
+import unicodedata
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import NamedTuple
 
-from _masterpaths import resolve_master_dir
+from _masterpaths import PREBUILT as PREBUILT_ROOT, resolve_master_dir
 
 # master feeds into path resolution; restrict to a slug charset so a value like
 # "../../etc" can never read files outside prebuilt/. Mirrors the isSafeName
 # guard in bin/cli.mjs and scripts/query.py.
 _SAFE_MASTER = re.compile(r"^[A-Za-z0-9_-]+$")
 
-# CBETA id 形态:T48n2008 / T08n0235(藏经卷+n+编号),及 API 返回的 X1218 / X0303
-# (无卷号)。无 `n` 的形态只认 T/X 两个集合,避免误吞 Wikidata 的 Q1234 / P5008。
+# CBETA id 形态:T48n2008 / T08n0235(藏经卷+n+编号)、嘉兴藏
+# J36nB348(字母 B 是目录号的一部分),及 API 返回的 X1218 / X0303 / JB348
+# (无卷号)。无 `n` 的形态只认 T/X 纯数字与 J+B编号,避免误吞 Wikidata 的
+# Q1234 / P5008。
 #
 # 边界不能用 \b:Python 的 \w 覆盖 CJK,故「卷一T99n9999」的「一」与「T」之间
 # 没有 \b,整块引文会被 audit_answer 当作无 id 跳过 —— 而格式跑偏正是模型最可能
 # 编造经号的时候。改判「前后不是拉丁字母或数字」:汉字紧邻属真实引文形态,须命中;
 # 拉丁字母紧邻(FakeSutraT99n9999)通常意味着它只是更长 token 的一部分,不算引文。
 _CBETA_ID = re.compile(
-    r"(?<![0-9A-Za-z])(?:[A-Z]{1,2}\d+n\d+|[TX]\d{3,})(?![0-9A-Za-z])"
+    r"(?<![0-9A-Za-z])(?:"
+    r"[A-Z]{1,2}\d+n[A-Z]?\d+[a-z]?|[TX]\d{3,}|JB\d{3,}"
+    r")(?![0-9A-Za-z])"
 )
+# 非 CBETA 契约家族。roadmap Phase 2 承诺把 CBETA / BDRC·Toh / PTS·SuttaCentral /
+# 编集开示当作平等的 contract family,但审计器长期只实现了第一个 —— 于是全部藏传与
+# 南传祖师的伪造引用一律漏检(见 eval/reports/BASELINE.md 的撤回段)。
+#
+# 关键在归一化,不在正则:meta.json 声明 `Toh:4465`,行文写 `Toh 4465`;声明
+# `BDRC:W22272`,夹具 must_cite 写裸 `W22272`。只加正则不归一,会把**正确**引用
+# 判成伪造 —— 那比漏检更糟。统一收敛到 `Family:Work` 再与声明集比对。
+_FAMILY_ID = re.compile(
+    r"(?<![0-9A-Za-z])(?:"
+    r"(?P<toh>Toh)[:\s]\s*(?P<toh_n>\d+)"
+    r"|(?P<bdrc>BDRC)[:\s]\s*(?P<bdrc_w>W[0-9A-Za-z-]+)"
+    # 真 PTS id 的作品名首字母大写(`PTS:Vism` / `PTS:DN-Comm`)。要求大写,
+    # 「（PTS edition）」这类散文说明才不会被读成 id。
+    r"|(?P<pts>PTS)[:\s]\s*(?P<pts_w>[A-Z][0-9A-Za-z-]*)"
+    # 裸 W 号:BDRC 的 work id 常单独出现(W22272 / W1KG14334)。要求 W 后紧跟数字,
+    # 否则 "Wisdom Publications" 这类普通词会被误读成 id。
+    r"|(?P<bare_w>W\d[0-9A-Z-]{3,})"
+    r")(?![0-9A-Za-z])"
+)
+
+
+def _normalize_family_id(m: "re.Match[str]") -> str:
+    """把一处家族引文归一成 meta.json 里声明的 `Family:Work` 形态。"""
+    if m.group("toh"):
+        return f"Toh:{m.group('toh_n')}"
+    if m.group("bdrc"):
+        return f"BDRC:{m.group('bdrc_w')}"
+    if m.group("pts"):
+        return f"PTS:{m.group('pts_w')}"
+    return f"BDRC:{m.group('bare_w')}"
+
+
+# 学术引用常把大正藏经号写成「T31 No.1585」「T 48, no. 2008」—— 藏别字母、册号、
+# `No.`、经号。`_CBETA_ID` 只认 `T31n1585` 这一种拼写，于是这类引文整块进
+# `unparsed`：真引用没被核对，编造的也抓不到。存档里实测四处：2026-08-31 全量运行
+# `compare-masters` 一处 `T48 No.2008`；2026-09-13 元技能复测三处 `T31 No.1585`
+# ×2、`T31 No.1614`。
+#
+# 归一成声明集的拼写（`T31n1585`，册号补到两位、经号补到四位），再交给同一套比对
+# ——包括只在册号、经号、字母后缀全部相等时才放行的未补零分支。这里不另开放行口子，
+# 只让这种写法进得了审计。
+#
+# `[0-9]` 而非 `\d`：这是解析器，理由同下方 `_SHORT_FORM` —— 全角数字不得经 `int()`
+# 洗成一个「已核验」的真经号。
+_CBETA_NO_FORM = re.compile(
+    r"(?<![0-9A-Za-z])([TXJ])\s?([0-9]{1,3}),?\s*[Nn][Oo]\.\s*(B?[0-9]{1,5})(?![0-9A-Za-z])"
+)
+
+
+def _canonical_no_form(match: re.Match) -> str:
+    canon, volume, number = match.group(1), int(match.group(2)), match.group(3)
+    work = number if number.startswith("B") else f"{int(number):04d}"
+    return f"{canon}{volume:02d}n{work}"
+
+
+def extract_citation_ids(text: str) -> list[str]:
+    """抽出一段文本里所有可核对的来源 id,四个家族一视同仁。
+
+    CBETA 号按原样返回(声明形态与行文形态本来就一致);其余家族归一到
+    `Family:Work`。SuttaCentral 是**语料库级** id(runtime contract §4 规则 3),
+    `MN 118` 这类经号无法在没有经目索引的情况下判真伪,故不在此抽取 —— 那是
+    已知边界,不是遗漏。
+    """
+    ids = list(_CBETA_ID.findall(text))
+    ids.extend(_canonical_no_form(m) for m in _CBETA_NO_FORM.finditer(text))
+    ids.extend(_normalize_family_id(m) for m in _FAMILY_ID.finditer(text))
+    return ids
+
+
+# 短号 ↔ 完整号。CBETA 通行简写省掉册号(`T1911` = `T46n1911`,
+# `JB348` = `J36nB348`),而 meta.json 存完整形态。审计无条件运行之后,
+# 模型写简写就会被误判伪造。按「藏别字母 + 经号」对齐,跨藏不对齐；
+# Jiaxing 的 B 前缀必须保留。
+# `[0-9]`,不是 `\d`。这两个正则**不是**识别器,是**解析器** —— 它们把行文里的
+# 短号对回声明集,命中即判 offline(已核验)。所以上面那条「识别 id 宽松是安全的」
+# 在这里**不成立**:`\d` 吃全角,`int()` 又把 `T１９１１` 归一成 1911,于是一个在
+# 任何平台都解析不出来的引文串被报成「已核验的声明源」—— 不是多抓一条判伪造,
+# 是 over-resolve 成了通过。
+#
+# `{1,8}`:`int()` 在 4300 位以上抛 ValueError,而这条路跑在 check_response 里,
+# 一条 `【x，T999…(5000个9)】` 能把整轮付费评测掀翻。经号最长四五位,8 位够宽。
+_SHORT_FORM = re.compile(r"^([TXJ])(B?[0-9]{1,8})$")
+_FULL_FORM = re.compile(r"^([TXJ])[0-9]{1,8}n(B?[0-9]{1,8})[a-z]?$")
+
+
+def _normalize_cbeta_work_number(number: str) -> str:
+    """Strip numeric zero padding while retaining a Jiaxing `B` prefix."""
+    prefix = "B" if number.startswith("B") else ""
+    digits = number[1:] if prefix else number
+    return f"{prefix}{int(digits)}"
+
+
+# 完整形但作品号未补零:`T14n475` 之于声明的 `T14n0475`。CBETA 习惯把作品号
+# 补到四位,模型常照写不补 —— 这不是短号(`T2008` 那种没有卷号的形态),所以
+# `_SHORT_FORM` 匹配不上,`_resolve_short_form` 直接返回 None,于是一条**正确**
+# 引用被判成**伪造**。2026-09-13 探针实测:master-debate 一条回答里 4 个引文块,
+# 3 个栽在这上面。判伪造比漏检更糟 —— 漏检只是没看,判伪造是指着真话说假话。
+_UNPADDED_FULL_FORM = re.compile(r"^([TXJ])([0-9]{1,8})n(B?[0-9]{1,8})([a-z]?)$")
+
+
+def _resolve_short_form(cid: str, declared_ids: set[str]) -> str | None:
+    """把短号 / 未补零的完整号对回声明里的完整号;对不上返回 None(仍按伪造处理)。"""
+    m = _SHORT_FORM.match(cid)
+    if m:
+        prefix = m.group(1)
+        number = _normalize_cbeta_work_number(m.group(2))
+        for declared in declared_ids:
+            d = _FULL_FORM.match(declared)
+            if (
+                d
+                and d.group(1) == prefix
+                and _normalize_cbeta_work_number(d.group(2)) == number
+            ):
+                return declared
+        return None
+
+    full = _UNPADDED_FULL_FORM.match(cid)
+    if not full:
+        return None
+    # 比短号那一支**更严**:卷号也必须相等。否则 `T99n0475` 会冒充
+    # `T14n0475` —— 卷号写错的引用不该被洗白成正确的。
+    prefix, volume, number, suffix = (
+        full.group(1),
+        full.group(2).lstrip("0") or "0",
+        _normalize_cbeta_work_number(full.group(3)),
+        full.group(4),
+    )
+    matches = []
+    for declared in declared_ids:
+        d = _UNPADDED_FULL_FORM.match(declared)
+        if (
+            d
+            and d.group(1) == prefix
+            and (d.group(2).lstrip("0") or "0") == volume
+            and _normalize_cbeta_work_number(d.group(3)) == number
+            and d.group(4) == suffix
+        ):
+            matches.append(declared)
+    # 歧义时不放行。现有声明集里归一后没有撞号(实测 35 条完整形,0 处冲突),
+    # 但放行凭据必须失败即安全 —— 将来多一条就会撞。
+    return matches[0] if len(matches) == 1 else None
+
+
+# 第四个契约家族:编集开示(compiled_teaching)。声明形态是 `Author:Work`
+# (`AjahnChah:StillForestPool`),而行文里它只以书名出现(《A Still Forest Pool》)——
+# 没有编号可抓,所以这一家必须拿声明集当钥匙来读,不能像前三家那样先抽 id 再比对。
+#
+# 难点仍是归一化。三处真实差异,每一处只要漏掉就会把**正确**引用判成伪造:
+#   声明 StillForestPool      ← 行文《A Still Forest Pool》        冠词
+#   声明 ProgressOfInsight    ← 行文《The Progress of Insight (Visuddhiñāṇa-kathā)》 冠词 + 括注
+#   声明 PracticalVipassana   ← 行文《Practical Vipassanā Meditation Exercises》 变音符 + 副标题
+# 故:去括注 → 去变音符 → 切词 → 去首冠词 → 声明词序为行文词序的**前缀**才算命中。
+# 前缀是有向的:声明比行文长不算命中,否则《Practical》就能冒充整本书。
+_WORK_TITLE = re.compile(r"《([^》]+)》")
+_PARENTHETICAL = re.compile(r"[（(][^）)]*[）)]")
+_CJK = re.compile(r"[\u3400-\u9fff\uf900-\ufaff]")
+# 前三家的家族名不是作者名,排除掉;`Toh:4465` 这类纯数字 Work 也不是书名。
+_ID_FAMILIES = {"Toh", "BDRC", "PTS"}
+_ARTICLES = {"a", "an", "the"}
+# 语料库级的 SuttaCentral 经号也常写进书名号里(《MN 10 / Satipaṭṭhāna Sutta》)。
+# 它是拉丁字面、又不会匹配任何编集开示,若不先挡掉就会被这一家判成伪造 ——
+# 阿姜查自己的 references/teaching.md 里就有四条。经号真伪需要经目索引才能判,
+# 那是 runtime contract §4 规则 3 划出的已知边界,此处维持「读不懂」而非「伪造」。
+_SUTTA_REF = re.compile(
+    r"^(?:SC[:：]\s*)?(?:MN|SN|AN|DN|KN|Dhp|Ud|Iti|Snp|Thag|Thig|Vin)\s*\d",
+    re.IGNORECASE,
+)
+
+
+def _fold(text: str) -> str:
+    """去掉变音符号:Vipassanā → Vipassana、Visuddhiñāṇa → Visuddhinana。"""
+    decomposed = unicodedata.normalize("NFKD", text)
+    return "".join(c for c in decomposed if not unicodedata.combining(c))
+
+
+def _title_tokens(title: str) -> list[str]:
+    """行文书名 → 归一词序。"""
+    words = re.findall(r"[A-Za-z]+", _fold(_PARENTHETICAL.sub(" ", title)).lower())
+    if words and words[0] in _ARTICLES:
+        words = words[1:]
+    return words
+
+
+def _work_tokens(work: str) -> list[str]:
+    """声明里的 CamelCase Work → 归一词序。FoodForTheHeart → food for the heart。"""
+    words = [w.lower() for w in re.findall(r"[A-Z][a-z]*|[a-z]+", _fold(work))]
+    if words and words[0] in _ARTICLES:
+        words = words[1:]
+    return words
+
+
+def _compiled_works(declared_ids: set[str]) -> dict[str, tuple[str, ...]]:
+    """声明集里属编集开示家族的 id → 其归一词序。"""
+    works: dict[str, tuple[str, ...]] = {}
+    for declared in declared_ids:
+        family, _, work = declared.partition(":")
+        if not work or family in _ID_FAMILIES or work.isdigit():
+            continue
+        tokens = _work_tokens(work)
+        if tokens:
+            works[declared] = tuple(tokens)
+    return works
+
+
+# 合集覆盖成员。声明的编集开示有时是一部合集,note 里点了具体成员篇目的名
+# ("Mālukyaputta Sutta / Dhammacakka Sutta / Sallekha Sutta 等开示集") ——
+# 人格引某一篇具体开示时用的是篇目名,不是合集自己的 CamelCase 名。2026-09-03
+# 裁定:合集自己 note 点过名的成员,应可解析回它所属的合集。
+#
+# 形状而非内容驱动:note 里没有 `/` 就不是成员列表(多数 note 只是单条书目
+# 说明,如「1944 缅文巨著…」),不必解析。单字词片段(裸的 "Sutta")几乎
+# 每条引用都会命中,要求至少两个词才够格当别名。
+_MEMBER_MIN_WORDS = 2
+
+
+# CJK ideographs (_CJK's own range) plus CJK punctuation/fullwidth blocks
+# (U+3000-303F, U+FF00-FFEF) -- both split a note segment into non-CJK
+# candidate pieces. Ideographs alone are not enough: a real note ends one
+# member's title with a full-width comma before trailing publisher info
+# ("Sallekha Sutta <CJK note>, BPS Sri Lanka") -- not splitting on that comma
+# lets the Latin tail glue onto the punctuation and out-length the real title.
+# Built with \u escapes, not typed CJK literals: hand-typing ideograph range
+# endpoints is easy to mistype silently (happened once here -- meant U+F900,
+# typed a character that turned out to be U+8C48, widening the range to
+# swallow everything in between).
+_CJK_OR_PUNCT = re.compile("[" + _CJK.pattern[1:-1] + "\u3000-\u303f\uff00-\uffef]")
+
+
+def extract_member_aliases(collection_id: str, note: str) -> dict[str, str]:
+    """把合集来源的 note 解析成「成员篇目名 → 合集 id」的别名表。
+
+    每段取**被 CJK(表意字+标点)切开后最长的那一块**,而非「第一个 CJK 字符
+    之前」——后者假设英文标题总在 CJK 说明之前,「开示集包括 X」这类中文在前
+    的写法会被整段吞掉、标题静默丢失。丢失是安全的方向(该词仍按未声明处理,
+    不会被错误洗白),但没必要留着这个假设。
+    """
+    if "/" not in note:
+        return {}
+    aliases: dict[str, str] = {}
+    for segment in note.split("/"):
+        pieces = _CJK_OR_PUNCT.split(segment)
+        title = max((p.strip() for p in pieces), key=len, default="")
+        if len(re.findall(r"[A-Za-z]+", title)) < _MEMBER_MIN_WORDS:
+            continue
+        aliases[title] = collection_id
+    return aliases
+
+
+def _compiled_teaching_id(
+    block: str,
+    declared_ids: set[str],
+    member_aliases: dict[str, str] | None = None,
+) -> str | None:
+    """把一个书名块判给编集开示家族。
+
+    命中声明的整部作品 → 返回那条声明 id(记 offline);命中某合集 note 里
+    点名的成员篇目 → 返回该合集的 id;本 master 确实有编集开示来源、而这个
+    拉丁书名两者都不命中 → 返回书名本身(交给 audit_answer 按伪造处理);
+    家族不适用(汉文书名,或本 master 根本没有编集开示来源)→ None,维持原样。
+    """
+    works = _compiled_works(declared_ids)
+    if not works:
+        return None
+    m = _WORK_TITLE.search(block)
+    if not m:
+        return None
+    title = m.group(1)
+    if _CJK.search(title) or not re.search(r"[A-Za-z]", title):
+        return None
+    if _SUTTA_REF.match(title.strip()):
+        return None
+    cited = _title_tokens(title)
+    if not cited:
+        return None
+    # 最长匹配优先,不按字典序:一个声明作品的词序若恰是另一个声明作品词序的
+    # 前缀(如 Food / FoodForTheHeart),字典序会把引用错记到更短、字典序更靠
+    # 前的那一个。按前缀长度降序取第一个命中,才是「最贴合」的那条声明。
+    prefix_matches = [
+        (declared, tokens)
+        for declared, tokens in works.items()
+        if tuple(cited[: len(tokens)]) == tokens
+    ]
+    if prefix_matches:
+        return max(prefix_matches, key=lambda pair: len(pair[1]))[0]
+    # 成员别名只按「结尾」匹配,不接受别名之后还有多余文字。真实形态是
+    # 「描述性前缀 + 成员全名」("A Discourse on Dhammacakka Sutta"),全名
+    # 在尾部;若接受别名出现在任意位置,一个编造标题只要恰好包含真成员名的
+    # 子串就会被洗白("...Dhammacakka Sutta That Does Not Exist")。
+    for member, collection in sorted((member_aliases or {}).items()):
+        needle = tuple(_title_tokens(member))
+        if needle and len(needle) <= len(cited) and tuple(cited[-len(needle):]) == needle:
+            return collection
+    return f"《{title}》"
+
+
 # 引文块 【…】
 _CITATION_BLOCK = re.compile(r"【([^】]*)】")
+# 一个【…】块要算「引文」,至少得含书名号、拉丁字母或数字 —— 本仓的引文契约
+# 里每条引用都指名一部作品(《…》)或一个标识符。人格也拿【…】当小标题写
+# (`【辨名义】`、`【立宗】`、`【破异说】`,以及把问题原样复述一遍),那些既不是
+# 引文,也不该进 `unparsed`:它们会把分母撑大、把覆盖率压低,让一份诚实的报告
+# 显得比实际差。2026-09-12 那轮 629 个块里有 10 个是这种。
+#
+# 不静默丢弃 —— 单列一类回传。整块 silently skip 正是当年让「审计了但一条都
+# 没看懂」和「已审计、干净」在报告里长得一模一样的那个动作。
+_LOOKS_LIKE_CITATION = re.compile(r"《|[A-Za-z0-9]")
 # live 链接 fojin.app/texts/<数字>
-_FOJIN_TEXT_LINK = re.compile(r"fojin\.app/texts/(\d+)")
+#
+# `[0-9]` 而不是 `\d`:Python 的 `\d` 默认吃全部 Unicode 数字,于是
+# `fojin.app/texts/１２３`(全角)曾被判成 live —— 一条未声明的伪造经号,靠一个
+# fojin.app 路由根本打不开的链接就被洗白。`--online`(唯一会去解析该 id 的路径)
+# 是可选的,CI 硬门只跑离线判定,永远不会发现。
+#
+# 注意这里与上面几个 id 正则的**方向相反**,不要顺手一起改:
+#   识别 id 宽松 → 多抓 → 判 fabricated → 失败,安全;
+#   放行链接宽松 → 多放 → 洗白伪造引文 → 通过,危险。
+# 所以「放行凭据」这一个要往死里收紧,`_CBETA_ID` / `_FAMILY_ID` 保持宽松。
+#
+# 只收紧数字还不够 —— 原来是个**无锚子串**匹配,于是这两个都能放行伪造引文:
+#     https://evil.example.com/?ref=fojin.app/texts/123
+#     https://myfojin.app/texts/123
+# 现在要求 `fojin.app` 紧跟在 `://` 之后,且 `://` 前面不能再接路径字符
+# (挡掉 `https://evil.com/https://fojin.app/...`)。全仓真实引用一律写
+# `https://fojin.app/texts/N`(实测 251 处无一例外),裸域名只出现在注释与散文里,
+# 所以要求 scheme 不会误伤正确引用。
+# `{1,10}`:上限存在是因为 `int()` 在 4300 位以上抛 ValueError,而调用它的
+# `_resolve_short_form` 跑在 check_response 里,一条畸形引文能掀翻整轮付费评测。
+_FOJIN_TEXT_LINK = re.compile(
+    r"(?<![\w./-])https?://fojin\.app/texts/([0-9]{1,10})(?![0-9])"
+)
 # 引文块「之后」多远内出现 live 链接仍算本块携带(且不跨过下一引文块)。link 须在引文之后。
 _LINK_WINDOW = 120
 
 
-def load_declared_ids(master: str) -> set[str]:
-    """读 prebuilt/<master>/meta.json,返回声明的离线 cbeta_id 集合。"""
+_FRONTMATTER_KIND = re.compile(r"^kind:\s*[\"']?([A-Za-z-]+)", re.M)
+
+
+def _skill_kind(master_dir: str) -> str | None:
+    """技能类型:先看 meta.json 的 `kind`,没有再看 SKILL.md frontmatter。
+
+    两处都声明 `kind`,而三个元技能(compare-masters / master-curriculum /
+    master-help)只有 SKILL.md 没有 meta.json —— 只读 meta.json 就会把它们
+    当成"找不到",于是 load_declared_ids 抛异常、审计整个跳过。
+    """
+    meta_path = os.path.join(master_dir, "meta.json")
+    if os.path.exists(meta_path):
+        with open(meta_path, encoding="utf-8") as f:
+            kind = json.load(f).get("kind")
+        if kind:
+            return kind
+    skill_path = os.path.join(master_dir, "SKILL.md")
+    if os.path.exists(skill_path):
+        with open(skill_path, encoding="utf-8") as f:
+            head = f.read(2048)
+        m = _FRONTMATTER_KIND.search(head)
+        if m:
+            return m.group(1)
+    return None
+
+
+def _persona_slugs(base: str | None = None) -> list[str]:
+    """`prebuilt/` 下所有**非**元技能的目录名。"""
+    root = base if base is not None else PREBUILT_ROOT
+    out = []
+    for name in sorted(os.listdir(root)):
+        path = os.path.join(root, name)
+        if not os.path.isdir(path):
+            continue
+        if _skill_kind(path) == "meta-skill":
+            continue
+        if os.path.exists(os.path.join(path, "meta.json")):
+            out.append(name)
+    return out
+
+
+def _union_over_personas(loader, base: str | None = None):
+    """把 loader 施加到每一位 persona 上并合并结果 —— 元技能的声明集。
+
+    compare-masters / master-debate / master-curriculum 引的是**别人**的经论,
+    自己不声明来源。以前这意味着 `load_declared_ids` 要么抛 FileNotFoundError
+    (没有 meta.json),要么返回空集(debate 的 meta.json 只有协议没有 sources),
+    两条路都让调用方的 `if declared_ids:` 短路,审计整个不跑。2026-09-12 那轮
+    因此有 53 条引文(compare-masters 47 + curriculum 6)被发出去、一条未查。
+
+    **这个并集严格弱于逐 persona 核验。** 审计时手上只有答案正文,不知道当次
+    选了哪两位祖师,所以「把慧能的经号安到宗喀巴名下」这类张冠李戴它查不出来。
+    它能查出的是真正的幻觉引文 —— 全库都没声明过的经号。比不查强,比逐 persona
+    弱,不要把它当成后者。
+    """
+    merged = None
+    for slug in _persona_slugs(base):
+        part = loader(slug, base)
+        if merged is None:
+            merged = part.copy()
+        elif isinstance(merged, dict):
+            for k, v in part.items():
+                merged.setdefault(k, v)
+        else:
+            merged |= part
+    return merged if merged is not None else type(loader("", base))()
+
+
+def load_declared_ids(master: str, base: str | None = None) -> set[str]:
+    """读 <base or prebuilt>/<master>/meta.json,返回声明的离线 cbeta_id 集合。
+
+    `base` 默认 None,交给 resolve_master_dir 用它自己的真实 prebuilt/ 常量 ——
+    传别的目录是为了让调用方(如 validate-citation-references.py 的
+    find_undeclared)既能用真实仓库,也能在测试里指向 tmp_path,不必为了可测试性
+    自己重新实现一遍 meta.json 解析。
+    """
     if not _SAFE_MASTER.match(master):
         raise ValueError(f"无效的 master ID：{master!r}（仅允许字母、数字、'-'、'_'）")
-    master_dir = resolve_master_dir(master)  # 兼容 "huineng" / "master-huineng"
+    kwargs = {"base": base} if base is not None else {}
+    master_dir = resolve_master_dir(master, **kwargs)  # 兼容 "huineng" / "master-huineng"
     if master_dir is None:
         raise FileNotFoundError(f"找不到 master：{master!r}（试过 {master!r} 和 master-{master}）")
+    if _skill_kind(master_dir) == "meta-skill":
+        return _union_over_personas(load_declared_ids, base)
     with open(os.path.join(master_dir, "meta.json"), encoding="utf-8") as f:
         meta = json.load(f)
     ids: set[str] = set()
@@ -67,53 +479,328 @@ def load_declared_ids(master: str) -> set[str]:
     return ids
 
 
-def audit_answer(declared_ids: set[str], answer: str) -> dict:
-    """把答案里每条引文分类为 offline / live / fabricated。
+def load_member_aliases(master: str, base: str | None = None) -> dict[str, str]:
+    """读 <base or prebuilt>/<master>/meta.json,把每条编集开示来源的 note 解析成
+    「成员篇目 → 合集 id」别名表(合并全部来源)。找不到 note 或没有
+    `/` 分隔的来源不贡献别名 —— 参见 extract_member_aliases。`base` 见
+    load_declared_ids。"""
+    if not _SAFE_MASTER.match(master):
+        raise ValueError(f"无效的 master ID：{master!r}（仅允许字母、数字、'-'、'_'）")
+    kwargs = {"base": base} if base is not None else {}
+    master_dir = resolve_master_dir(master, **kwargs)
+    if master_dir is None:
+        raise FileNotFoundError(f"找不到 master：{master!r}（试过 {master!r} 和 master-{master}）")
+    if _skill_kind(master_dir) == "meta-skill":
+        return _union_over_personas(load_member_aliases, base)
+    with open(os.path.join(master_dir, "meta.json"), encoding="utf-8") as f:
+        meta = json.load(f)
+    aliases: dict[str, str] = {}
+    for src in meta.get("sources", []):
+        if src.get("type") != "compiled_teaching":
+            continue
+        sid, note = src.get("id"), src.get("note")
+        if sid and note:
+            aliases.update(extract_member_aliases(sid, note))
+    return aliases
+
+
+def load_title_aliases(master: str, base: str | None = None) -> dict[str, str]:
+    """「声明题名 → 声明 id」别名表,只对**非经号**来源生成。
+
+    宗喀巴声明 `Lam-rim-chen-mo`,答案写 `【《菩提道次第广论》§毗钵舍那章】`;
+    声明 `Lam-gtso-rnam-gsum`,答案写 `【《三主要道》(Lam gtso rnam gsum)】`
+    —— 空格而非连字符。两者都是**正确引用了已声明来源**,解析器一条都认不出,
+    全进 `unparsed`。2026-09-12 那轮里这是宗喀巴 53 条引文中的 50 条。
+
+    别名就摆在 meta.json 里:`"title": "菩提道次第广论 (Lam rim chen mo)"`
+    同时给出中文题名与空格式 Wylie。这里只是把已经声明的东西读出来。
+
+    **经号家族一律不生成别名。** CBETA 契约要求的标识符是经号本身,若
+    `【《六祖坛经》】` 能靠题名过关,那条契约就被这个"修复"悄悄削掉了。判断
+    依据是 id 的形状(`_CBETA_ID` 整体匹配),不是 `type` 字段:type 是自由
+    文本,形状是审计器真正认的东西。
+
+    这道守卫跳过了 46 条经号来源,而 2026-09-12 那轮**去掉它覆盖率一字不变**
+    —— 那批答案里没有一条是只写书名不写经号的。所以它同样是前瞻护栏,不是
+    已测修复,由 test_a_cbeta_persona_may_not_cite_by_title_alone 钉住。
+    """
+    if not _SAFE_MASTER.match(master):
+        raise ValueError(f"无效的 master ID：{master!r}（仅允许字母、数字、'-'、'_'）")
+    kwargs = {"base": base} if base is not None else {}
+    master_dir = resolve_master_dir(master, **kwargs)
+    if master_dir is None:
+        raise FileNotFoundError(f"找不到 master：{master!r}（试过 {master!r} 和 master-{master}）")
+    if _skill_kind(master_dir) == "meta-skill":
+        return _union_over_personas(load_title_aliases, base)
+    with open(os.path.join(master_dir, "meta.json"), encoding="utf-8") as f:
+        meta = json.load(f)
+    aliases: dict[str, str] = {}
+    for src in meta.get("sources", []):
+        sid, title = src.get("id"), src.get("title")
+        if not sid or not title or _CBETA_ID.fullmatch(sid):
+            continue
+        inner = re.findall(r"[（(]([^）)]+)[）)]", title)
+        head = re.sub(r"\s*[（(].*$", "", title).strip()
+        # 一条 title 可能把多个题名粘在一起
+        # (`"《吉祥悦意》《长部注释》 (Sumaṅgalavilāsinī)"`),整串永远匹配不上
+        # 正文里的单个题名,所以把每个《…》也各登记一次。
+        parts = [head, *inner]
+        parts += [t for chunk in parts for t in _WORK_TITLE.findall(chunk)]
+        for alias in parts:
+            alias = alias.strip()
+            if len(alias) >= _MIN_TITLE_ALIAS:
+                aliases.setdefault(alias, sid)
+    return aliases
+
+
+# 题名别名的最短长度。2026-09-12 那轮实测(每次清 __pycache__ 后重跑):
+#   下限 4 → 523/603    下限 3 → 526    下限 2 → 530    下限 1 → 530
+# 差额是《入中论》(3 字,Toh:3861)与《父法》《子法》(2 字,BDRC:Pha-chos-Bu-chos)
+# —— 都是声明里原样写着的书名,挡掉它们纯属损失。取 2 而不取 1,是因为单字
+# 别名(若将来有人声明一条 title 为「论」「经」的来源)会在散文里到处撞上;
+# 现有数据里没有单字题名,所以这一格差别为 0 —— 它是前瞻护栏,由
+# test_a_one_character_title_never_becomes_an_alias 钉住,不是一处已测修复。
+_MIN_TITLE_ALIAS = 2
+
+
+@functools.lru_cache(maxsize=8)
+def _declared_literal_matcher(declared: frozenset[str]) -> re.Pattern[str] | None:
+    """A matcher for declared ids written exactly as declared.
 
-    返回 {'offline': [...], 'live': [(cbeta_id, text_id), ...], 'fabricated': [...]}。
+    `_FAMILY_ID` needs a family tag or a numeric work id, and four of this
+    repo's own declared ids have neither: `master-tsongkhapa` declares bare
+    Wylie titles (`Lam-rim-chen-mo`, `sNgags-rim-chen-mo`,
+    `Drang-nges-legs-bshad-snying-po`, `Lam-gtso-rnam-gsum`), and two more are
+    `BDRC:` followed by Wylie rather than a W-number (`BDRC:gsung-bum`,
+    `BDRC:Pha-chos-Bu-chos`). No regex reads a hyphenated Tibetan title apart
+    from prose, so the parser dropped all six into `unparsed`.
+
+    Re-auditing the 2026-09-12 sweep, that was every remaining failure in
+    `master-curriculum` — 26 of 32 parsed, and the 6 that did not were all
+    declared. `unparsed` reads as neutral, so a correct citation of a declared
+    source was scored the same as an uninterpretable one.
+
+    This runs only where nothing at all was extractable, and matches only a
+    string already in the declared set, so it can move a citation from
+    `unparsed` to `offline` and never from `fabricated`. The shortest declared
+    id is 8 characters, so there is nothing here short enough to collide with
+    running prose.
+    """
+    if not declared:
+        return None
+    alts = "|".join(re.escape(i) for i in sorted(declared, key=len, reverse=True))
+    return re.compile(rf"(?<![0-9A-Za-z-]){alts}(?![0-9A-Za-z-])")
+
+
+def audit_answer(
+    declared_ids: set[str],
+    answer: str,
+    member_aliases: dict[str, str] | None = None,
+    title_aliases: dict[str, str] | None = None,
+) -> dict:
+    """把答案里每条引文分类为 offline / live / fabricated / unparsed。
+
+    返回 {'offline': [...], 'live': [(cbeta_id, text_id), ...],
+          'fabricated': [...], 'unparsed': [...], 'noncitation': [...]}。
+
+    ``noncitation`` 是**根本不是引文**的【…】块 —— 人格拿它当小标题
+    (`【辨名义】`)或复述问题。它们不计入覆盖率的分母;单列而非丢弃,是为了
+    「这里有 10 个块我判定它不是引文」这句话在报告里说得出口。
+
+    ``unparsed`` 是抽不出任何可核对 id 的引文块。它们以前被整块 silently skip,
+    于是「审计了但一条都没看懂」和「已审计、干净」在报告里长得一模一样 —— 宗喀巴
+    声明的多是裸 Wylie 标题、觉音大量用语料库级的 `【SC: AN 3.88】`,两者的
+    ``fabricated`` 都是空。记下来才能算出「审计器实际看得懂的引用占多少」。
     """
     offline: list[str] = []
     live: list[tuple[str, str]] = []
     fabricated: list[str] = []
+    unparsed: list[str] = []
+    noncitation: list[str] = []
 
     blocks = list(_CITATION_BLOCK.finditer(answer))
     for idx, m in enumerate(blocks):
-        ids = _CBETA_ID.findall(m.group(1))
-        if not ids:
-            continue
-        # 链接归属:本引文块结束 → 下一引文块开始(且不超过 _LINK_WINDOW)。这样一个 link
+        # 归属区:本引文块结束 → 下一引文块开始(且不超过 _LINK_WINDOW)。这样一个 link
         # 只能洗白紧挨它之前的那一个引文块,不会连带洗白更前面的伪造引文(B1 的关键)。
         next_start = blocks[idx + 1].start() if idx + 1 < len(blocks) else len(answer)
         region_end = min(next_start, m.end() + _LINK_WINDOW)
-        link = _FOJIN_TEXT_LINK.search(answer, m.end(), region_end)
+        # 非 CBETA 祖师的主格式把家族标签放在块**后**的括号里
+        # (`【《Visuddhimagga》§I】（PTS Vism）`),所以 id 与 link 共用这同一个归属区。
+        ids = extract_citation_ids(m.group(1)) + extract_citation_ids(
+            answer[m.end():region_end]
+        )
+        if not ids:
+            compiled = _compiled_teaching_id(m.group(1), declared_ids, member_aliases)
+            if compiled:
+                ids = [compiled]
+        if not ids:
+            # Last resort: the block may name a declared id the parser has no
+            # pattern for. Exact membership only — see the matcher's docstring.
+            matcher = _declared_literal_matcher(frozenset(declared_ids))
+            if matcher is not None:
+                ids = matcher.findall(m.group(1)) + matcher.findall(
+                    answer[m.end():region_end]
+                )
+            if not ids and title_aliases:
+                # 声明题名 → 声明 id。同样只在什么都抽不出来时才走,而且映射的
+                # 目标必然在 declared_ids 里,所以只能把 unparsed 挪成 offline。
+                block = m.group(1)
+                hit = [
+                    (alias, sid)
+                    for alias, sid in title_aliases.items()
+                    if alias in block
+                ]
+                if hit:
+                    # 最长题名优先:「密宗道次第广论」包含「宗道次第广论」这类
+                    # 前缀关系下,短的那个会把引用记到错的声明上。
+                    ids = [max(hit, key=lambda pair: len(pair[0]))[1]]
+        if not ids:
+            block = m.group(1).strip()
+            if block:
+                if _LOOKS_LIKE_CITATION.search(block):
+                    unparsed.append(block)
+                else:
+                    noncitation.append(block)
+            continue
+        links = _FOJIN_TEXT_LINK.findall(answer, m.end(), region_end)
+        # 先分类,再决定 link 能洗白谁 —— 一个链接只能为**一条**引文作保。
+        # 原来 `for cid in ids` 复用同一个 `link`,于是
+        # 【《伪甲》，T99n9991；《伪乙》，T99n9992；《伪丙》，T99n9993】+ 一个真链接
+        # 会让三条伪造经号一起过关:那个链接指向的显然只是其中一部经(如果有的话),
+        # 其余两条连"它到底指谁"都无从谈起。歧义时判伪造 —— 放行凭据必须失败即安全。
+        unresolved: list[str] = []
         for cid in ids:
-            if cid in declared_ids:
-                offline.append(cid)
-            elif link:
-                live.append((cid, link.group(1)))
+            resolved = cid if cid in declared_ids else _resolve_short_form(
+                cid, declared_ids
+            )
+            if resolved:
+                offline.append(resolved)
             else:
-                fabricated.append(cid)
-    return {"offline": offline, "live": live, "fabricated": fabricated}
+                unresolved.append(cid)
+        if len(unresolved) == 1 and links:
+            live.append((unresolved[0], links[0]))
+        else:
+            fabricated.extend(unresolved)
+    return {
+        "offline": offline,
+        "live": live,
+        "fabricated": fabricated,
+        "unparsed": unparsed,
+        "noncitation": noncitation,
+    }
+
 
+# 每个 id 的核验结果是**三态**,不是布尔:
+#   True  → 200 + 有 JSON 正文,确实解析得到
+#   False → 404,平台明确说没有这个 id —— 唯一该硬失败的信号
+#   None  → 5xx / 连接失败 / 返回的不是 JSON,不知道
+# 旧版把这三种压成一个布尔,再让任何一次异常 `return {"_unreachable": True}`,
+# 于是一次网络抖动就把**已经验成功的全部结果丢掉**,整轮降级成一条警告。
+# "查不出来" 和 "查过了,没问题" 从此长得一样 —— 正是本仓一直在修的那个形状。
+VERIFY_TIMEOUT = 15
+VERIFY_WORKERS = 8
 
-def verify_online(text_ids: list[str], base_url: str = "https://fojin.app", timeout: int = 15) -> dict:
+
+def _check_one_text_id(session_factory, base_url: str, tid: str, timeout: int):
+    """核验单个 text_id,返回 (三态结果, 说明)。异常一律收敛成 None,不外抛。"""
+    try:
+        resp = session_factory().get(f"{base_url}/api/texts/{tid}", timeout=timeout)
+    except Exception as e:  # noqa: BLE001 — 传输层失败是"不知道",不是"不存在"
+        return None, f"{type(e).__name__}: {e}"
+    if resp.status_code == 404:
+        return False, "404"
+    if resp.status_code != 200:
+        return None, f"HTTP {resp.status_code}"
+    try:
+        payload = resp.json()
+    except ValueError:
+        # 200 却不是 JSON:通常是网关错误页,不能据此断定 id 不存在。
+        return None, "200 但正文不是 JSON"
+    if payload:
+        return True, ""
+    # 200 + 空正文归 None,不归 False —— 上面刚写下「404 是唯一该硬失败的信号」,
+    # 这里返回 False 就是在自己的契约上开口子。空信封可能来自 FoJin 换了外层结构、
+    # 一次读半截、或 CDN 改写了 body;拿它判伪造,会在平台抖动时把**正确**引用
+    # 批量打成伪造 —— 同一段注释说过那比漏检更糟。真的不存在,平台会回 404。
+    return None, "200 但正文为空"
+
+
+class OnlineVerification(NamedTuple):
+    """一次 --online 核验的完整结果。
+
+    最初的版本把这些塞进**同一个字典**:`{tid: 三态, "_reasons": {...}}`,
+    再让调用方 pop 掉那个下划线键。也就是说字典里有一个键不是 text_id,而
+    「是不是 text_id」只能靠命名约定分辨 —— 这正是本仓一直在修的那种形状:
+    两种语义长得一样,靠调用方记得区分。忘了 pop 也不会炸,只会把 `_reasons`
+    当成一个永远核验通过的引文,静静地混进统计里。
+    """
+
+    #: tid -> True(解析得到) / False(404,确定不存在) / None(查不出来)
+    verdicts: dict
+    #: tid -> 说明,只对 False / None 有值
+    reasons: dict
+    #: 整体不可达时的原因;可达时为 None
+    unreachable: str | None = None
+
+    @property
+    def fabricated(self) -> list:
+        """平台明确回 404 的 —— 唯一该判失败的。"""
+        return sorted(t for t, ok in self.verdicts.items() if ok is False)
+
+    @property
+    def unknown(self) -> list:
+        """传输层没给出答案的 —— 报出来,但不算伪造。"""
+        return sorted(t for t, ok in self.verdicts.items() if ok is None)
+
+
+def verify_online(
+    text_ids: list[str],
+    base_url: str = "https://fojin.app",
+    timeout: int = VERIFY_TIMEOUT,
+    workers: int = VERIFY_WORKERS,
+) -> OnlineVerification:
     """best-effort:GET /api/texts/{id} 看 live 引文的 text_id 是否真解析。
 
-    网络不可达时返回 {'_unreachable': True},调用方按告警处理(不硬失败)。
+    requests 缺失或**每一个** id 都查不出结果时,`unreachable` 带上原因;
+    部分失败不再吃掉部分成功。
     """
     try:
         import requests
     except ImportError:
-        return {"_unreachable": True, "_reason": "requests 未安装"}
+        return OnlineVerification({}, {}, "requests 未安装")
+
+    unique = sorted(set(text_ids))
+    if not unique:
+        return OnlineVerification({}, {})
+
+    # requests.Session 的线程安全性没有保证,所以每个线程持有自己的那个。
+    local = threading.local()
+
+    def session_factory():
+        if not hasattr(local, "session"):
+            local.session = requests.Session()
+        return local.session
+
     out: dict = {}
-    sess = requests.Session()
-    for tid in text_ids:
-        try:
-            r = sess.get(f"{base_url}/api/texts/{tid}", timeout=timeout)
-            out[tid] = r.status_code == 200 and bool(r.json())
-        except Exception as e:  # noqa: BLE001 — 网络层一律降级为不可达
-            return {"_unreachable": True, "_reason": str(e)}
-    return out
+    reasons: dict[str, str] = {}
+    with ThreadPoolExecutor(max_workers=max(1, min(workers, len(unique)))) as pool:
+        futures = {
+            pool.submit(_check_one_text_id, session_factory, base_url, tid, timeout): tid
+            for tid in unique
+        }
+        for future in as_completed(futures):
+            tid = futures[future]
+            out[tid], reason = future.result()
+            if reason:
+                reasons[tid] = reason
+
+    if all(v is None for v in out.values()):
+        first = next(iter(reasons.values()), "未知原因")
+        return OnlineVerification(
+            out, reasons, f"{len(out)} 个 id 全部无法核验({first})"
+        )
+
+    return OnlineVerification(out, reasons)
 
 
 def main() -> int:
@@ -125,12 +812,14 @@ def main() -> int:
 
     try:
         declared = load_declared_ids(args.master)
+        member_aliases = load_member_aliases(args.master)
+        title_aliases = load_title_aliases(args.master)
     except (ValueError, FileNotFoundError) as e:
         print(f"✗ {e}", file=sys.stderr)
         return 2
 
     answer = open(args.answer_file, encoding="utf-8").read() if args.answer_file else sys.stdin.read()
-    report = audit_answer(declared, answer)
+    report = audit_answer(declared, answer, member_aliases, title_aliases)
 
     print(f"offline 引文: {len(report['offline'])}  live 引文: {len(report['live'])}  "
           f"fabricated: {len(report['fabricated'])}")
@@ -142,13 +831,24 @@ def main() -> int:
 
     if args.online and report["live"]:
         res = verify_online([tid for _, tid in report["live"]])
-        if res.get("_unreachable"):
-            print(f"⚠ --online 跳过:FoJin 不可达({res.get('_reason')})", file=sys.stderr)
+        if res.unreachable:
+            print(f"⚠ --online 跳过:FoJin 不可达({res.unreachable})", file=sys.stderr)
         else:
-            bad = [tid for tid, ok in res.items() if not ok]
-            if bad:
-                print(f"✗ live 引文 text_id 无法解析: {bad}", file=sys.stderr)
+            # 只有平台明确回 404 才算伪造 —— 5xx / 超时 / 网关错误页说明的是
+            # 网络状况,不是引文真伪,拿它判 fabricated 会在 FoJin 抖动时把正确
+            # 引用打成伪造,那比漏检更糟。
+            if res.fabricated:
+                print(f"✗ live 引文 text_id 无法解析: {res.fabricated}", file=sys.stderr)
                 exit_code = 1
+            if res.unknown:
+                # 报出来而不是静默算过 —— 「没查成」必须与「查过没问题」可区分。
+                detail = ", ".join(
+                    f"{t}({res.reasons.get(t, '?')})" for t in res.unknown
+                )
+                print(
+                    f"⚠ {len(res.unknown)} 条 live 引文未能核验: {detail}",
+                    file=sys.stderr,
+                )
 
     if exit_code == 0:
         print("✓ 全部引文可核验")