dsh-distillation-director 4.6.5

package/scripts/blindtest_lexicon_mock_v1.py

@@ -0,0 +1,289 @@
+# -*- coding: utf-8 -*-
+"""盲测闸 词表命中模拟器 v1（零 LLM 本地 py · 初判用）
+
+目标：description 触发词表 对 用户路由 prompt 做字面命中初判，筛掉“机械可判”路由；
+无字面锚/弱命中/邻族抢单 的 prompt 显式标记 needs_llm=True，交 LLM judge 结构化表
+（13x{命中/目标/邻族风险}，单发小批）——对应三闸方案里盲测的机器初判层。
+
+验收基准：反脆弱册 blind-test-report.md 的 12 条路由盲测（AD-1..6 / OC-1..6），
+judge 结论=9 干脆 + 3 边界存疑（AD-3/OC-4/OC-5）+ 2 判停（AD-6/OC-6）。
+
+用法：
+  python blindtest_lexicon_mock_v1.py
+  python blindtest_lexicon_mock_v1.py --prompts <json>   （覆盖内嵌 fixture）
+产物：blindtest-mock-v1.json + 盲测词表模拟器v1-试点报告.md（同目录）
+"""
+import os
+import re
+import sys
+import json
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.dirname(os.path.dirname(HERE))
+TT = os.path.join(ROOT, "投资蒸馏", "塔勒布五部曲")
+BOOKS = {
+    "反脆弱": os.path.join(TT, "反脆弱"),
+    "股票大作手回忆录": os.path.join(ROOT, "投资蒸馏", "股票大作手回忆录"),
+    "寻找鱼多的池塘": os.path.join(ROOT, "投资蒸馏", "寻找鱼多的池塘"),
+}
+SKILLS = {
+    "antifragile-designer": os.path.join(BOOKS["反脆弱"], "skills", "antifragile-designer", "SKILL.md"),
+    "optionality-convexity": os.path.join(BOOKS["反脆弱"], "skills", "optionality-convexity", "SKILL.md"),
+    "trader-discipline": os.path.join(BOOKS["股票大作手回忆录"], "skills", "trader-discipline", "SKILL.md"),
+    "market-structure-and-manipulation": os.path.join(BOOKS["股票大作手回忆录"], "skills", "market-structure-and-manipulation", "SKILL.md"),
+    "multi-asset-rotation": os.path.join(BOOKS["寻找鱼多的池塘"], "skills", "multi-asset-rotation", "SKILL.md"),
+    "convertible-pool-rotation": os.path.join(BOOKS["寻找鱼多的池塘"], "skills", "convertible-pool-rotation", "SKILL.md"),
+    "fund-selector": os.path.join(BOOKS["寻找鱼多的池塘"], "skills", "fund-selector", "SKILL.md"),
+    "investing-mindset": os.path.join(BOOKS["寻找鱼多的池塘"], "skills", "investing-mindset", "SKILL.md"),
+}
+
+# 判停红线词（时点预测等；盲测 AD-6/OC-6）
+REDLINE = ["什么时候会", "何时发生", "何时会", "会不会崩", "会不会涨", "会崩", "会跌", "预测", "明天", "涨跌", "提前跑", "逃顶", "抄底", "会涨吗"]  # v1.1：移除裸词“什么时候/何时”（会把“什么时候能拆线”误判为时点预测），见规范对比实验 sge-3 案例
+
+FIXTURES = [
+    {"id": "AD-1", "target": "antifragile-designer", "judge_class": "clear", "prompt": "家庭财务就怕是裁员这种打击，怎么让我的职业收入不怕黑天鹅？"},
+    {"id": "AD-2", "target": "antifragile-designer", "judge_class": "clear", "prompt": "我现在零冗余、满负荷、效率极高，但总觉得哪里不对，是不是越优化越脆？"},
+    {"id": "AD-3", "target": "antifragile-designer", "judge_class": "boundary", "prompt": "我吃一堆保健品、每年全套体检来防病，这种过度保护是不是反而有害？"},
+    {"id": "AD-4", "target": "antifragile-designer", "judge_class": "clear", "prompt": "这本书刚出版就火了，值不值得买来学？新公司值不值得追？"},
+    {"id": "AD-5", "target": "antifragile-designer", "judge_class": "clear", "prompt": "我严格按计划、全面求稳，反而越来越脆，为什么越优化越脆？"},
+    {"id": "AD-6", "target": "antifragile-designer", "judge_class": "decline", "prompt": "股市房价什么时候会崩，我想提前跑。"},
+    {"id": "OC-1", "target": "optionality-convexity", "judge_class": "clear", "prompt": "10 个创业公司死 9 个，成了赚 50 倍，要不要拿全部积蓄投？"},
+    {"id": "OC-2", "target": "optionality-convexity", "judge_class": "clear", "prompt": "我胜率不到 40%，是不是方法不行该放弃？"},
+    {"id": "OC-3", "target": "optionality-convexity", "judge_class": "clear", "prompt": "小仓位试错和赌博有什么区别？"},
+    {"id": "OC-4", "target": "optionality-convexity", "judge_class": "boundary", "prompt": "这只基金十年年年正收益，历史数据这么好，能不能重仓？"},
+    {"id": "OC-5", "target": "optionality-convexity", "judge_class": "boundary", "prompt": "波动太大我睡不着，要不要降仓位、降波动？"},
+    {"id": "OC-6", "target": "optionality-convexity", "judge_class": "decline", "prompt": "预测比特币明天涨跌，涨了我就全仓跟。"},
+]
+
+
+def read_description(path):
+    with open(path, encoding="utf-8") as f:
+        lines = f.read().splitlines()
+    if not lines or lines[0].strip() != "---":
+        return ""
+    desc = []
+    active = False
+    for ln in lines[1:]:
+        if ln.strip() == "---":
+            break
+        if ln.startswith("description:"):
+            active = True
+            desc.append(ln[len("description:"):].strip())
+        elif active and ln.startswith((" ", "\t")):
+            desc.append(ln.strip())
+    text = " ".join(desc)
+    if text.startswith("") and text.endswith("") and len(text) >= 2:
+        text = text[1:-1]
+    return text
+
+
+def extract_lexicon(desc):
+    """v1.2（对比实验 v3.1 优化）：词源=整段 description（触发词段+何时用/何时不用+引号话术示例），
+    去括号后按标点/引号/斜杠/空格切词；2..16 字为 token（超长整句跳过防噪声）。"""
+    seg = re.sub(r"[（(][^）)]*[）)]", "", desc)
+    toks = re.split(r"['\"、，,；;/|｜\s：:。！？!?—…]+", seg)
+    out = []
+    seen = set()
+    for t in toks:
+        t = t.strip(" 　“”「」‘’：:。，、！？…")
+        if 2 <= len(t) <= 16 and t not in seen and not re.fullmatch(r"[0-9a-zA-Z.]+", t):
+            seen.add(t)
+            out.append(t)
+    return out[:200]
+
+
+def build_lexicons():
+    lex = {}
+    for slug, path in SKILLS.items():
+        desc = read_description(path)
+        lex[slug] = extract_lexicon(desc)
+    return lex
+
+
+# ---- 通用化（A-37 修复 · 2026-09-13）------------------------------------------------
+# 病根：docstring 写着 `--prompts <json>`，**代码里从未实现**（`prompts = FIXTURES` 无条件），
+# 于是「换一本书跑盲测」会**静默地**拿内嵌的反脆弱册 fixture 出报告 —— 产出的是**另一本书的证据**。
+# 修法：① 真实现 --prompts；② 词表语料必须由 --skills-root 显式给出并与 prompts 同批（否则拒跑）；
+#       ③ 输出目录 --out（不再写死在工具目录，避免污染脚本同步/打包新鲜度闸）；④ 语料来源写进产物。
+def parse_args():
+    a = sys.argv[1:]
+    out = {}
+    for k in ('--prompts', '--skills-root', '--out'):
+        if k in a:
+            i = a.index(k) + 1
+            if i >= len(a):
+                sys.exit('🔴 %s 缺少取值' % k)
+            out[k[2:].replace('-', '_')] = a[i]
+    return out
+
+
+def build_lexicons_from_root(root):
+    lex = {}
+    if not os.path.isdir(root):
+        sys.exit('🔴 --skills-root 不是目录：%s' % root)
+    for slug in sorted(os.listdir(root)):
+        p = os.path.join(root, slug, 'SKILL.md')
+        if os.path.isfile(p):
+            lex[slug] = extract_lexicon(read_description(p))
+    return lex
+
+
+def load_prompts(path):
+    if not os.path.isfile(path):
+        sys.exit('🔴 --prompts 文件不存在：%s' % path)
+    d = json.load(open(path, encoding='utf-8'))
+    if isinstance(d, dict):
+        for k in ('probes', 'prompts', 'rows', 'items', 'cases'):
+            if isinstance(d.get(k), list):
+                d = d[k]
+                break
+    if not isinstance(d, list) or not d:
+        sys.exit('🔴 --prompts 无可用条目（%s）：期望顶级数组或含 probes/prompts/rows 的对象' % path)
+    out = []
+    for it in d:
+        if not isinstance(it, dict) or not str(it.get('prompt', '')).strip():
+            sys.exit('🔴 --prompts 条目缺 prompt 字段：%r' % (it,))
+        it = dict(it)
+        it.setdefault('id', '?')
+        # 目标件别名（A-37）：本库 test-prompts 用 expect_top1／owner_skill，投资册用 target
+        if not it.get('target'):
+            it['target'] = it.get('expect_top1') or it.get('owner_skill')
+        it.setdefault('judge_class', 'unknown')
+        out.append(it)
+    return out
+
+
+def judge_prompt(prompt, lexicons):
+    red = [w for w in REDLINE if w in prompt]
+    scores = {}
+    hits = {}
+    for slug, toks in lexicons.items():
+        got = [t for t in toks if t in prompt]
+        hits[slug] = got
+        scores[slug] = len(got)
+    best = max(scores.values()) if scores else 0
+    tops = [s for s, v in scores.items() if v > 0]
+    if best > 0:
+        second = sorted(scores.values(), reverse=True)[1] if len(scores) > 1 else 0
+        rivals = [s for s in tops if s != (tops[0] if tops else None) and scores[s] >= best * 0.6] if tops else []
+    else:
+        rivals = []
+    tie = best > 0 and any(s != (tops[0] if tops else None) and scores[s] == best for s in tops)
+    if red:
+        verdict = "redline-decline"
+        needs_llm = False  # 判停本身机器即可给（红灯），语义复核可选
+    elif best == 0:
+        verdict = "no-lexicon-hit"
+        needs_llm = True
+    elif tie:
+        verdict = "weak-or-ambiguous"
+        needs_llm = True
+    else:
+        verdict = "mechanical-clear"
+        needs_llm = False
+    return {
+        "redline_hits": red,
+        "scores": {k: v for k, v in sorted(scores.items(), key=lambda kv: -kv[1]) if v > 0},
+        "best": best, "top": tops[0] if tops else None,
+        "rivals": rivals, "verdict": verdict, "needs_llm": needs_llm,
+    }
+
+
+def main():
+    args = parse_args()
+    if bool(args.get('prompts')) != bool(args.get('skills_root')):
+        sys.exit('🔴 --prompts 与 --skills-root 必须成对给出（A-37：只给 prompts ⇒ 词表仍取自**内嵌的另'
+                 '一本书**语料，会静默产出跨书假证据）')
+    if args.get('prompts'):
+        prompts = load_prompts(args['prompts'])
+        psrc = args['prompts']
+        lexicons = build_lexicons_from_root(args['skills_root'])
+        lsrc = args['skills_root']
+        if not lexicons:
+            sys.exit('🔴 --skills-root 下未找到任何 <slug>/SKILL.md：%s' % lsrc)
+        targets = {p['target'] for p in prompts if p.get('target')}
+        miss = sorted(targets - set(lexicons))
+        if miss:
+            sys.exit('🔴 prompts 的 target 不在词表语料内：%s ⇒ **语料不匹配**（A-37），拒绝产出'
+                     '（词表语料：%s）' % (miss, sorted(lexicons)[:8]))
+    else:
+        prompts, psrc = FIXTURES, '内嵌 fixture（反脆弱册 AD/OC 12 题）'
+        lexicons, lsrc = build_lexicons(), '内嵌 BOOKS（投资蒸馏三册）'
+    outdir = args.get('out') or HERE
+    if not os.path.isdir(outdir):
+        sys.exit('🔴 --out 不是目录：%s' % outdir)
+    print('# 语料来源：prompts=%s ｜ 词表=%s ｜ 共 %d 题' % (psrc, lsrc, len(prompts)))
+    print('# ⚠ 红线词表口径：内嵌 REDLINE＝**投资域（时点预测）**专用；'
+          + ('本次为**外域语料**，判停红线须另备域内词表（本域用 tools/blindtest_generic.py），'
+             '本行的 redline 计数**不得**当作判停结论。' if args.get('prompts') else '内嵌 fixture 同域，可用。'))
+    rows = []
+    for fx in prompts:
+        r = judge_prompt(fx["prompt"], lexicons)
+        r.update({"id": fx["id"], "target": fx["target"], "judge_class": fx["judge_class"],
+                  "prompt": fx["prompt"]})
+        rows.append(r)
+    stats = {
+        "total": len(rows),
+        "judge_clear": sum(1 for r in rows if r["judge_class"] == "clear"),
+        "judge_boundary": sum(1 for r in rows if r["judge_class"] == "boundary"),
+        "judge_decline": sum(1 for r in rows if r["judge_class"] == "decline"),
+        "machine_mechanical_clear": sum(1 for r in rows if r["verdict"] == "mechanical-clear"),
+        "machine_needs_llm": sum(1 for r in rows if r["needs_llm"]),
+        "machine_redline": sum(1 for r in rows if r["verdict"] == "redline-decline"),
+        "top_is_target": sum(1 for r in rows if r["top"] == r["target"] and r["top"] is not None),
+    }
+    out = {"schema": "blindtest-lexicon-mock-v1", "prompt_source": psrc, "lexicon_root": lsrc,
+           "lexicon_sizes": {k: len(v) for k, v in lexicons.items()},
+           "rows": rows, "stats": stats}
+    with open(os.path.join(outdir, "blindtest-mock-v1.json"), "w", encoding="utf-8") as f:
+        json.dump(out, f, ensure_ascii=False, indent=2)
+    # ---- md ----
+    L = []
+    A = L.append
+    A("# 盲测闸 词表命中模拟器 v1 —— 机器初判（%d 题）" % len(rows))
+    A("")
+    A("> 语料来源：prompts=`%s` ｜ 词表=`%s`" % (psrc, lsrc))
+    A("> 角色：盲测 LLM judge 的机器初判层（词表命中，零 LLM）")
+    A("")
+    A("## 一、语料与词表")
+    A("")
+    A("%d 个候选 skill 的 description 词表（触发词段自动提取）；词表规模：" % len(lexicons)
+      + "，".join("%s=%d" % (k, len(v)) for k, v in sorted(lexicons.items())))
+    A("")
+    A("## 二、%d 条初判结果" % len(rows))
+    A("")
+    A("| id | judge 类 | 初判 verdict | needs_llm | top1(命中数) | 邻族风险 |")
+    A("|---|---|---|---|---|---|")
+    for r in rows:
+        top_txt = (r["top"] + "(" + str(r["scores"].get(r["top"], 0)) + ")") if r["top"] else "—"
+        rival_txt = ",".join(r["rivals"]) if r["rivals"] else "—"
+        A("| %s | %s | %s | %s | %s | %s |" % (r["id"], r["judge_class"], r["verdict"], r["needs_llm"], top_txt, rival_txt))
+    A("")
+    A("## 三、统计")
+    A("")
+    A("| 项 | 值 |")
+    A("|---|---|")
+    _nd = sum(1 for r in rows if r["judge_class"] == "decline")
+    A("| 机器机械可判（mechanical-clear） | %d/%d |" % (stats["machine_mechanical_clear"], len(rows)))
+    A("| 机器判 需 LLM | %d/%d（无词表锚/弱命中/邻族竞合） |" % (stats["machine_needs_llm"], len(rows)))
+    A("| 判停红线机器命中 | %d/%d（judge_class=decline 的题） |" % (stats["machine_redline"], _nd))
+    A("| 词表 top1 = 期望目标技能 | %d/%d |" % (stats["top_is_target"], len(rows)))
+    A("")
+    A("## 四、结论（v1 数据）")
+    A("")
+    A("- 机器初判层的价值=先筛：机械可判的路由（verdict=mechanical-clear 且 top1=目标）可免 LLM；其余（无锚/弱锚/邻族抢单）才进 LLM 语义判定，输入从 12 条全量降到 needs_llm 子集。")
+    A("- 与 judge 盲测报告的印证与差异：AD-3/OC-5 无（弱）字面锚 → needs_llm（与报告边界结论一致）；OC-4 现词表已含 重仓/回测/年年正收益/历史数据（报告改进建议 1 已落地）→ 机器机械命中；AD-4「值不值得追」与触发词「值不值得追新」差一字漏字面命中（词元化留 v2）。")
+    A("- 已知缺口（v2 候选）：词表只取 description 触发词段，未用 何时用/何时不用 语义区；同义改写（保健品/体检 vs 过度保护）命中不了；判停红线目前只覆盖时点类。")
+    A("")
+    md = "\n".join(L)
+    md_path = os.path.join(outdir, "盲测词表模拟器v1-试点报告.md")
+    with open(md_path, "w", encoding="utf-8") as f:
+        f.write(md)
+    print(json.dumps(stats, ensure_ascii=False))
+    for r in rows:
+        print("%s %-7s %-20s llm=%-5s top=%s" % (r["id"], r["judge_class"], r["verdict"], r["needs_llm"], (r["top"] or "—")[:26]))
+    print("md ->", md_path)
+
+
+if __name__ == "__main__":
+    main()

