master-skill 0.12.1 → 0.12.3

package/tools/verify_sources.py

@@ -365,13 +365,13 @@ def classify_cbeta_volumes(
     return mismatched, sorted(unknown)
 
 
-def fetch_cbeta_volumes(full_ids: list[str]) -> dict[str, str | None]:
-    """向 CBETA 问每个经号所属的卷(或卷区间);问不到的记 None(未知,不是不符)。"""
+def fetch_cbeta_works(full_ids: list[str]) -> dict[str, dict | None]:
+    """向 CBETA 问每个经号的卷(或卷区间)与题名;问不到的记 None(未知,不是不符)。"""
     import urllib.error
     import urllib.parse
     import urllib.request
 
-    out: dict[str, str | None] = {}
+    out: dict[str, dict | None] = {}
     for full_id in full_ids:
         short = full_to_short_cbeta(full_id)
         if not short:
@@ -382,12 +382,424 @@ def fetch_cbeta_volumes(full_ids: list[str]) -> dict[str, str | None]:
             with urllib.request.urlopen(url, timeout=CBETA_TIMEOUT) as resp:
                 payload = json.loads(resp.read().decode("utf-8"))
             results = payload.get("results") or []
-            out[full_id] = results[0].get("vol") if results else None
+            out[full_id] = (
+                {"vol": results[0].get("vol"), "title": results[0].get("title")}
+                if results
+                else None
+            )
         except (urllib.error.URLError, OSError, ValueError, KeyError, IndexError):
             out[full_id] = None
     return out
 
 
+def _title_syllables(title: str | None) -> list[set[str]]:
+    """题名 → 逐字读音集合。去掉括注，只留汉字；多音字保留全部读音。"""
+    from pypinyin import Style, pinyin
+
+    bare = re.sub(r"[（(][^）)]*[）)]", "", title or "")
+    bare = "".join(ch for ch in bare if "\u3400" <= ch <= "\u9fff" or "\uf900" <= ch <= "\ufaff")
+    return [set(readings) for readings in pinyin(bare, style=Style.NORMAL, heteronym=True)]
+
+
+def titles_agree(declared: str, cbeta: str | None) -> bool | None:
+    """声明题名按读音是否为 CBETA 题名的子序列。
+
+    经号在 FoJin 查得到、卷号也对，仍可能是另一部书：master-yinguang 把《印光
+    法师文钞》声明成 X62n1182–1184，CBETA 那三号是《徹悟禪師語錄》《淨業知津》
+    《念佛百問》，卷号 X62 分毫不差，这道周检一直是绿的。
+
+    声明用简体、常用简称（《大佛顶首楞严经》），CBETA 用繁体全称，逐字比两边都
+    会误报。按读音比，繁简同音即对得上，简称是全称的子序列也对得上；另一部书一
+    个音都对不上。用读音而不用繁简转换表，是因为仓库已依赖 pypinyin。已知边界：
+    过短的题名可能碰巧是别书题名的子序列。
+
+    返回 None 表示比不了（任一侧没有汉字），既不是对也不是错。
+    """
+    mine, theirs = _title_syllables(declared), _title_syllables(cbeta)
+    if not mine or not theirs:
+        return None
+    position = 0
+    for readings in theirs:
+        if position < len(mine) and mine[position] & readings:
+            position += 1
+    return position == len(mine)
+
+
+def collect_declared_titles() -> dict[str, list[str]]:
+    """{完整经号: [各 meta.json 为它声明的题名]} —— 同一部经可能被几位祖师声明。"""
+    titles: dict[str, list[str]] = {}
+    for teacher in sorted(os.listdir(PREBUILT_DIR)):
+        meta_path = os.path.join(PREBUILT_DIR, teacher, "meta.json")
+        if not os.path.isfile(meta_path):
+            continue
+        with open(meta_path, encoding="utf-8") as f:
+            meta = json.load(f)
+        for src in meta.get("sources", []):
+            if src.get("type") == "cbeta" and src.get("id") and src.get("title"):
+                known = titles.setdefault(src["id"], [])
+                if src["title"] not in known:
+                    known.append(src["title"])
+    return titles
+
+
+def classify_cbeta_titles(
+    declared: dict[str, list[str]], cbeta_titles: dict[str, str | None]
+) -> tuple[dict[str, tuple[list[str], str | None]], list[str]]:
+    """把声明题名分成「与 CBETA 对不上」与「比不了」两类，三态同卷号检查。
+
+    一个 id 若有一条题名对不上，就算不符 —— 另一条比不了的题名不能把它盖住。
+    """
+    mismatched: dict[str, tuple[list[str], str | None]] = {}
+    unknown: list[str] = []
+    for full_id, mine in declared.items():
+        theirs = cbeta_titles.get(full_id)
+        verdicts = {title: titles_agree(title, theirs) for title in mine}
+        wrong = [title for title, verdict in verdicts.items() if verdict is False]
+        if wrong:
+            mismatched[full_id] = (wrong, theirs)
+        elif not mine or any(verdict is None for verdict in verdicts.values()):
+            unknown.append(full_id)
+    return mismatched, sorted(unknown)
+
+
+def collect_frontmatter_fojin_ids() -> list[tuple[str, str, str, str]]:
+    """(祖师目录, 题名, cbeta_id, fojin_text_id)，取自各 SKILL.md frontmatter 的 sources。"""
+    import yaml
+
+    rows: list[tuple[str, str, str, str]] = []
+    for teacher in sorted(os.listdir(PREBUILT_DIR)):
+        path = os.path.join(PREBUILT_DIR, teacher, "SKILL.md")
+        if not os.path.isfile(path):
+            continue
+        with open(path, encoding="utf-8") as f:
+            parts = f.read().split("---", 2)
+        if len(parts) < 3 or parts[0].strip():
+            continue
+        front = yaml.safe_load(parts[1]) or {}
+        for src in front.get("sources") or []:
+            if isinstance(src, dict) and src.get("cbeta_id") and src.get("fojin_text_id") is not None:
+                rows.append(
+                    (teacher, str(src.get("title", "")), str(src["cbeta_id"]), str(src["fojin_text_id"]))
+                )
+    return rows
+
+
+def classify_frontmatter_fojin_ids(
+    rows: list[tuple[str, str, str, str]], short_to_text: dict[str, object]
+) -> tuple[list[tuple[str, str, str, str, str]], list[str]]:
+    """frontmatter 的 fojin_text_id 与 FoJin 对该经号的解析结果不符的条目。
+
+    这个 id 不进审计，却是人设给读者拼链接用的：master-zhiyi 把《法華玄義》
+    （T1716）写成 52，那是《法華文句》的 text id。frontmatter 里完整号与短号
+    （`T1716`）两种写法都有，一律折成短号再比。查不到的记为未知，不算错。
+    """
+    mismatched: list[tuple[str, str, str, str, str]] = []
+    unknown: list[str] = []
+    for teacher, title, cbeta_id, written in rows:
+        short = full_to_short_cbeta(cbeta_id) if FULL_CBETA_RE.match(cbeta_id) else cbeta_id
+        actual = short_to_text.get(short)
+        if actual is None:
+            unknown.append(f"{teacher}:{cbeta_id}")
+        elif str(actual) != written:
+            mismatched.append((teacher, cbeta_id, title, written, str(actual)))
+    return mismatched, sorted(unknown)
+
+
+_DOC_CITATION = re.compile(r"【([^】]*)】")
+_DOC_FOJIN_LINK = re.compile(r"https://fojin\.app/texts/([0-9]+)")
+_DOC_CBETA_ID = re.compile(r"(?<![0-9A-Za-z])([TXJ])(?:[0-9]{1,3}n)?(B?[0-9]{3,5})[a-z]?(?![0-9A-Za-z])")
+_DOC_TEMPLATE = re.compile(r"\{|卷N|[A-Za-z][xX]{3,}")
+
+
+def _cbeta_work(cid: str) -> tuple[str, str] | None:
+    """`T33n1716` / `T1716` → ("T", "1716")，经号去零；不是 CBETA 号 → None。"""
+    m = _DOC_CBETA_ID.fullmatch(cid.strip())
+    if not m:
+        return None
+    number = m.group(2)
+    return m.group(1), ("B" + str(int(number[1:]))) if number.startswith("B") else str(int(number))
+
+
+def collect_doc_citation_links() -> list[tuple[str, str, list[str], str | None]]:
+    """(位置, text_id, 引文里的 CBETA 号, 引文书名)：人设文档里每个后面同一行跟着
+    FoJin 数字链接的引文块。
+
+    只认同一行、且在下一个引文块之前的链接。第一次核查用 120 字符窗口，把
+    master-yinguang 一条没有链接的引文和两行之后表格里《佛說阿彌陀經》的链接
+    配成了一对。格式模板（`{title}`、`卷N`、`Wxxxxx`）不是引文，跳过。
+    """
+    pairs: list[tuple[str, str, list[str], str | None]] = []
+    base = Path(PREBUILT_DIR)
+    files = sorted(base.glob("*/SKILL.md")) + sorted(base.glob("*/references/*.md")) + sorted(base.glob("*/sources/*.md"))
+    for path in files:
+        where = path.relative_to(base).as_posix()
+        for number, line in enumerate(path.read_text(encoding="utf-8").splitlines(), 1):
+            for block in _DOC_CITATION.finditer(line):
+                if _DOC_TEMPLATE.search(block.group(1)):
+                    continue
+                rest = line[block.end():]
+                following = _DOC_CITATION.search(rest)
+                link = _DOC_FOJIN_LINK.search(rest[: following.start()] if following else rest)
+                if not link:
+                    continue
+                ids = [m.group(0) for m in _DOC_CBETA_ID.finditer(block.group(1))]
+                title = re.search(r"《([^》]+)》", block.group(1))
+                pairs.append((f"{where}:{number}", link.group(1), ids, title.group(1) if title else None))
+    return pairs
+
+
+def classify_doc_citation_links(
+    pairs: list[tuple[str, str, list[str], str | None]], records: dict[str, dict | None]
+) -> tuple[list[tuple[str, str, str]], list[str]]:
+    """哪些文档链接打开的不是引文所说的那部书；FoJin 没给出记录的记为未知。
+
+    比两样：链接文本的经号是否是引文里的某个号，书名（截掉「·品名」）是否与
+    `title_zh` 读音对得上（`titles_agree`）。
+    """
+    mismatched: list[tuple[str, str, str]] = []
+    unknown: list[str] = []
+    for where, tid, ids, title in pairs:
+        record = records.get(tid)
+        if not record:
+            unknown.append(where)
+            continue
+        problems = []
+        linked = record.get("cbeta_id")
+        wanted = {_cbeta_work(c) for c in ids} - {None}
+        if wanted and linked and _cbeta_work(str(linked)) not in wanted:
+            problems.append(f"texts/{tid} 是 {linked}，不是 {'/'.join(ids)}")
+        linked_title = record.get("title_zh")
+        if title and linked_title:
+            book = re.split(r"[·・‧〈<]", title, maxsplit=1)[0].strip()
+            if book and titles_agree(book, str(linked_title)) is False:
+                problems.append(f"《{title}》对不上 texts/{tid} 的《{linked_title}》")
+        if problems:
+            mismatched.append((where, tid, "；".join(problems)))
+    return mismatched, unknown
+
+
+# Step 3f：摘录里的「原典」引文是不是所引那一卷的原文。
+#
+# 前面几步核经号、卷号、题名和链接，都看不见引文本身。2026-09-15 逐句比对
+# `sources/*-excerpts.md` 与 lore_triggers：63 段里 19 段有分句不在所引的那一卷，
+# 其中「宁起有见如须弥山」挂在《大智度论》名下、四法界挂在《五教章》名下、
+# 《摩诃止观》序文写错了讲经的寺名，而人设把这些当原文引给用户。
+
+CBETA_JUANS_URL = "https://cbdata.dila.edu.tw/stable/juans"
+# 引文没标卷次时，卷数不超过此数的书整部读；更长的记为未知，请补卷次。
+EXCERPT_WHOLE_WORK_MAX_JUANS = 30
+# 短于此数的分句（「第七」「华严经」）哪里都可能出现，不拿来判对错。
+EXCERPT_MIN_CLAUSE = 4
+
+_HAN = re.compile(r"[㐀-鿿豈-﫿]")
+_HAN_RUN = re.compile(r"[㐀-鿿豈-﫿]+")
+_CN_DIGITS = {"〇": 0, "零": 0, "一": 1, "二": 2, "三": 3, "四": 4, "五": 5, "六": 6, "七": 7, "八": 8, "九": 9}
+_READINGS: dict[str, frozenset[str]] = {}
+
+
+def _chinese_number(text: str) -> int | None:
+    """「五」「二十一」「一百零八」「一一二」「31」→ 整数；认不出 → None。"""
+    if text.isdigit():
+        return int(text)
+    if text and all(ch in _CN_DIGITS for ch in text):
+        return int("".join(str(_CN_DIGITS[ch]) for ch in text))
+    total, digit = 0, 0
+    for ch in text:
+        if ch in _CN_DIGITS:
+            digit = _CN_DIGITS[ch]
+        elif ch in "十百":
+            total += (digit or 1) * (10 if ch == "十" else 100)
+            digit = 0
+        else:
+            return None
+    return total + digit or None
+
+
+def cited_juan(detail: str) -> int | None:
+    """引文里「卷五上」「卷31」「卷5·易行品」的卷次；没写或是区间（卷五至卷十、卷3-4）→ None。"""
+    match = re.search(r"卷([〇零一二三四五六七八九十百0-9]+)", detail)
+    if not match or re.match(r"[上中下]?\s*(?:至|[-–~～、])", detail[match.end():]):
+        return None
+    return _chinese_number(match.group(1))
+
+
+def _cbeta_api_work(cid: str) -> str | None:
+    """CBETA API 的 work 参数：`T46n1911` / `T1911` → `T1911`，`J36nB348` → `JB348`。"""
+    parts = _cbeta_work(cid)
+    if not parts:
+        return None
+    canon, number = parts
+    return canon + (number if number.startswith("B") else number.zfill(4))
+
+
+def collect_excerpt_quotes() -> list[tuple[str, str, str, int | None]]:
+    """(位置, 引文, CBETA 号, 卷次)：摘录文件里每个「原典」块，与每条 source_ref
+    是 CBETA 号的 lore_triggers。
+
+    块的形状是一行以「原典」开头的标签、若干 `>` 行、再一行带【《书名》卷N，经号】
+    的「引用格式」。标成「要义」之类的整理文字不是引文，不收。lore 条目只取「——」
+    之前的部分：CONTRIBUTING §6 允许在原文后用「——」接一句浅释。
+    """
+    base = Path(PREBUILT_DIR)
+    quotes: list[tuple[str, str, str, int | None]] = []
+    for path in sorted(base.glob("*/sources/*-excerpts.md")):
+        where = path.relative_to(base).as_posix()
+        label_line, lines = 0, []
+        for number, line in enumerate(path.read_text(encoding="utf-8").splitlines(), 1):
+            if line.startswith("原典"):
+                label_line, lines = number, []
+            elif not label_line:
+                continue
+            elif line.startswith(">"):
+                lines.append(line[1:].strip())
+            elif line.startswith("#"):
+                label_line, lines = 0, []
+            elif "引用格式" in line:
+                citation = _DOC_CITATION.search(line)
+                cid = _DOC_CBETA_ID.search(citation.group(1)) if citation else None
+                if cid and any(lines):
+                    quotes.append((f"{where}:{label_line}", "\n".join(lines), cid.group(0), cited_juan(citation.group(1))))
+                label_line, lines = 0, []
+    for path in sorted(base.glob("*/meta.json")):
+        where = path.relative_to(base).as_posix()
+        entries = json.loads(path.read_text(encoding="utf-8")).get("lore_triggers") or []
+        for index, entry in enumerate(entries):
+            cid, _, anchor = str(entry.get("source_ref") or "").partition("#")
+            if _cbeta_api_work(cid):
+                quote = str(entry.get("content") or "").split("——", 1)[0]
+                quotes.append((f"{where}:lore_triggers[{index}]", quote, cid, cited_juan(anchor)))
+    return quotes
+
+
+def cbeta_juan_plain_text(html: str) -> str:
+    """`/stable/juans` 返回的 HTML → 正文。
+
+    校勘注在末尾的 footnote 区，先切掉：注里的异读（如「含【甲】」）不是这一卷
+    的正文，不能让一段改写的引文靠它对上。
+    """
+    body = re.split(r"<div[^>]*class=['\"][^'\"]*footnote", html, maxsplit=1)[0]
+    return re.sub(r"<[^>]+>", "", body)
+
+
+def fetch_cbeta_juan_count(work: str) -> int | None:
+    """CBETA 记这部书有几卷；问不到记 None（未知，不是不符）。"""
+    import urllib.error
+    import urllib.parse
+    import urllib.request
+
+    url = f"{CBETA_WORKS_URL}?{urllib.parse.urlencode({'work': work})}"
+    try:
+        with urllib.request.urlopen(url, timeout=CBETA_TIMEOUT) as resp:
+            results = json.loads(resp.read().decode("utf-8")).get("results") or []
+        return int(results[0]["juan"]) if results else None
+    except (urllib.error.URLError, OSError, ValueError, KeyError, TypeError, AttributeError):
+        return None
+
+
+def fetch_cbeta_juan_text(work: str, juan: int) -> str | None:
+    """CBETA 某部某卷的正文；问不到记 None（未知，不是不符）。"""
+    import urllib.error
+    import urllib.parse
+    import urllib.request
+
+    url = f"{CBETA_JUANS_URL}?{urllib.parse.urlencode({'work': work, 'juan': juan})}"
+    try:
+        with urllib.request.urlopen(url, timeout=CBETA_TIMEOUT) as resp:
+            results = json.loads(resp.read().decode("utf-8")).get("results") or []
+    except (urllib.error.URLError, OSError, ValueError, AttributeError):
+        return None
+    html = "".join(r for r in results if isinstance(r, str))
+    return cbeta_juan_plain_text(html) if html else None
+
+
+def quote_clauses(quote: str) -> list[str]:
+    """按标点、省略号切成分句；不足 EXCERPT_MIN_CLAUSE 个汉字的不收。"""
+    return [run for run in _HAN_RUN.findall(quote) if len(run) >= EXCERPT_MIN_CLAUSE]
+
+
+def _readings(text: str) -> list[frozenset[str]]:
+    """逐个汉字的全部读音，不看上下文：繁简同音即对得上，与 titles_agree 同理。"""
+    from pypinyin import Style, pinyin
+
+    out: list[frozenset[str]] = []
+    for ch in _HAN.findall(text):
+        if ch not in _READINGS:
+            _READINGS[ch] = frozenset(pinyin(ch, style=Style.NORMAL, heteronym=True)[0])
+        out.append(_READINGS[ch])
+    return out
+
+
+def _reading_index(text: str) -> tuple[list[frozenset[str]], dict[str, list[int]]]:
+    sequence = _readings(text)
+    positions: dict[str, list[int]] = {}
+    for i, readings in enumerate(sequence):
+        for reading in readings:
+            positions.setdefault(reading, []).append(i)
+    return sequence, positions
+
+
+def _clause_found(clause: str, index: tuple[list[frozenset[str]], dict[str, list[int]]]) -> bool:
+    wanted = _readings(clause)
+    sequence, positions = index
+    starts: set[int] = set()
+    for reading in wanted[0]:
+        starts.update(positions.get(reading, ()))
+    return any(
+        i + len(wanted) <= len(sequence) and all(w & sequence[i + k] for k, w in enumerate(wanted))
+        for i in starts
+    )
+
+
+def excerpt_fascicles(juan: int | None, total: int | None) -> list[int] | None:
+    """该读哪几卷。标了卷读那一卷；没标而书不长读整部；否则 None（没法核）。
+
+    标的卷超出全书卷数时返回 []：那是卷次写错了，不是没法核。
+    """
+    if not total:
+        return None
+    if juan is not None:
+        return [juan] if 1 <= juan <= total else []
+    return list(range(1, total + 1)) if total <= EXCERPT_WHOLE_WORK_MAX_JUANS else None
+
+
+def classify_excerpt_quotes(
+    quotes: list[tuple[str, str, str, int | None]],
+    juan_counts: dict[str, int | None],
+    juan_texts: dict[tuple[str, int], str | None],
+) -> tuple[list[tuple[str, str, list[str]]], list[tuple[str, str]]]:
+    """哪些引文有分句不在所引的卷里；没法核的记为未知，不算错。
+
+    逐分句找，不要求整段连续：《金师子章》本文在 T45n1880 里与净源注文逐句交错，
+    照抄本文整段是找不到的。按读音比，繁简同音即对得上。已知边界：同音字替换
+    看不出来（「不妄不愚」对得上「不忘不愚」）；这道检查抓的是改写、增字、换序
+    与张冠李戴，不是错别字。
+    """
+    mismatched: list[tuple[str, str, list[str]]] = []
+    unknown: list[tuple[str, str]] = []
+    indexes: dict[tuple[str, tuple[int, ...]], tuple[list[frozenset[str]], dict[str, list[int]]]] = {}
+    for where, quote, cid, juan in quotes:
+        work = _cbeta_api_work(cid)
+        total = juan_counts.get(work) if work else None
+        fascicles = excerpt_fascicles(juan, total)
+        if fascicles is None:
+            unknown.append((where, f"没标卷次，{work} 共 {total} 卷" if total else f"CBETA 没有返回 {cid} 的卷数"))
+            continue
+        if not fascicles:
+            mismatched.append((where, f"{work} 只有 {total} 卷，引文标的是卷{juan}", []))
+            continue
+        texts = [juan_texts.get((work, j)) for j in fascicles]
+        if any(text is None for text in texts):
+            unknown.append((where, f"CBETA 没有返回 {work} 的卷文"))
+            continue
+        key = (work, tuple(fascicles))
+        if key not in indexes:
+            indexes[key] = _reading_index("\n".join(texts))
+        missing = [clause for clause in quote_clauses(quote) if not _clause_found(clause, indexes[key])]
+        if missing:
+            mismatched.append((where, f"{work} 卷{juan}" if juan is not None else work, missing))
+    return mismatched, unknown
+
+
 def verify_ids(bridge, cbeta_map: dict[str, list[str]], titles: dict[str, str]) -> dict[str, dict]:
     """Verify all CBETA IDs and return {full_cbeta_id: {text_id, short_id, title, ...}}.
 
@@ -566,7 +978,8 @@ def _run_legacy_link_verification(*, fix: bool) -> int:
 
     # Step 3b: 卷号。FoJin 的查询把卷号丢掉了,所以上面那一步结构上看不见它。
     print("\n[3b/4] Checking declared volume numbers against CBETA...")
-    cbeta_vols = fetch_cbeta_volumes(sorted(combined_map))
+    cbeta_works = fetch_cbeta_works(sorted(combined_map))
+    cbeta_vols = {k: (v or {}).get("vol") for k, v in cbeta_works.items()}
     mismatched, unknown_to_cbeta = classify_cbeta_volumes(combined_map, cbeta_vols)
     if mismatched:
         print(f"  Declared IDs CBETA disagrees with ({len(mismatched)}):")
@@ -579,6 +992,22 @@ def _run_legacy_link_verification(*, fix: bool) -> int:
     if not mismatched and not unknown_to_cbeta:
         print(f"  All {len(combined_map)} declared IDs sit in a volume CBETA gives this work")
 
+    # Step 3c: 题名。卷号对、FoJin 查得到，仍可能是另一部书（见 titles_agree）。
+    print("\n[3c/4] Checking declared titles against CBETA...")
+    declared_titles = collect_declared_titles()
+    title_mismatched, title_unknown = classify_cbeta_titles(
+        {cid: declared_titles.get(cid, []) for cid in cbeta_map},
+        {k: (v or {}).get("title") for k, v in cbeta_works.items()},
+    )
+    for full_id, (mine, theirs) in sorted(title_mismatched.items()):
+        teachers = ", ".join(combined_map.get(full_id, ["?"]))
+        print(f"    [WRONG] {full_id} declared as 《{' / '.join(mine)}》 -> CBETA: 《{theirs}》  (used by: {teachers})")
+    if title_unknown:
+        print(f"  Could not compare titles for {len(title_unknown)} ID(s) — "
+              "unknown, not wrong: " + ", ".join(title_unknown))
+    if not title_mismatched and not title_unknown:
+        print(f"  All {len(cbeta_map)} declared titles match the work CBETA gives each ID")
+
     found = {k: v for k, v in verified.items() if v["text_id"] is not None}
     all_absent = {k: v for k, v in verified.items() if v["text_id"] is None}
     known_absent = load_known_absent()
@@ -618,6 +1047,64 @@ def _run_legacy_link_verification(*, fix: bool) -> int:
                 f"{found[cid]['text_id']}) —— 从清单里删掉这一条"
             )
 
+    # Step 3d: SKILL.md frontmatter 的 fojin_text_id（见 classify_frontmatter_fojin_ids）。
+    print("\n[3d/4] Checking SKILL.md frontmatter fojin_text_id values against FoJin...")
+    short_to_text = {
+        info.get("short_cbeta_id"): info["text_id"] for info in found.values()
+    }
+    fm_mismatched, fm_unknown = classify_frontmatter_fojin_ids(
+        collect_frontmatter_fojin_ids(), short_to_text
+    )
+    for teacher, cbeta_id, title, written, actual in fm_mismatched:
+        print(f"    [WRONG] {teacher}: 《{title}》 {cbeta_id} fojin_text_id={written} -> FoJin resolves {actual}")
+    if fm_unknown:
+        print(f"  FoJin did not resolve {len(fm_unknown)} frontmatter ID(s) — "
+              "unknown, not wrong: " + ", ".join(fm_unknown))
+    if not fm_mismatched and not fm_unknown:
+        print("  Every frontmatter fojin_text_id matches what FoJin resolves")
+
+    # Step 3e: 人设文档里引文后面的 FoJin 链接打开的是不是那部书（见 collect_doc_citation_links）。
+    print("\n[3e/4] Checking FoJin links after citations in persona docs...")
+    doc_pairs = collect_doc_citation_links()
+    doc_records: dict[str, dict | None] = {}
+    for tid in sorted({tid for _, tid, _, _ in doc_pairs}, key=int):
+        try:
+            record = bridge.get_text(tid)
+        except Exception:  # noqa: BLE001 — 查不到是「未知」，不是「不符」
+            record = None
+        doc_records[tid] = record if isinstance(record, dict) and record else None
+    doc_mismatched, doc_unknown = classify_doc_citation_links(doc_pairs, doc_records)
+    for where, tid, problem in doc_mismatched:
+        print(f"    [WRONG] {where}: {problem}")
+    if doc_unknown:
+        print(f"  FoJin returned nothing for {len(doc_unknown)} doc link(s) — "
+              "unknown, not wrong: " + ", ".join(doc_unknown))
+    if not doc_mismatched and not doc_unknown:
+        print(f"  All {len(doc_pairs)} citation links in persona docs open the cited work")
+
+    # Step 3f: 摘录里的「原典」引文是否真在所引那一卷（见 classify_excerpt_quotes）。
+    print("\n[3f/4] Checking excerpt quotations against the cited CBETA fascicle...")
+    quotes = collect_excerpt_quotes()
+    quote_works = sorted({work for work in (_cbeta_api_work(cid) for _, _, cid, _ in quotes) if work})
+    juan_counts = {work: fetch_cbeta_juan_count(work) for work in quote_works}
+    wanted_juans = sorted({
+        (work, fascicle)
+        for _, _, cid, juan in quotes
+        for work in [_cbeta_api_work(cid)]
+        if work
+        for fascicle in (excerpt_fascicles(juan, juan_counts.get(work)) or [])
+    })
+    juan_texts = {key: fetch_cbeta_juan_text(*key) for key in wanted_juans}
+    quote_mismatched, quote_unknown = classify_excerpt_quotes(quotes, juan_counts, juan_texts)
+    for where, cited, missing in quote_mismatched:
+        print(f"    [WRONG] {where}: {cited}" + (f" has no 「{'」「'.join(missing)}」" if missing else ""))
+    if quote_unknown:
+        print(f"  Could not check {len(quote_unknown)} quotation(s) — unknown, not wrong:")
+        for where, reason in quote_unknown:
+            print(f"    {where}: {reason}")
+    if not quote_mismatched and not quote_unknown:
+        print(f"  All {len(quotes)} quotations appear clause by clause in the cited fascicle")
+
     # Step 4: Update URLs
     # Build replacement map: full_cbeta_id -> str(internal_text_id)
     id_replacement_map: dict[str, str] = {}
@@ -660,6 +1147,10 @@ def _run_legacy_link_verification(*, fix: bool) -> int:
         print(f"  Stale known-absent entries:{len(stale_absent):>4}")
     print(f"  URL replacements:          {len(all_changes)}")
     print(f"  CBETA id mismatches:       {len(mismatched)}")
+    print(f"  CBETA title mismatches:    {len(title_mismatched)}")
+    print(f"  Frontmatter FoJin id mismatches: {len(fm_mismatched)}")
+    print(f"  Doc citation links to another work: {len(doc_mismatched)}")
+    print(f"  Excerpt quotes not in the cited text: {len(quote_mismatched)}")
     if unknown_to_cbeta:
         print(f"  CBETA unreachable for:     {len(unknown_to_cbeta)} (not counted as wrong)")
     if dry_run and all_changes: