master-skill 0.12.1 → 0.12.2

package/scripts/check-pe-subsystem.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""Check which Windows subsystem a PE executable was linked for.
+
+The field is the Subsystem word of the PE optional header: 2 for a GUI
+program, 3 for a console one (`file` prints the latter as `PE32+ executable
+(console)`). The desktop manager is kept a console program. A GUI-subsystem
+build stops double-clicking from opening a console window, but on
+release-desktop run 34858072308 PowerShell did not wait for it, closed the
+pipe, and `--help > help.txt` panicked. The release smoke test runs this with
+`--expect 3` so the switch cannot come back unmeasured.
+
+Output is ASCII only. This runs on the Windows release runner, whose console
+encoding is cp1252; a check mark there raised UnicodeEncodeError after the
+check itself had passed.
+
+Usage:
+    python scripts/check-pe-subsystem.py <exe> --expect 2
+"""
+
+from __future__ import annotations
+
+import argparse
+import struct
+import sys
+from pathlib import Path
+
+SUBSYSTEMS = {2: "Windows GUI", 3: "Windows console"}
+
+
+def pe_subsystem(data: bytes) -> int:
+    """Return the Subsystem field of a PE image's optional header."""
+    if data[:2] != b"MZ":
+        raise ValueError("not a PE file: no MZ header")
+    (pe_offset,) = struct.unpack_from("<I", data, 0x3C)
+    if data[pe_offset:pe_offset + 4] != b"PE\0\0":
+        raise ValueError("not a PE file: no PE signature")
+    # The optional header follows the 4-byte signature and the 20-byte COFF
+    # header; Subsystem sits 68 bytes into it in both PE32 and PE32+.
+    (subsystem,) = struct.unpack_from("<H", data, pe_offset + 24 + 68)
+    return subsystem
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("exe", type=Path)
+    parser.add_argument("--expect", type=int, required=True, help="2 = GUI, 3 = console")
+    args = parser.parse_args(argv)
+    try:
+        with args.exe.open("rb") as handle:
+            subsystem = pe_subsystem(handle.read(4096))
+    except (OSError, ValueError, struct.error) as exc:
+        print(f"FAIL {args.exe}: {exc}")
+        return 1
+    found = f"{subsystem} ({SUBSYSTEMS.get(subsystem, 'other')})"
+    if subsystem != args.expect:
+        wanted = f"{args.expect} ({SUBSYSTEMS.get(args.expect, 'other')})"
+        print(f"FAIL {args.exe}: subsystem {found}, expected {wanted}")
+        return 1
+    print(f"OK {args.exe}: subsystem {found}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/reaudit-report.py

@@ -13,6 +13,12 @@ The ¥3.89 sweep is re-measurable for nothing, and a family added to the auditor
 has to show what it bought instead of asserting it.
 
     python3 scripts/reaudit-report.py eval/reports/0.11.0-06b8142-deepseek.json
+    python3 scripts/reaudit-report.py eval/reports/0.11.0-06b8142-deepseek.json --online
+
+`--online` also asks FoJin about the run's live citations, the ones that passed
+offline on a link alone: does each link open, and is it the work the citation
+names (same sutra number, agreeing title)? It needs the network and reads
+nothing back into the report.
 
 The report file itself is never rewritten: it is the record of what that run
 measured with that instrument, and editing it would be rewriting the experiment.
@@ -29,6 +35,7 @@ from verify_citations import (  # noqa: E402
     load_declared_ids,
     load_member_aliases,
     load_title_aliases,
+    verify_online,
 )
 
 
@@ -80,6 +87,7 @@ def reaudit(report: dict) -> dict:
             continue
 
         checked = unparsed = 0
+        live: list[dict] = []
         fabricated: list[str] = []
         noncitation: list[str] = []
         for result in suite["results"]:
@@ -92,6 +100,7 @@ def reaudit(report: dict) -> dict:
                 len(audit["offline"]) + len(audit["live"]) + len(audit["fabricated"])
             )
             unparsed += len(audit["unparsed"])
+            live.extend(audit["live_detail"])
             fabricated.extend(audit["fabricated"])
             noncitation.extend(audit.get("noncitation", ()))
         recomputed = {"checked": checked, "unparsed": unparsed}
@@ -104,6 +113,8 @@ def reaudit(report: dict) -> dict:
                 "recorded": recorded,
                 "recomputed": recomputed,
                 "fabricated": sorted(set(fabricated)),
+                # Passed on a FoJin link alone; only `--online` checks the link.
+                "live": live,
                 # 判定为「不是引文」的【…】块。不计入覆盖率的分母,但必须
                 # 数出来:排除而不申报,和静默跳过没有区别。
                 "noncitation": sorted(set(noncitation)),
@@ -121,12 +132,41 @@ def _coverage(counts: dict | None) -> str:
     return f"{counts['checked']}/{total} {counts['checked'] / total:.0%}"
 
 
+def _print_online(out: dict) -> None:
+    """Ask FoJin whether each stored live citation's link is the work it names."""
+    cited = [(s["master"], c) for s in out["suites"] for c in s.get("live", ())]
+    if not cited:
+        print("\nlive 引文在线核验：这次运行没有 live 引文")
+        return
+    tids = [c["text_id"] for _, c in cited]
+    res = verify_online(tids, citations=[c for _, c in cited])
+    print(f"\nlive 引文在线核验：{len(cited)} 条，{len(set(tids))} 个 FoJin 链接")
+    if res.unreachable:
+        print(f"  ⚠ 未能核验：FoJin 不可达（{res.unreachable}）")
+        return
+    groups: dict[tuple[str, str], int] = {}
+    for master, citation in cited:
+        key = (master, citation["text_id"])
+        groups[key] = groups.get(key, 0) + 1
+    for (master, tid), count in sorted(groups.items()):
+        verdict = res.verdicts.get(tid)
+        if verdict is True:
+            continue
+        mark = "✗" if verdict is False else "?"
+        print(f"  {mark} {master} ×{count}  {res.reasons.get(tid, '未能核验')}")
+    passed = sum(count for (_, tid), count in groups.items() if res.verdicts.get(tid) is True)
+    print(f"  ✓ {passed} 条的链接是所引之书")
+
+
 def main(argv: list[str]) -> int:
-    if len(argv) != 2:
+    args = argv[1:]
+    online = "--online" in args
+    paths = [arg for arg in args if arg != "--online"]
+    if len(paths) != 1:
         print(__doc__.strip().splitlines()[0])
-        print(f"usage: {Path(argv[0]).name} <eval/reports/*.json>")
+        print(f"usage: {Path(argv[0]).name} <eval/reports/*.json> [--online]")
         return 2
-    path = Path(argv[1])
+    path = Path(paths[0])
     report = json.loads(path.read_text())
     out = reaudit(report)
 
@@ -156,6 +196,8 @@ def main(argv: list[str]) -> int:
         )
         for block in skipped:
             print(f"    【{block}】")
+    if online:
+        _print_online(out)
     return 0
 
 

package/scripts/validate-citation-references.py

@@ -14,17 +14,29 @@ as the prescribed format while `meta.json` declares five sources, none of them
 That was found by a ¥3.89 graded run over 211 fixtures, which caught it only
 because one fixture happened to trigger it. This finds every instance of the
 class deterministically, for free, on every PR.