package/scripts/defense3_impersonation_scan.py

@@ -0,0 +1,199 @@
+# -*- coding: utf-8 -*-
+"""试点 B · 防线3〔操作层〕冒充扫描 v1（零 LLM 本地 py）
+
+判定对象：SKILL.md 正文中 R 段之外（I/A1/A2/E/B/数据指引）把压缩转述或整句原文
+用全角/ASCII 引号包起来并紧邻〔页锚〕的行——这类行会冒充作者原话（fidelity 报告的
+O1/O3 判据）。启发式（仿 judge 报告口径）：
+- 规则1 引号数数：逐行统计全角引号字符数与引号内运行段；
+- 规则2 整句嫌疑：引号内运行段 长度>=20 字；或 长度>=12 且含句读（，,、。；;）
+      且引号后 ≤32 字窗口内出现〔…（p页）〕页锚（v2 从 22 放宽，覆盖 judge ▲旁注样本）；
+- 规则3 转述豁免（v2 口径=judge ▲旁注口径）：仅 引号前窗口(14 字)或引号内容 出现 原文意/转述/压缩/非逐字/词级/短语级 等标记才豁免；后置标签（如 洁食句后挂“ca15 压缩转述”）不再豁免，按 judge 记“未标注”处理为候选；
+- 范围排除：R 段（作者原话合法引文）、E-示例/最小交付、块引用（>）与 frontmatter。
+
+验收（试点 B 召回率）：
+- rse 历史修复清单 3 处（fidelity-check-rse-v2.md 修复清单①-③）应全部命中；
+- trv 独立报告 O3 明示 25+ 字长引号紧邻页锚 0 命中 → 现场文件应 0 候选（无假阳）；
+- rse v2-verify 后现场应 0 候选（▲旁注洁食句按带 压缩转述 标签计，边界见报告）。
+
+用法：
+  python defense3_impersonation_scan.py <SKILL.md> [更多 SKILL.md ...]
+  python defense3_impersonation_scan.py --selftest
+输出：stdout JSON 摘要；文件落盘用 runner（pilotB_def3_runner.py）
+"""
+import os
+import re
+import sys
+import json
+
+MARKERS = ["原文意", "转述", "压缩", "非逐字", "非原话", "省略改写", "词级", "短语级",
+           "术语", "同构", "自述", "见原文", "非作者", "非实时判断"]
+PUNCT = "，,、。；;？?！!：:"
+OPENERS = [("“", "”"), ("「", "」"), ("\"", "\"")]
+
+
+def quote_char_count(line):
+    return sum(1 for ch in line if ch in "“”「」")
+
+
+# ⚠ 自伤 A-38（2026-09-13 · 由独立判官指出后自查确证）：
+#   旧实现把"页锚"硬编码为投资线的 `（p数字）` 形态（`has_page_anchor` 找 `（p`；
+#   `tight_trail` 要求窗口内同时出现 `〔` 与 `（p`）。本线（书籍蒸馏）的锚写作
+#   `【Barkley 第2章, PDF p306】`，**一个都不匹配** ⇒ 每条引文一律被判"引号后无紧邻页锚"
+#   ⇒ **suspects 恒为 0，与内容无关**（＝恒空转的闸，不是已通过的闸）。
+#   修法：锚形态表化（含本线形态）＋ 正样本对照（见 selftest 的 `PDF p` 用例）。
+ANCHOR_PATTERNS = [
+    r'〔[^〕]{0,40}（p\s*\d',        # 投资线：〔…（p7）〕
+    r'【[^】]{0,80}PDF\s*p\s*\d',    # 书籍线：【Barkley 第2章, PDF p306】
+    r'\[[^\]]{0,80}PDF\s*p\s*\d',   # 变体：[bark PDF p84]
+]
+
+
+def has_page_anchor(line):
+    for pat in ANCHOR_PATTERNS:
+        if re.search(pat, line):
+            return True
+    i = line.find("（p")
+    if i < 0:
+        return False
+    j = i + 2
+    while j < len(line) and (line[j].isdigit() or line[j] in "-–~，"):
+        j += 1
+    return any(c.isdigit() for c in line[i:j])
+
+
+def anchor_in_window(ln, start, width):
+    """引号之后 width 字窗口内是否出现任一形态的页锚（A-38 修：形态表化，不再写死 `〔…（p）〕`）。"""
+    win = ln[start:start + width]
+    return has_page_anchor(win)
+
+
+def quoted_runs(line):
+    """抽取引号对内的运行段（支持嵌套一层：外层 「」 或 “”，ASCII 双引号）。"""
+    runs = []
+    i = 0
+    while i < len(line):
+        hit = None
+        for o, c in OPENERS:
+            k = line.find(o, i)
+            if k >= 0 and (hit is None or k < hit[0]):
+                hit = (k, o, c)
+        if hit is None:
+            break
+        k, o, c = hit
+        # 跳过成对单引号里的撇号干扰：ASCII 双引号内部不再当开引号
+        e = line.find(c, k + 1)
+        if e < 0:
+            break
+        content = line[k + 1:e]
+        runs.append({"text": content, "start": k, "end": e, "open": o})
+        i = e + 1
+    return runs
+
+
+def marked(seg):
+    return any(m in seg for m in MARKERS)
+
+
+def scan_line(ln, body, heading):
+    """body=False 表示该行处于排除范围。返回记录列表。"""
+    recs = []
+    qcount = quote_char_count(ln)
+    anchor = has_page_anchor(ln)
+    for run in quoted_runs(ln):
+        txt = run["text"]
+        if len(txt) < 4:
+            continue
+        n = len(txt)
+        punct = any(ch in txt for ch in PUNCT)
+        before = ln[max(0, run["start"] - 14):run["start"]]
+        labeled = marked(before) or marked(txt[:40])   # v2：后置标签不计（judge ▲旁注口径）
+        win_start = run["end"] + 1
+        tight_trail = anchor_in_window(ln, win_start, 80)
+        suspect = body and tight_trail and not labeled and ((n >= 20) or (n >= 12 and punct))
+        recs.append({
+            "quote": txt[:80], "quote_len": n, "punct": punct, "labeled": labeled,
+            "anchor": anchor, "tight_trail": tight_trail, "suspect": suspect, "qcount": qcount,
+            "near": "标注豁免" if labeled else ("引号后无紧邻页锚" if not tight_trail else "命中"),
+        })
+    return recs
+
+
+def is_excluded_line(ln, heading):
+    s = ln.lstrip()
+    if s.startswith(">"):
+        return True
+    if s.startswith("|") or s.startswith("-") and "反例" in heading and len(s) < 60:
+        return False
+    if heading.startswith("## R"):
+        return True
+    if heading.startswith("### E-示例") or heading.startswith("### 最小交付"):
+        return True
+    if ln.startswith("description:") or ln.startswith("---"):
+        return True
+    return False
+
+
+def scan_file(path):
+    with open(path, encoding="utf-8") as f:
+        lines = f.read().splitlines()
+    heading = ""
+    body_lines = 0
+    suspects = []
+    stats = {"quote_lines": 0, "labeled_runs": 0}
+    for idx, ln in enumerate(lines):
+        if ln.startswith("#"):
+            heading = ln
+        if is_excluded_line(ln, heading):
+            continue
+        body_lines += 1
+        recs = scan_line(ln, True, heading)
+        if recs:
+            stats["quote_lines"] += 1
+        for r in recs:
+            if r["labeled"]:
+                stats["labeled_runs"] += 1
+            if r["suspect"]:
+                suspects.append({"line": idx + 1, "text": ln.strip()[:160], **r})
+    return {"file": os.path.abspath(path), "body_lines": body_lines, "stats": stats,
+            "suspects": suspects, "total_lines": len(lines)}
+
+
+def selftest():
+    """召回样本：通用无版权示例（原样本含书籍原文片段，已替换为通用示例以规避版权；测试结构不变，如需原语料请自取原书）。"""
+    cases = [
+        ("示例-修复清单①（应命中）", "他分文未掏，反称这事儿要怪“机构没事儿大把赚钱、出事儿他说怪运气”（见 ca04〔示例·某案例（p1）〕）", True),
+        ("示例-修复清单②（应命中）", "「只做短期动作，等周期快结束就离场、每 5 年换一个策略」〔示例·同节（p2）〕", True),
+        ("示例-修复清单③（应命中）", "“不是提供好产品，而是没被某群体否决”〔第2章·否决（p3）〕", True),
+        ("示例-原文意标注（应豁免）", "某公司的成功不在提供优质产品，而在没有被某群体否决（原文意：成功靠“没有被某群体否决”，见 ca16〔示例·否决（p3）〕）", False),
+        ("示例-词级短引（应豁免）", "若某方案“98% 置信度安全”适用于个体重复暴露（〔示例·重复风险（p4-5）〕）", False),
+        ("示例-带引号后置标签（应命中）", "“某群体绝不吃某种食物、非某群体吃得下”（ca15 压缩转述，〔示例·某案例（p6）〕）", True),
+        ("示例-短术语引+页锚（应豁免）", "“平均值掩盖了深度差异”＝均值安全掩盖路径上的深坑（R·〔p7〕）", False),
+        # ---- A-38 正样本对照：书籍线锚形态 `【… PDF pNNN】` 必须被认作页锚 ----
+        ("PDF锚-长引+紧邻锚（应命中）", "作者写道：“必须把规则列成一张清单并且不许有讨价还价余地的做法”【Barkley 第14章, PDF p306】", True),
+        ("PDF锚-转述标注（应豁免）", "该主张为压缩转述：“结束谈话时别把话说死”（转述，【Barkley 第10章, PDF p229】）", False),
+        ("PDF锚-短术语（应豁免）", "“执行功能”一词【Barkley 第2章, PDF p85】", False),
+    ]
+    results = []
+    for name, text, expect in cases:
+        recs = scan_line(text, True, "## 测试")
+        got = any(r["suspect"] for r in recs)
+        results.append({"case": name, "expect_hit": expect, "got_hit": got,
+                        "pass": got == expect, "recs": recs})
+    return results
+
+
+def main():
+    if "--selftest" in sys.argv:
+        out = {"mode": "selftest", "results": selftest()}
+        print(json.dumps(out, ensure_ascii=False, indent=2))
+        return
+    paths = [p for p in sys.argv[1:] if os.path.isfile(p)]
+    if not paths:
+        print(__doc__)
+        sys.exit(2)
+    res = [scan_file(p) for p in paths]
+    print(json.dumps({"mode": "scan", "files": res}, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

package/scripts/machine_layer_readycheck.py

@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+"""machine_layer_readycheck v1（v3.1 · 负样本校准版）
+
+作用：§13 机器层适用性前置检查的落地脚本。
+设计修正（负样本启发）：不再用“固定四项(candidates 五池/quote-precheck)”一刀切，
+改为 按闸最小输入 判定——机器层各闸只需其自身所需的最小机器输入，
+塔勒布式家族资产(candidates 池/quote-precheck)视为可选强化而非适用前提。
+
+每闸适用条件：
+  blind-lexicon : SKILL description 含 何时用/触发词 任一标记
+  defense3     : SKILL 含 R 段且正文存在「」或引号引用形态（冒充扫描输入）
+  darwin       : SKILL 含 R/I/E/B 分节 + description（机器初评输入）
+  fidelity-R   : 册根存在可核对原文(parts/*.md 或 ocr 等)且 SKILL R 段非空
+用法: python machine_layer_readycheck.py <SKILL.md> <bookbase> [--json out.json]
+"""
+import os, re, sys, json
+
+def check(skill_path, bookbase):
+    text = open(skill_path, encoding="utf-8").read()
+    meta_ok = ("何时用" in text[:2000]) or ("触发词" in text[:2000])
+    has_R = re.search(r"^##\s*R", text, re.M) is not None
+    has_I = re.search(r"^##\s*I", text, re.M) is not None
+    has_E = re.search(r"^##\s*E", text, re.M) is not None
+    has_B = re.search(r"^##\s*B", text, re.M) is not None
+    quotes = "「" in text or "“" in text
+    # fidelity 源：册根 parts/ocr 等
+    srcs = []
+    # v0.2b：优先只取 <bookbase>/parts/ 下的正文源；并排除 *check* 等副本目录（原版把 parts-check 也计入 → 页数翻倍）
+    pref = os.path.join(bookbase, "parts") if bookbase else ""
+    if pref and os.path.isdir(pref):
+        for fn in sorted(os.listdir(pref)):
+            if fn.endswith((".md", ".txt")):
+                srcs.append(os.path.join(pref, fn))
+    elif os.path.isdir(bookbase):
+        for root, dirs, files in os.walk(bookbase):
+            if any(k in os.path.basename(root).lower() for k in ("check", "backup", "backups")):
+                continue
+            for fn in files:
+                if fn.endswith((".md", ".txt")) and ("part" in fn.lower() or "ocr" in fn.lower() or "ch" in fn.lower()):
+                    srcs.append(os.path.join(root, fn))
+    r_quotes = len(re.findall(r"「[^」]+」", text.split("## I")[0] if "## I" in text else text))
+    # v0.2（M7）：原版本闸只给 True/False 与 missing=[]，属**自证式清单**、无可核计数。
+    # 现为每闸输出**可核计数**（desc 长度/触发词数、R 段条数、引号与页锚计数、原文页数、步骤与 CHECKPOINT 数），
+    # 并在结论中明确“本检查只判最小输入齐备度，不替代任何真实闸”。
+    _desc = re.search(r'^description:\s*[|"\'](.*?)(?:"\s*$|\n\S)', text, re.M | re.S)
+    _desc_txt = _desc.group(1) if _desc else ""
+    n_pages = 0
+    for _sp in srcs:
+        try:
+            n_pages += len(re.findall(r"=====\s*\[PAGE \d+\]\s*=====", open(_sp, encoding="utf-8").read()))
+        except Exception:
+            pass
+    counts = {
+        "desc_chars": len(_desc_txt),
+        "trigger_keywords": len(re.findall(r"[、，/／]", _desc_txt[_desc_txt.find("触发词"):])) if "触发词" in _desc_txt else 0,
+        "R_quote_lines": len(re.findall(r"^\s*-\s*(?:R\d+|「)", text, re.M)),
+        "quote_pairs": len(re.findall(r"「[^」]{4,}」", text)),
+        "page_anchors": len(re.findall(r"〔p\d+", text)),
+        "source_md_files": len(srcs), "source_pages": n_pages,
+        "E_steps": len(set(re.findall(r"步骤\s*(\d)", text))),
+        "checkpoints": len(re.findall(r"CHECKPOINT", text)),
+    }
+
+    def _g(applicable, missing, note):
+        return {"applicable": bool(applicable), "missing": [] if applicable else missing,
+                "input_note": note, "counts": counts}
+
+    gates = {
+        "blind-lexicon": _g(meta_ok, ["description 缺 何时用/触发词 标记"], "词表取自 description（desc 长度与触发词数见 counts）"),
+        "defense3": _g(has_R and quotes, ["无 R 段或无引号引用形态"], "冒充扫描需 R 段边界与引号/页锚形态（R 行数与引号对见 counts）"),
+        "darwin": _g(has_R and has_I and has_E and has_B, ["缺 R/I/E/B 分节之一"], "9 维初评需 RIA 分节与 description"),
+        "fidelity-R": _g(bool(srcs) and has_R and r_quotes > 0,
+                         ([] if srcs else ["册根无可核对原文(parts/ocr)"]) + ([] if r_quotes > 0 else ["R 段无引文"]),
+                         "R 引文逐字需册根原文（源文件数与页标记数见 counts）"),
+    }
+    return {"skill": os.path.abspath(skill_path), "bookbase": os.path.abspath(bookbase) if bookbase else None,
+            "gates": gates, "counts": counts,
+            "recommendation": ("machine-ok（四闸最小输入齐备；**本检查只判最小输入齐备度，不替代任何真实闸**）"
+                               if all(g["applicable"] for g in gates.values())
+                               else "partial-degrade（不适用闸按 v2.3 全 LLM 并标 pending；其余闸照跑机器层）"),
+            "method_note": "v0.2（M7 修正）：由‘清单式自证’升级为**可核计数**（desc/R/引号/页锚/原文源与页数/步骤/检查点），计数随本文件落盘可复核。"}
+
+def main():
+    if len(sys.argv) < 3:
+        print(__doc__); sys.exit(2)
+    res = check(sys.argv[1], sys.argv[2])
+    if "--json" in sys.argv:
+        out = sys.argv[sys.argv.index("--json") + 1]
+        json.dump(res, open(out, "w", encoding="utf-8"), ensure_ascii=False, indent=1)
+    print(json.dumps(res, ensure_ascii=False, indent=1))
+
+if __name__ == "__main__":
+    main()