+
+It reads source ids outside 【…】 too. A routing table is an instruction as
+much as a citation template is, and until 2026-09-14 this gate saw only
+bracketed citations — while six genuine works that personas' own tables and
+prose pointed at had never been declared (see `_bare_ids`).
 """
 from __future__ import annotations
 
 import json
 import re
 import sys
+from collections import Counter
 from dataclasses import dataclass
 from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent))
-from verify_citations import audit_answer, load_declared_ids, load_member_aliases  # noqa: E402
+from verify_citations import (  # noqa: E402
+    audit_answer,
+    extract_citation_ids,
+    load_declared_ids,
+    load_member_aliases,
+    load_title_aliases,
+)
 
 PREBUILT_DIR = Path(__file__).resolve().parent.parent / "prebuilt"
 
@@ -47,12 +59,14 @@ _TEMPLATE_MARKERS = (
 # been permitted. Do not add to it to turn a red build green — that is exactly
 # the failure this gate exists to prevent.
 #
-# Empty as of 2026-09-03. Both findings this gate ever recorded were resolved
+# Empty as of 2026-09-14. The first two findings this gate recorded were resolved
 # by declaring the source: `Toh:3861` in master-tsongkhapa/meta.json (月称《入
 # 中论》is a real Tengyur text Tsongkhapa's tradition treats as its own
 # foundation) and `J36nB348` in master-ouyi/meta.json (《灵峰宗论》is Ouyi's own
 # collected works). Neither needed a B1 contract change — both simply belonged
-# in the declared set. See CHANGELOG.md for the maintainer decision.
+# in the declared set. See CHANGELOG.md for the maintainer decision. The six the
+# bare-id sweep found on 2026-09-14 were resolved the same way, never entered
+# here.
 KNOWN_UNDECLARED: dict[tuple[str, str], str] = {}
 
 
@@ -77,6 +91,33 @@ def _strip_template_citations(text: str) -> str:
     return "".join(out)
 
 
+# `BDRC W-number` in a persona's own rules names a field, it is not an id:
+# master-tsongkhapa says 不得编造未验证的 BDRC W-number, master-atisha asks for
+# a BDRC W-ID. `_FAMILY_ID` stays loose on purpose — in an answer, reading too
+# much fails safe as fabricated (see the note above `_FOJIN_TEXT_LINK` in
+# verify_citations.py) — so it reads both as ids. Only this prose sweep drops
+# them: a real BDRC work id is W followed by a digit (W22272, W1KG14334), the
+# rule the auditor's own bare-W branch already applies.
+_BDRC_FIELD_NAME = re.compile(r"^BDRC:W(?![0-9])")
+
+
+def _bare_ids(text: str) -> list[str]:
+    """Source ids written outside every 【…】 block: table cells, prose, frontmatter.
+
+    `audit_answer` reads only bracketed citations, so a persona's routing table
+    was invisible to this gate. master-xuanzang's SKILL.md sent 五位百法
+    questions to `《百法明门论》，T31n1614` in a table cell; master-ouyi had an
+    offline excerpt file for 《教觀綱宗》 T46n1939. Neither id was declared.
+
+    Callers audit each id alone, as `【id】` with nothing after it, so a FoJin
+    link in the same table row cannot make it `live`: in an answer a link can
+    vouch for one citation, but in the persona's own material a link is not a
+    declaration.
+    """
+    ids = extract_citation_ids(_BLOCK.sub(" ", text))
+    return [cid for cid in ids if not _BDRC_FIELD_NAME.match(cid)]
+
+
 @dataclass(frozen=True)
 class Finding:
     master: str
@@ -84,8 +125,12 @@ class Finding:
     path: str
 
 
-def find_undeclared(prebuilt_dir: Path) -> list[Finding]:
-    """Every citation the personas' own material makes that meta.json omits."""
+def find_undeclared(prebuilt_dir: Path, reach: Counter | None = None) -> list[Finding]:
+    """Every citation the personas' own material makes that meta.json omits.
+
+    `reach`, when given, counts what was read: bracketed citations the audit
+    could resolve to an id, and bare ids outside brackets.
+    """
     findings: list[Finding] = []
     for persona in sorted(Path(prebuilt_dir).iterdir()):
         meta_path = persona / "meta.json"
@@ -100,6 +145,13 @@ def find_undeclared(prebuilt_dir: Path) -> list[Finding]:
         try:
             declared = load_declared_ids(persona.name, base=str(prebuilt_dir))
             aliases = load_member_aliases(persona.name, base=str(prebuilt_dir))
+            # Declared titles, as reaudit-report.py and test-fidelity.py already
+            # pass them. Without them a source with no sutra number is unreadable:
+            # master-yinguang's own 【《印光法師文鈔正編》卷一】 examples counted as
+            # nothing, and the sweep read fewer citations after the Wenchao was
+            # re-declared. An alias only makes a block readable; it cannot turn an
+            # undeclared id into a declared one.
+            titles = load_title_aliases(persona.name, base=str(prebuilt_dir))
         except (FileNotFoundError, ValueError):
             continue  # meta.json exists (meta_path.is_file() above) but is unreadable
         if not declared:
@@ -111,7 +163,17 @@ def find_undeclared(prebuilt_dir: Path) -> list[Finding]:
             if not doc.is_file():
                 continue
             text = _strip_template_citations(doc.read_text(encoding="utf-8"))
-            for citation in dict.fromkeys(audit_answer(declared, text, aliases)["fabricated"]):
+            bracketed = audit_answer(declared, text, aliases, titles)
+            undeclared = list(bracketed["fabricated"])
+            bare = _bare_ids(text)
+            for cid in bare:
+                undeclared += audit_answer(declared, f"【{cid}】", aliases)["fabricated"]
+            if reach is not None:
+                reach["bracketed"] += sum(
+                    len(bracketed[bucket]) for bucket in ("offline", "live", "fabricated")
+                )
+                reach["bare"] += len(bare)
+            for citation in dict.fromkeys(undeclared):
                 findings.append(
                     Finding(persona.name, citation, str(doc.relative_to(prebuilt_dir.parent)))
                 )
@@ -119,7 +181,18 @@ def find_undeclared(prebuilt_dir: Path) -> list[Finding]:
 
 
 def main() -> int:
-    findings = find_undeclared(PREBUILT_DIR)
+    reach: Counter = Counter()
+    findings = find_undeclared(PREBUILT_DIR, reach)
+    print(
+        f"Read {reach['bracketed']} bracketed citations and {reach['bare']} bare "
+        "source ids in the personas' own docs."
+    )
+    if not reach["bracketed"] or not reach["bare"]:
+        print(
+            "FAIL: the sweep read nothing of one kind — it is not looking at what "
+            "it claims to check."
+        )
+        return 1
     known, new = [], []
     for f in findings:
         (known if (f.master, f.citation) in KNOWN_UNDECLARED else new).append(f)

package/scripts/validate-self-audit-sources.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""Gate: a persona's self-audit list must include every source it declares.
+
+Nine personas end SKILL.md with the same pre-answer rule (B1): before replying,
+check that each offline citation's identifier "∈ 本 master frontmatter `sources:`
+声明的对应字段", and strip any claim that fails. The list the model checks
+against is the frontmatter, not meta.json, and nothing compared the two.
+
+master-ouyi declares 《灵峰宗论》 `J36nB348` in meta.json, and its own
+references/teaching.md cites it, but its frontmatter never listed it. A model
+following the rule to the letter deletes a correct citation of Ouyi's own
+collected works. The audit would never notice: it reads meta.json.
+
+Personas whose rule points at meta.json instead are not examined here.
+
+Usage:
+    python3 scripts/validate-self-audit-sources.py
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import yaml
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from verify_citations import audit_answer  # noqa: E402
+
+PREBUILT = Path(__file__).resolve().parent.parent / "prebuilt"
+
+# The phrase every frontmatter-pointing rule uses. If the wording changes, the
+# gate examines nothing and says so instead of passing.
+_RULE = "frontmatter `sources:`"
+
+# The identifier fields the rule itself enumerates.
+_ID_FIELDS = (
+    "cbeta_id", "toh_id", "bdrc_id", "pts_id", "suttacentral", "suttacentral_id", "teaching_id",
+)
+
+
+def _frontmatter_ids(text: str) -> list[str]:
+    parts = text.split("---", 2)
+    if len(parts) < 3 or parts[0].strip():
+        return []
+    front = yaml.safe_load(parts[1]) or {}
+    ids: list[str] = []
+    for src in front.get("sources") or []:
+        if isinstance(src, dict):
+            ids += [str(src[field]) for field in _ID_FIELDS if src.get(field) is not None]
+    return ids
+
+
+def _covered(declared_id: str, listed: list[str]) -> bool:
+    """Does some frontmatter identifier name `declared_id`, in a spelling the audit accepts?
+
+    The resolution is the auditor's own. master-zhiyi's frontmatter writes
+    `T1716` for the declared `T33n1716`; master-milarepa writes `W22272` for
+    `BDRC:W22272`. A model citing either passes the audit, so the list covers
+    the source. Reimplementing those rules here would drift from them.
+    """
+    return any(
+        declared_id in audit_answer({declared_id}, f"【{value}】")["offline"] for value in listed
+    )
+
+
+def check_persona(persona: Path) -> tuple[list[str], bool]:
+    """Return (problems, whether this persona was examined)."""
+    skill, meta = persona / "SKILL.md", persona / "meta.json"
+    if not skill.is_file() or not meta.is_file():
+        return [], False
+    text = skill.read_text(encoding="utf-8")
+    if _RULE not in text:
+        return [], False
+    rule_line = text[: text.index(_RULE)].count("\n") + 1
+    listed = _frontmatter_ids(text)
+    problems: list[str] = []
+    for src in json.loads(meta.read_text(encoding="utf-8")).get("sources", []):
+        source_id = src.get("id")
+        if source_id and not _covered(source_id, listed):
+            problems.append(
+                f"{persona.name}: meta.json declares {source_id} ({src.get('title', '')}) "
+                f"but the frontmatter `sources:` never lists it. The self-audit rule at "
+                f"SKILL.md:{rule_line} checks citations against that list, so a correct "
+                f"citation of this source would be stripped."
+            )
+    return problems, True
+
+
+def main(prebuilt: Path = PREBUILT) -> int:
+    problems: list[str] = []
+    examined: list[str] = []
+    for persona in sorted(p for p in prebuilt.iterdir() if p.is_dir()):
+        found, looked = check_persona(persona)
+        problems += found
+        if looked:
+            examined.append(persona.name)
+
+    if not examined:
+        print(f"✗ no persona's SKILL.md contains {_RULE!r} — this check examined nothing")
+        return 1
+    if problems:
+        print(f"✗ {len(problems)} declared source(s) missing from a self-audit list:\n")
+        for problem in problems:
+            print(f"  - {problem}")
+        return 1
+    print(
+        f"✓ self-audit sources ok — {len(examined)} persona(s) check citations against "
+        f"their frontmatter: {', '.join(examined)}"
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/verify_citations.py

@@ -617,6 +617,7 @@ def audit_answer(
     fabricated: list[str] = []
     unparsed: list[str] = []
     noncitation: list[str] = []
+    live_detail: list[dict] = []
 
     blocks = list(_CITATION_BLOCK.finditer(answer))
     for idx, m in enumerate(blocks):
@@ -679,11 +680,22 @@ def audit_answer(
                 unresolved.append(cid)
         if len(unresolved) == 1 and links:
             live.append((unresolved[0], links[0]))
+            # `--online` needs more than the pair to tell whether the link is the
+            # work the citation names: the title the block gives it.
+            title = _WORK_TITLE.search(m.group(1))
+            live_detail.append(
+                {
+                    "cited_id": unresolved[0],
+                    "text_id": links[0],
+                    "title": title.group(1) if title else None,
+                }
+            )
         else:
             fabricated.extend(unresolved)
     return {
         "offline": offline,
         "live": live,
+        "live_detail": live_detail,
         "fabricated": fabricated,
         "unparsed": unparsed,
         "noncitation": noncitation,
@@ -701,8 +713,58 @@ VERIFY_TIMEOUT = 15
 VERIFY_WORKERS = 8
 
 
-def _check_one_text_id(session_factory, base_url: str, tid: str, timeout: int):
-    """核验单个 text_id,返回 (三态结果, 说明)。异常一律收敛成 None,不外抛。"""
+def _cbeta_key(cid: str) -> tuple[str, str] | None:
+    """`T30n1568` / `T1568` / `JB348` → (藏别, 去零经号);不是 CBETA 号 → None。"""
+    m = _FULL_FORM.match(cid) or _SHORT_FORM.match(cid)
+    if not m:
+        return None
+    return m.group(1), _normalize_cbeta_work_number(m.group(2))
+
+
+def _titles_agree(cited: str, linked: str) -> bool | None:
+    """借用 tools/verify_sources.titles_agree(读音子序列);加载不了返回 None。"""
+    tools = os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, "tools")
+    if tools not in sys.path:
+        sys.path.insert(0, tools)
+    try:
+        from verify_sources import titles_agree
+    except ImportError:
+        return None
+    return titles_agree(cited, linked)
+
+
+def _live_link_mismatch(citation: dict, payload: dict) -> str | None:
+    """一个解析得到的 FoJin 文本,为什么仍不是这条 live 引文所说的那部书;可能是则 None。
+
+    只验「打得开」时,【《伪经》,T99n9999】→ texts/20 能过:texts/20 是
+    《佛說阿彌陀經》。master-yinguang 的存档引文更隐蔽:X62n1182 → texts/12977,
+    链接的 cbeta_id 正是 X1182,经号自洽,可那部书是《徹悟禪師語錄》而不是引文
+    写的《印光法師文鈔正編》。所以比两样:经号(只对 CBETA 号),书名(引文给了
+    才比)。书名先截掉「·品名」「〈篇名〉」,篇章不是书名的一部分。
+    """
+    tid = citation.get("text_id")
+    cited = citation.get("cited_id") or ""
+    linked_id = payload.get("cbeta_id")
+    cited_key = _cbeta_key(cited)
+    if cited_key and linked_id and _cbeta_key(str(linked_id)) != cited_key:
+        return f"texts/{tid} 是 {linked_id},不是引文写的 {cited}"
+    title = citation.get("title")
+    linked_title = payload.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:
+            return f"引文题名《{title}》对不上 texts/{tid} 的《{linked_title}》"
+    return None
+
+
+def _check_one_text_id(
+    session_factory, base_url: str, tid: str, timeout: int, citations=()
+):
+    """核验单个 text_id,返回 (三态结果, 说明)。异常一律收敛成 None,不外抛。
+
+    `citations` 是用这个 text_id 作链接的 live 引文;给了就还要核对链接是不是
+    它们所说的那部书(见 `_live_link_mismatch`),对不上判 False。
+    """
     try:
         resp = session_factory().get(f"{base_url}/api/texts/{tid}", timeout=timeout)
     except Exception as e:  # noqa: BLE001 — 传输层失败是"不知道",不是"不存在"
@@ -717,6 +779,11 @@ def _check_one_text_id(session_factory, base_url: str, tid: str, timeout: int):
         # 200 却不是 JSON:通常是网关错误页,不能据此断定 id 不存在。
         return None, "200 但正文不是 JSON"
     if payload:
+        if isinstance(payload, dict):
+            for citation in citations:
+                mismatch = _live_link_mismatch(citation, payload)
+                if mismatch:
+                    return False, mismatch
         return True, ""
     # 200 + 空正文归 None,不归 False —— 上面刚写下「404 是唯一该硬失败的信号」,
     # 这里返回 False 就是在自己的契约上开口子。空信封可能来自 FoJin 换了外层结构、
@@ -758,6 +825,7 @@ def verify_online(
     base_url: str = "https://fojin.app",
     timeout: int = VERIFY_TIMEOUT,
     workers: int = VERIFY_WORKERS,
+    citations: list[dict] | None = None,
 ) -> OnlineVerification:
     """best-effort:GET /api/texts/{id} 看 live 引文的 text_id 是否真解析。
 
@@ -770,6 +838,9 @@ def verify_online(
         return OnlineVerification({}, {}, "requests 未安装")
 
     unique = sorted(set(text_ids))
+    by_tid: dict[str, list[dict]] = {}
+    for citation in citations or ():
+        by_tid.setdefault(str(citation.get("text_id")), []).append(citation)
     if not unique:
         return OnlineVerification({}, {})
 
@@ -785,7 +856,14 @@ def verify_online(
     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
+            pool.submit(
+                _check_one_text_id,
+                session_factory,
+                base_url,
+                tid,
+                timeout,
+                by_tid.get(tid, ()),
+            ): tid
             for tid in unique
         }
         for future in as_completed(futures):
@@ -807,7 +885,10 @@ def main() -> int:
     p = argparse.ArgumentParser(description="B1 引证核验器")
     p.add_argument("--master", required=True, help="master slug,如 huineng")
     p.add_argument("--answer-file", help="答案文件;省略则从 stdin 读")
-    p.add_argument("--online", action="store_true", help="额外验证 live 引文 text_id 可解析")
+    p.add_argument(
+        "--online", action="store_true",
+        help="额外验证 live 引文:链接可解析,且是引文所说的那部书(经号、书名)",
+    )
     args = p.parse_args()
 
     try:
@@ -830,7 +911,9 @@ def main() -> int:
         exit_code = 1
 
     if args.online and report["live"]:
-        res = verify_online([tid for _, tid in report["live"]])
+        res = verify_online(
+            [tid for _, tid in report["live"]], citations=report["live_detail"]
+        )
         if res.unreachable:
             print(f"⚠ --online 跳过:FoJin 不可达({res.unreachable})", file=sys.stderr)
         else:
@@ -838,7 +921,10 @@ def main() -> int:
             # 网络状况,不是引文真伪,拿它判 fabricated 会在 FoJin 抖动时把正确
             # 引用打成伪造,那比漏检更糟。
             if res.fabricated:
-                print(f"✗ live 引文 text_id 无法解析: {res.fabricated}", file=sys.stderr)
+                detail = "; ".join(
+                    f"{t}({res.reasons.get(t, '?')})" for t in res.fabricated
+                )
+                print(f"✗ live 引文链接无法解析或不是所引之书: {detail}", file=sys.stderr)
                 exit_code = 1
             if res.unknown:
                 # 报出来而不是静默算过 —— 「没查成」必须与「查过没问题」可区分。