@furongjun1999/dsh-memory 0.4.11 → 0.5.1

package/md_cg/bench_zh_mad.py

@@ -1,602 +1,602 @@
-# -*- coding: utf-8 -*-
-"""中文多维探针（MAD, multi-axis）——20 条「中文层 + 英文原文」语料，Rust 侧四路检索。
-
-与既有 zh_probe 探针的关系：前一版探针只测「中文层做索引」的单点效果；本探针
-把写入侧加工拆成可消融的四个维度，逐一叠加，看每一步对检索指标的边际贡献：
-
-  轴 1 实体规范化  —— 全库 df 聚合出的 canonical 词 + 人物/地点/时间 → tags（entity 路）
-  轴 2 指代消解    —— **仅当本条自身无实体**时承接**前一条自身**的 canonical（保守附加）
-  轴 3 意图抽象    —— 摘要 → 规范意图类目；类目 + 动词原形 → tags，类目 → 正文子功能行
-  轴 4 关系图遍历  —— 人物/事件/时间/身份/地点/条件 多维关系 → edges（graph 路）
-
-首轮五臂实测出现三项反直觉负增益，经取证判定为**实现/口径缺陷**而非能力缺陷
-（结论已归档灵枢记忆；本段为修正说明）：
-  * 轴2 原实现无条件承接，且 `last_canon = cur`（含继承）单调累积 → tags 退化为
-    「历史全集」，后段条目对任何查询都命中 entity 路（-15~-20pp）。本文件已改为
-    规格语义；修正后本探针集**无「自身无实体」条目 → 该轴未激活**（`承接条数=0`）。
-  * 轴3 原产出是摘要切片（非抽象），且只进正文、只喂词法路；RRF 按**名次**融合，
-    该行只改变 jaccard 分母不改名次 → 边际恒 0。本文件已改为规范类目 + tags 通道。
-  * 轴4 `_path_graph` 契约要求「种子已排序」，但 `_lexical` 在 LIKE 命中
-    ≤ `GLOBAL_CAP`(500) 时返回**未排序**列表 → seeds[:5] 退化为索引枚举序前 5 条，
-    图路对多题注入同一恒定集合。`run_seed_control` 用于隔离该口径缺陷。
-
-数据源（**全部既有真源，零新增标注**）：
-  * data/external/zh_probe/manual_zh.json          20 条 gold turn 的中文层（既有产物）
-  * data/external/zh_probe/manual_q.json           20 条中文查询
-  * data/external/longmemeval/lme_s_haystack.jsonl 英文原文（按 id 取）
-  * data/external/longmemeval/lme_s_questions.jsonl qid → qtype / evidence_turns
-
-诚实条款（报告必须原样声明）：
-  * 中文层与查询均为**既有产物**（非本次生成），本脚本不改一字，只做结构解析；
-  * 写入侧加工是**确定性纯规则**（零 LLM、零第三方依赖、同输入必同输出），
-    词表随源码公开，第三方可重放；
-  * 加工**盲于查询集**：canonical 判定只用全库 df 与中文层自身字段，
-    不读 manual_q.json 的任何内容——否则即数据泄漏，评测作废；
-  * 池仅 20 条 → 随机基线 hit@1 = 5%，单项能力 ±1 题即 ±5 个百分点。
-    结论只能作**方向性证据**，不可作定量结论。
-"""
-import json
-import os
-import re
-import sys
-
-HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-# 本脚本既可能被当脚本跑（sys.path[0] 是 md_cg/），也可能被当包内模块导入
-for _p in (HERE, os.path.join(HERE, "md_cg")):
-    if _p not in sys.path:
-        sys.path.insert(0, _p)
-
-EXT = os.path.join(HERE, "data", "external")
-ZP = os.path.join(EXT, "zh_probe")
-LM = os.path.join(EXT, "longmemeval")
-
-MANUAL_ZH = os.path.join(ZP, "manual_zh.json")
-MANUAL_Q = os.path.join(ZP, "manual_q.json")
-LM_H = os.path.join(LM, "lme_s_haystack.jsonl")
-LM_Q = os.path.join(LM, "lme_s_questions.jsonl")
-
-CORPUS20 = os.path.join(ZP, "corpus20.jsonl")
-QUESTIONS20 = os.path.join(ZP, "questions20.jsonl")
-
-# 关系轴：用户裁决「条件链 + 人物/事件/时间/身份/地点都可以作为关系」
-AXES = ("person", "event", "time", "identity", "place", "condition")
-
-
-# 生效条件：path 以 UTF-8 打开后逐行读取，仅 strip 后非空的行经 json.loads 产出，空白行被跳过。
-def iter_jsonl(path):
-    with open(path, encoding="utf-8") as f:
-        for line in f:
-            line = line.strip()
-            if line:
-                yield json.loads(line)
-
-
-# 生效条件：path 以 UTF-8 打开成功时返回 json.load(f) 的解析结果，片段内无其它分支。
-def load_json(path):
-    with open(path, encoding="utf-8") as f:
-        return json.load(f)
-
-
-# 生效条件：raw 经 str() 后按“；”切分，仅含“=”的段被解析，其中键为身份/时间/摘要时写对应槽位、键为条件时按“|”与“:”写入 condition、键为词时按“,”拆出非空项写入 terms，其它键或未出现的槽位保持 out 的默认空值。
-def parse_zh(raw):
-    """中文层串 → 槽位 dict。
-
-    格式（manual_zh.json 既有形态，本函数只解析不改写）：
-        身份=用户；时间=2023/05/24 04:49；摘要=…；
-        条件=观测位置:会话陈述|观测工具:会话记录|时间窗口:2023-05-24|存在约束:公开；
-        词=礼物,礼物清单,场合
-    """
-    out = {"identity": "", "time": "", "summary": "", "condition": {},
-           "terms": []}
-    for seg in str(raw).split("；"):
-        seg = seg.strip()
-        if not seg or "=" not in seg:
-            continue
-        key, val = seg.split("=", 1)
-        key, val = key.strip(), val.strip()
-        if key == "身份":
-            out["identity"] = val
-        elif key == "时间":
-            out["time"] = val
-        elif key == "摘要":
-            out["summary"] = val
-        elif key == "条件":
-            for kv in val.split("|"):
-                if ":" in kv:
-                    k, v = kv.split(":", 1)
-                    out["condition"][k.strip()] = v.strip()
-        elif key == "词":
-            out["terms"] = [t.strip() for t in val.split(",") if t.strip()]
-    return out
-
-
-# 生效条件：当 MANUAL_ZH/MANUAL_Q/LM_Q/LM_H 可读取、hay 覆盖 want_ids 且 meta 含 man_q 全部 qid 时写出 CORPUS20/QUESTIONS20 并返回 (corpus, questions)，缺 turn 或 qid 分别 raise SystemExit，verbose（默认 True）为真值时额外打印统计、假值时静默。
-def prepare(verbose=True):
-    """生成 corpus20.jsonl 与 questions20.jsonl（幂等覆盖）。"""
-    man_zh = load_json(MANUAL_ZH)
-    man_q = load_json(MANUAL_Q)
-    meta = {r["qid"]: r for r in iter_jsonl(LM_Q)}
-    want_ids = set(man_zh)
-    hay = {}
-    for r in iter_jsonl(LM_H):
-        if r["id"] in want_ids:
-            hay[r["id"]] = r
-            if len(hay) == len(want_ids):
-                break
-
-    missing = want_ids - set(hay)
-    if missing:
-        raise SystemExit(f"[失败] haystack 缺以下 turn：{sorted(missing)}")
-
-    # corpus：按 turn id 的数值序（= 时间序），保证「承接前一条」有确定语义
-# 生效条件：tid 经 rsplit("t",1) 得到至少两段且最后一段可被 int() 解析时返回该整数，否则源码未做校验会抛错。
-    def turn_no(tid):
-        return int(tid.rsplit("t", 1)[1])
-
-    corpus = []
-    for tid in sorted(man_zh, key=turn_no):
-        t = hay[tid]
-        corpus.append({
-            "id": tid,
-            "text": str(t.get("text") or ""),
-            "speaker": str(t.get("speaker") or ""),
-            "date": str(t.get("date") or ""),
-            "zh": man_zh[tid],
-            "zh_fields": parse_zh(man_zh[tid]),
-        })
-
-    # questions：qid → 中文查询 + 证据（完整 evidence_turns，池里仅 ev0 存在）
-    questions = []
-    for qid, q in man_q.items():
-        m = meta.get(qid)
-        if m is None:
-            raise SystemExit(f"[失败] questions 缺 qid={qid}")
-        questions.append({
-            "qid": qid,
-            "qtype": m["qtype"],
-            "question": q,
-            "answer": str(m.get("answer") or ""),
-            "evidence_turns": list(m.get("evidence_turns") or []),
-        })
-
-    with open(CORPUS20, "w", encoding="utf-8") as f:
-        for r in corpus:
-            f.write(json.dumps(r, ensure_ascii=False) + "\n")
-    with open(QUESTIONS20, "w", encoding="utf-8") as f:
-        for r in questions:
-            f.write(json.dumps(r, ensure_ascii=False) + "\n")
-
-    if verbose:
-        print(f"语料 {len(corpus)} 条 → {CORPUS20}")
-        print(f"题库 {len(questions)} 条 → {QUESTIONS20}")
-        n_etype = {}
-        for q in questions:
-            n_etype[q["qtype"]] = n_etype.get(q["qtype"], 0) + 1
-        print("题型分布：" + ", ".join(f"{k}={v}" for k, v in sorted(n_etype.items())))
-    return corpus, questions
-
-
-# 生效条件：prepare(verbose=False) 返回 corpus/questions 后，对每题以 evidence_turns[0]（空则 ""）取 ev0，命中词限于 ev0 非空且词出现在 zh_of[ev0] 中，df1 收集池内 df==1 的词、all_df 收集 df==len(corpus) 的词，verbose（默认 True）为真值时打印后返回 per_q、为假值时直接返回 per_q。
-def analyze(verbose=True):
-    """诊断：查询词能否落到 gold 中文层 / 池内其他条目（决定各轴是否有可桥接的实体）。
-
-    只读既有产物，不修改任何语料。输出两类事实：
-      * 查询词在 gold 中文层的字面命中率 → 词法路的天花板；
-      * 查询词在**池内**的 df → 该词的判别力（df=1 是精确定位，df=20 则无信息量）。
-    """
-    corpus, questions = prepare(verbose=False)
-    zh_of = {c["id"]: c["zh"] for c in corpus}
-
-    per_q = []
-    for q in questions:
-        ev0 = q["evidence_turns"][0] if q["evidence_turns"] else ""
-        terms = [t for t in str(q["question"]).split() if t]
-        hit = [t for t in terms if ev0 and t in zh_of.get(ev0, "")]
-        globalish = [t for t in terms
-                     if sum(1 for c in corpus if t in zh_of[c["id"]]) == len(corpus)]
-        per_q.append({
-            "qid": q["qid"], "ev0": ev0, "qtype": q["qtype"],
-            "n_term": len(terms), "n_hit": len(hit),
-            "hit_terms": hit,
-            "df1": sorted({t for t in terms
-                           if sum(1 for c in corpus if t in zh_of[c["id"]]) == 1}),
-            "all_df": globalish,
-        })
-
-    if verbose:
-        print(f"\n== 查询词覆盖诊断（池 {len(corpus)} 条，题 {len(questions)} 道）==")
-        print(f"{'qid':<16}{'ev0':<12}{'词数':>5}{'命中':>5}  命中词")
-        print("-" * 72)
-        for r in per_q:
-            print(f"{r['qid']:<16}{r['ev0']:<12}{r['n_term']:>5}{r['n_hit']:>5}  "
-                  f"{','.join(r['hit_terms'])[:40]}")
-        tot_t = sum(r["n_term"] for r in per_q)
-        tot_h = sum(r["n_hit"] for r in per_q)
-        zero = [r["qid"] for r in per_q if r["n_hit"] == 0]
-        print("-" * 72)
-        print(f"合计：{tot_h}/{tot_t} 个查询词落在 gold 中文层"
-              f"（{tot_h / max(1, tot_t):.1%}）")
-        print(f"零重叠题（{len(zero)}）：{', '.join(zero) if zero else '无'}")
-        return per_q
-
-    return per_q
-
-
-# ---------------------------------------------------------------- 写入侧四轴
-# 全部为确定性纯规则：零 LLM、零外部依赖，同输入必同输出；词表随源码公开。
-# **盲于查询集**：以下规则只读 corpus20（语料）与中文层自身字段，从不打开 manual_q.json。
-
-STOP_ZH = frozenset(
-    "的 了 在 是 我 你 他 她 它 和 与 或 这 那 有 没 不 就 都 也 还 要 会 能 可以 "
-    "多少 什么 哪里 哪 怎么 为什么 几 一些 一个 之 其 与 及 等 被 把 给 对 从 到".split()
-)
-
-PERSON_HINTS = (
-    "妹妹", "姐姐", "哥哥", "弟弟", "妈妈", "爸爸", "母亲", "父亲", "父母", "奶奶",
-    "爷爷", "外婆", "外公", "同事", "朋友", "同学", "邻居", "老板", "上司", "教练",
-    "医生", "老师", "室友", "伴侣", "丈夫", "妻子", "儿子", "女儿", "叔叔", "阿姨",
-    "表亲", "未婚夫", "未婚妻",
-)
-
-PLACE_HINTS = (
-    "市", "州", "城", "镇", "岛", "公园", "中心", "大学", "海滩", "广场", "机场",
-    "河", "湖", "山", "街", "路", "区", "国家", "澳洲", "欧洲", "亚洲", "美洲",
-)
-
-EN_STOP = frozenset("""
-The A An And But Or For Nor So Yet This That These Those There Their They Them Then Than
-When What Where Which While Who Whom Whose Why How However Also Always Never Often Sometimes
-I You He She It We They Me Him Her Us My Your His Its Our Very Really Just Only Even Still
-Have Has Had Having Do Does Did Doing Be Been Being Am Is Are Was Were Will Would Shall
-Should Can Could May Might Must Not No Yes If In On At By To Of With From Into Onto Over
-Under Above Below Between During After Before About Around Because Since Until Upon While
-Monday Tuesday Wednesday Thursday Friday Saturday Sunday January February March April May
-June July August September October November December Today Yesterday Tomorrow Last Next
-New Old Good Bad Best Worst First Second Third One Two Three Four Five Six Seven Eight Nine
-Ten Okay Ok Well Thanks Thank Please Hi Hello Hey
-""".split())
-
-EN_NAME_RE = re.compile(r"\b[A-Z][a-z]{2,}(?:[ ][A-Z][a-z]{2,})*\b")
-DATE_RE = re.compile(r"(\d{4})[/-](\d{1,2})[/-](\d{1,2})")
-
-
-# 生效条件：DATE_RE.search(str(raw or "")) 有匹配时返回零填充的 YYYY-MM-DD，无匹配（含 raw 为假值回落成 ""）时返回 ""。
-def norm_time(raw):
-    """'2023/05/24 04:49' → '2023-05-24'（跨条目统一格式，使日期查询可命中）。"""
-    m = DATE_RE.search(str(raw or ""))
-    if not m:
-        return ""
-    y, mo, d = m.groups()
-    return f"{int(y):04d}-{int(mo):02d}-{int(d):02d}"
-
-
-# 生效条件：对 str(text or "") 用 EN_NAME_RE 扫描，匹配串按空白切分后任一部分命中 EN_STOP 即跳过，其余项按首次出现顺序去重加入 out 并返回；text 为假值时扫描空串返回 []。
-def en_names(text):
-    """英文原文中的专名候选（跨语言桥：中文查询里的英文专名可经 entity 路命中）。"""
-    out, seen = [], set()
-    for m in EN_NAME_RE.finditer(str(text or "")):
-        w = m.group(0)
-        if any(p in EN_STOP for p in w.split()):
-            continue
-        if w not in seen:
-            seen.add(w)
-            out.append(w)
-    return out
-
-
-# 生效条件：遍历 corpus，对每条记录的 zh_fields["terms"] 去重后逐词判断，词非空且不在 STOP_ZH 时使 df[词] 计数加一，返回 df。
-def build_tables(corpus):
-    """全库统计：# 词项 df（**只读语料**，与查询集无关）。"""
-    df = {}
-    for c in corpus:
-        for t in set(c["zh_fields"]["terms"]):
-            if t and t not in STOP_ZH:
-                df[t] = df.get(t, 0) + 1
-    return df
-
-
-# 生效条件：c 含 zh_fields（terms/condition/time/identity）且 df 为词到频次的映射时，返回 person/event/time/identity/place/condition 六轴取值字典。
-def axis_values(c, df):
-    """一条 turn 的六个关系轴取值（用户裁决：条件链 + 人物/事件/时间/身份/地点）。"""
-    f = c["zh_fields"]
-    terms = [t for t in f["terms"] if t and t not in STOP_ZH]
-    tw = norm_time(f["condition"].get("时间窗口") or f["time"])
-    person = [t for t in terms if any(h in t for h in PERSON_HINTS)]
-    place = [t for t in terms if any(h in t for h in PLACE_HINTS)]
-    event = [t for t in terms if df.get(t, 0) >= 2]
-    return {
-        "person": person,
-        "event": event,
-        "time": [tw] if tw else [],
-        "identity": [f["identity"]] if f["identity"] else [],
-        "place": place,
-        "condition": [f"{k}:{v}" for k, v in f["condition"].items()],
-    }
-
-
-# 意图类目：意图动词 → 规范类目（确定性词表，只读摘要，与查询集无关）
-INTENT_CLASSES = (
-    ("推荐", ("推荐", "建议", "咨询", "请教")),
-    ("购置", ("购买", "买", "挑选", "选购", "下单", "购买")),
-    ("整理", ("整理", "清理", "分类", "收纳", "归档")),
-    ("学习", ("学习", "了解", "阅读", "查阅", "研究")),
-    ("规划", ("计划", "安排", "准备", "制定")),
-    ("比较", ("比较", "对比", "估算", "计算")),
-    ("维修", ("维修", "修理", "更换", "保养")),
-    ("出行", ("旅行", "搬家", "搬迁", "游玩", "漂流")),
-    ("参加", ("参加", "报名", "出席")),
-    ("健身", ("锻炼", "跑步", "训练")),
-    ("取退", ("退还", "退回", "归还")),
-    ("完成", ("完成", "做完", "结课")),
-)
-
-
-# 生效条件：按 INTENT_CLASSES 顺序检查 c["zh_fields"]["summary"]，首个命中类目的首个包含于摘要的动词返回 (cls, v)，全不命中返回 ('', '')。
-def intent_of(c):
-    """意图抽象：摘要 → (规范类目, 命中的动词原形)。
-
-    规格要求「抽象」。原实现返回摘要切片 `f"{v}：" + summary[i-6:i+10]`——
-    那只是把原文再抄一遍：不产生任何新词、不构成类目，且只写进正文，
-    而正文只喂词法路、RRF 又只按**名次**融合（见 bench 报告），故边际恒为 0。
-    此处归一为固定类目，并保留命中的动词原形，二者一并进 tags（entity 路——
-    存在性匹配，不吃分数尺度），使该轴真正获得独立检索通道。
-    """
-    s = c["zh_fields"]["summary"]
-    for cls, verbs in INTENT_CLASSES:
-        for v in verbs:
-            if v in s:
-                return cls, v
-    return "", ""
-
-
-# 生效条件：把 c["zh_fields"]["terms"] 与 en_names(c["text"]) 逐项 strip 后跳过空串、STOP_ZH（原形或小写）及已见项去重入 out，再用 norm_time(条件.get("时间窗口") or c 的 time) 得到非空且未出现的时窗串追加；df 形参在该片段内未参与条件判断。
-def normalize_terms(c, df):
-    """实体规范化：去停用 + 去重 + 附时间规范式 + 附英文专名（跨语言对齐）。"""
-    f = c["zh_fields"]
-    out, seen = [], set()
-    for t in list(f["terms"]) + en_names(c["text"]):
-        t = t.strip()
-        if not t or t in STOP_ZH or t.lower() in STOP_ZH or t in seen:
-            continue
-        seen.add(t)
-        out.append(t)
-    tw = norm_time(f["condition"].get("时间窗口") or f["time"])
-    if tw and tw not in seen:
-        out.append(tw)
-    return out
-
-
-# 生效条件：遍历 corpus 并以 root=os.path.join(HERE, root_base or f"_md_cg_eval_zhprobe_{arm['name']}")（root_base 为 None/空串时回落）建库，graph 分支仅当 arm.get("graph") 为真且某轴取值的同值 id 数落在 [2, max_df]（默认 5）时为这些 id 两两建有向边，coref 仅当 arm.get("coref") 为真、本条 own 为空（own 只在 arm.get("norm") 为真时由 normalize_terms 生成，否则恒为 []）且 prev_own 非空时承接前一条自身 canonical，intent 分支仅当 arm.get("intent") 为真且 intent_of 返回 cls 非空时写意图行并把意图词与长度>=2 的动词加入 tags，verbose（默认 True）为真值时打印臂统计、root 已是目录时先整树删除再建 MdCGOS。
-def build_arm(corpus, arm, max_df=5, root_base=None, verbose=True):
-    """按消融臂建库。每臂一个独立 root，互不污染。
-
-    臂的差异**只体现在库内容**（正文/tags/edges），检索路固定
-    lexical+entity+graph——这样"能力未开"就等于"库内没有对应信息"，
-    归因干净：指标变化可直接归给该轴，而不是归给路开关。
-    """
-    from md_cg.mdcos import MdCGOS
-    root = os.path.join(HERE, root_base or f"_md_cg_eval_zhprobe_{arm['name']}")
-
-    df = build_tables(corpus)
-    axes = {c["id"]: axis_values(c, df) for c in corpus}
-
-    edges = {}
-    if arm.get("graph"):
-        for ax in AXES:
-            val2ids = {}
-            for c in corpus:
-                for v in axes[c["id"]][ax]:
-                    val2ids.setdefault(v, set()).add(c["id"])
-            for v, ids in val2ids.items():
-                if not (2 <= len(ids) <= max_df):
-                    continue  # df=1 无边；df>max_df 全连通，零信息量只注入噪声
-                for a in ids:
-                    for b in ids:
-                        if a != b:
-                            edges.setdefault(a, {})[b] = ax
-
-    if os.path.isdir(root):
-        import shutil
-        shutil.rmtree(root, ignore_errors=True)
-    cg = MdCGOS(root, autoflush=500)
-
-    prev_own = None  # 前一条**自身**的 canonical（不累积）
-    n_coref = 0
-    for c in corpus:
-        f = c["zh_fields"]
-        own = normalize_terms(c, df) if arm.get("norm") else []
-
-        # 轴2 指代消解（规格：保守附加）——**仅当本条自身无实体**时，
-        # 才承接**前一条自身**的 canonical。
-        # 原实现：`if coref and last_canon` 无条件承接，且 `last_canon = cur`
-        # 把「继承结果」也计入 → 单调累积成「历史全集」，tags 雪球污染。
-        inherit = []
-        if arm.get("coref") and not own and prev_own:
-            inherit = list(prev_own)
-            n_coref += 1
-
-        # 轴3 意图抽象：类目写正文（规格的「子功能行」），类目词 + 动词原形写 tags。
-        intent_terms = []
-        intent_line = ""
-        if arm.get("intent"):
-            cls, verb = intent_of(c)
-            if cls:
-                intent_line = f"意图：{cls}"
-                intent_terms = [f"意图:{cls}"] + ([verb] if len(verb) >= 2 else [])
-
-        body = [f"身份：{f['identity']}", f"时间：{f['time']}",
-                f"摘要：{f['summary']}", f"词：{','.join(f['terms'])}",
-                "条件：" + "|".join(f"{k}:{v}" for k, v in f["condition"].items())]
-        if intent_line:
-            body.append(intent_line)
-        if inherit:
-            body.append("承接：" + ",".join(inherit))
-        body.append("")
-        body.append(c["text"])
-
-        tags = own[:]
-        for t in intent_terms + inherit:
-            if t not in tags:
-                tags.append(t)
-
-        e = [{"target": t, "axis": a} for t, a in edges.get(c["id"], {}).items()]
-        cg.add(c["id"], "\n".join(body), layer="contextual", tags=tags,
-               edges=e, eval_src=f"zh_mad:{arm['name']}", verification_basis="data")
-
-        prev_own = own[:]
-
-    cg.flush()
-    if verbose:
-        n_e = sum(len(v) for v in edges.values())
-        print(f"  [{arm['name']}] root={os.path.basename(root)} "
-              f"tags_axis={'on' if arm.get('norm') else 'off'} "
-              f"coref={'on' if arm.get('coref') else 'off'} "
-              f"intent={'on' if arm.get('intent') else 'off'} "
-              f"graph={'on' if arm.get('graph') else 'off'} 有向边={n_e} "
-              f"承接条数={n_coref}")
-    return root
-
-
-ARMS = [
-    {"name": "a0_base", "norm": False, "coref": False, "intent": False, "graph": False},
-    {"name": "a1_norm", "norm": True, "coref": False, "intent": False, "graph": False},
-    {"name": "a2_coref", "norm": True, "coref": True, "intent": False, "graph": False},
-    {"name": "a3_intent", "norm": True, "coref": True, "intent": True, "graph": False},
-    {"name": "a4_graph", "norm": True, "coref": True, "intent": True, "graph": True},
-]
-
-
-# 生效条件：先执行 prepare(verbose=False) 取得 corpus，再对 ARMS 每臂以 max_df=max_df（默认 5，原样下传不做假值回落）调用 build_arm 并汇总为 roots 返回。
-def build_all(max_df=5):
-    corpus, _ = prepare(verbose=False)
-    print(f"== 建库（消融 {len(ARMS)} 臂，max_df={max_df}）==")
-    roots = {}
-    for arm in ARMS:
-        roots[arm["name"]] = build_arm(corpus, arm, max_df=max_df)
-    return roots
-
-
-RUST_BIN = os.path.join(HERE, "rust", "target", "release", "mdcg-eval.exe")
-ROW_RE = re.compile(
-    r"^\s*(precise|temporal|interference|reference)\s+(\d+)\s+"
-    r"([\d.]+)%\s+([\d.]+)%\s+([\d.]+)\s*$", re.M)
-GROUPS = ["precise", "temporal", "interference", "reference"]
-
-
-# 生效条件：os.path.exists(RUST_BIN) 为真时以 argv=[RUST_BIN,"--dataset","mad","--tag",name,"--lib",lib]（extra 为真值时追加 list(extra)）执行 subprocess，返回码非 0 或 ROW_RE 在 stdout 未匹配到任何组时 raise SystemExit，否则返回 {组:(n,hit@1,hit@5,MRR)}。
-def run_one(name, lib, extra=None):
-    """调用 **Rust 检索器** 跑一臂，返回 {组: (n, hit@1, hit@5, MRR)}。
-
-    命令执行走 subprocess argv 列表 + 显式 UTF-8 + PYTHONUTF8=1（不经 Windows shell），
-    规避 GBK 解码异常。
-    """
-    import subprocess
-
-    if not os.path.exists(RUST_BIN):
-        raise SystemExit(f"[失败] 未找到 Rust 评测器：{RUST_BIN}（先 cargo build --release）")
-    argv = [RUST_BIN, "--dataset", "mad", "--tag", name, "--lib", lib]
-    if extra:
-        argv += list(extra)
-    env = dict(os.environ, PYTHONUTF8="1")
-    p = subprocess.run(argv, capture_output=True, text=True,
-                       encoding="utf-8", errors="replace", env=env, cwd=HERE)
-    if p.returncode != 0:
-        raise SystemExit(f"[失败] {name}：{(p.stderr or '')[-900:]}")
-    got = {}
-    for m in ROW_RE.finditer(p.stdout):
-        g, n, h1, h5, mrr = m.groups()
-        got[g] = (int(n), float(h1), float(h5), float(mrr))
-    if not got:
-        raise SystemExit(f"[失败] {name}：未解析到组指标\n{p.stdout[-1200:]}")
-    return got
-
-
-# 生效条件：先打印 title 与表头，再遍历 rows 的 (label, got, note)，对 GROUPS 每组用 got[g] 取 (n,h1,h5,mrr) 并累计总体 hit@1/MRR，仅当 baseline 不为 None 且 label==baseline 时记 ref，仅当 ref 已记录且 label!=baseline 时输出 Δ。
-def print_table(title, rows, baseline=None):
-    """rows: [(label, got, note)]；baseline = 参照行 label（算 Δ）。"""
-    print(f"\n== {title} ==")
-    hdr = (f"{'臂':<14}" + "".join(f"{g[:12]:>15}" for g in GROUPS)
-           + f"{'总体hit@1':>12}{'总体MRR':>10}")
-    print(hdr)
-    print("-" * len(hdr))
-    ref = None
-    for label, got, note in rows:
-        cells, tot_h1, tot_n, tot_mrr = [], 0.0, 0, 0.0
-        for g in GROUPS:
-            n, h1, _h5, mrr = got[g]
-            cells.append(f"{h1:.0f}%/{mrr:.3f}")
-            tot_h1 += h1 / 100.0 * n
-            tot_n += n
-            tot_mrr += mrr * n
-        ov_h1 = tot_h1 / max(1, tot_n)
-        ov_mrr = tot_mrr / max(1, tot_n)
-        if baseline is not None and label == baseline:
-            ref = (ov_h1, ov_mrr)
-        delta = ""
-        if ref is not None and label != baseline:
-            delta = f"  (Δ{(ov_h1 - ref[0]) * 100:+.1f}pp)"
-        suffix = f"  {note}" if note else ""
-        print(f"{label:<14}" + "".join(f"{c:>15}" for c in cells)
-              + f"{ov_h1 * 100:>10.1f}%{ov_mrr:>10.3f}{delta}{suffix}")
-
-
-# 生效条件：对 ARMS 每臂以 lib=f"_md_cg_eval_zhprobe_{name}"、无 extra 调用 run_one 组成 rows，并以 ARMS[0]["name"] 为 baseline 调 print_table 后返回 rows。
-def run_ablation():
-    """消融主表：逐臂调用 Rust 检索器并汇总（种子口径 = 缺省，即生产现状）。"""
-    rows = []
-    for arm in ARMS:
-        name = arm["name"]
-        rows.append((name, run_one(name, f"_md_cg_eval_zhprobe_{name}"), ""))
-    print_table("消融主表（Rust 检索器，k=5，jaccard，证据命中；graph 种子=索引序）",
-                rows, baseline=ARMS[0]["name"])
-    print("\n随机基线 hit@1 = 5.0%（1/20）；池仅 20 条，±1 题 = ±5pp，"
-          "结论只作方向性证据。")
-    return rows
-
-
-# 生效条件：以最后一个臂 ARMS[-1]['name'] 对应的库路径，先无 extra 调 run_one("a4_index", lib)、再以 extra=("--graph-seeds","sorted") 调 run_one("a4_sorted", lib) 组成 rows，并以 baseline="a4/index" 调 print_table 后返回。
-def run_seed_control():
-    """对照：**同一个 a4 库**（写入侧与边结构完全相同），只切换 graph 路种子口径。
-
-    用于把 a4 相对 a3 的变化拆成两个因子：
-      * 边结构质量（本轴真正要测的能力）；
-      * `_path_graph`「种子须已排序」契约被违反 → seeds[:5] 退化为索引枚举序前 5。
-    """
-    lib = f"_md_cg_eval_zhprobe_{ARMS[-1]['name']}"
-    rows = [
-        ("a4/index", run_one("a4_index", lib), "现状：seeds=索引枚举序前 5"),
-        ("a4/sorted", run_one("a4_sorted", lib, ("--graph-seeds", "sorted")),
-         "文档语义：seeds=top-5 词法"),
-    ]
-    print_table("graph 种子口径对照（库内容完全相同，只换种子）", rows,
-                baseline="a4/index")
-    return rows
-
-
-# 生效条件：cmd 取 argv[1]（len(argv)<=1 时为 "prepare"），cmd=="prepare"/"analyze"/"build"/"run"/"seed-control" 分别调用 prepare/analyze/build_all/run_ablation/run_seed_control，cmd=="all" 依次调用 prepare、analyze、build_all、run_ablation、run_seed_control，其余值 raise SystemExit。
-def main(argv):
-    cmd = argv[1] if len(argv) > 1 else "prepare"
-    if cmd == "prepare":
-        prepare()
-    elif cmd == "analyze":
-        analyze()
-    elif cmd == "build":
-        build_all()
-    elif cmd == "run":
-        run_ablation()
-    elif cmd == "seed-control":
-        run_seed_control()
-    elif cmd == "all":
-        prepare()
-        analyze()
-        build_all()
-        run_ablation()
-        run_seed_control()
-    else:
-        raise SystemExit(
-            f"未知子命令：{cmd}"
-            "（可用：prepare / analyze / build / run / seed-control / all）")
-
-
-if __name__ == "__main__":
+# -*- coding: utf-8 -*-
+"""中文多维探针（MAD, multi-axis）——20 条「中文层 + 英文原文」语料，Rust 侧四路检索。
+
+与既有 zh_probe 探针的关系：前一版探针只测「中文层做索引」的单点效果；本探针
+把写入侧加工拆成可消融的四个维度，逐一叠加，看每一步对检索指标的边际贡献：
+
+  轴 1 实体规范化  —— 全库 df 聚合出的 canonical 词 + 人物/地点/时间 → tags（entity 路）
+  轴 2 指代消解    —— **仅当本条自身无实体**时承接**前一条自身**的 canonical（保守附加）
+  轴 3 意图抽象    —— 摘要 → 规范意图类目；类目 + 动词原形 → tags，类目 → 正文子功能行
+  轴 4 关系图遍历  —— 人物/事件/时间/身份/地点/条件 多维关系 → edges（graph 路）
+
+首轮五臂实测出现三项反直觉负增益，经取证判定为**实现/口径缺陷**而非能力缺陷
+（结论已归档灵枢记忆；本段为修正说明）：
+  * 轴2 原实现无条件承接，且 `last_canon = cur`（含继承）单调累积 → tags 退化为
+    「历史全集」，后段条目对任何查询都命中 entity 路（-15~-20pp）。本文件已改为
+    规格语义；修正后本探针集**无「自身无实体」条目 → 该轴未激活**（`承接条数=0`）。
+  * 轴3 原产出是摘要切片（非抽象），且只进正文、只喂词法路；RRF 按**名次**融合，
+    该行只改变 jaccard 分母不改名次 → 边际恒 0。本文件已改为规范类目 + tags 通道。
+  * 轴4 `_path_graph` 契约要求「种子已排序」，但 `_lexical` 在 LIKE 命中
+    ≤ `GLOBAL_CAP`(500) 时返回**未排序**列表 → seeds[:5] 退化为索引枚举序前 5 条，
+    图路对多题注入同一恒定集合。`run_seed_control` 用于隔离该口径缺陷。
+
+数据源（**全部既有真源，零新增标注**）：
+  * data/external/zh_probe/manual_zh.json          20 条 gold turn 的中文层（既有产物）
+  * data/external/zh_probe/manual_q.json           20 条中文查询
+  * data/external/longmemeval/lme_s_haystack.jsonl 英文原文（按 id 取）
+  * data/external/longmemeval/lme_s_questions.jsonl qid → qtype / evidence_turns
+
+诚实条款（报告必须原样声明）：
+  * 中文层与查询均为**既有产物**（非本次生成），本脚本不改一字，只做结构解析；
+  * 写入侧加工是**确定性纯规则**（零 LLM、零第三方依赖、同输入必同输出），
+    词表随源码公开，第三方可重放；
+  * 加工**盲于查询集**：canonical 判定只用全库 df 与中文层自身字段，
+    不读 manual_q.json 的任何内容——否则即数据泄漏，评测作废；
+  * 池仅 20 条 → 随机基线 hit@1 = 5%，单项能力 ±1 题即 ±5 个百分点。
+    结论只能作**方向性证据**，不可作定量结论。
+"""
+import json
+import os
+import re
+import sys
+
+HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+# 本脚本既可能被当脚本跑（sys.path[0] 是 md_cg/），也可能被当包内模块导入
+for _p in (HERE, os.path.join(HERE, "md_cg")):
+    if _p not in sys.path:
+        sys.path.insert(0, _p)
+
+EXT = os.path.join(HERE, "data", "external")
+ZP = os.path.join(EXT, "zh_probe")
+LM = os.path.join(EXT, "longmemeval")
+
+MANUAL_ZH = os.path.join(ZP, "manual_zh.json")
+MANUAL_Q = os.path.join(ZP, "manual_q.json")
+LM_H = os.path.join(LM, "lme_s_haystack.jsonl")
+LM_Q = os.path.join(LM, "lme_s_questions.jsonl")
+
+CORPUS20 = os.path.join(ZP, "corpus20.jsonl")
+QUESTIONS20 = os.path.join(ZP, "questions20.jsonl")
+
+# 关系轴：用户裁决「条件链 + 人物/事件/时间/身份/地点都可以作为关系」
+AXES = ("person", "event", "time", "identity", "place", "condition")
+
+
+# 生效条件：path 以 UTF-8 打开后逐行读取，仅 strip 后非空的行经 json.loads 产出，空白行被跳过。
+def iter_jsonl(path):
+    with open(path, encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                yield json.loads(line)
+
+
+# 生效条件：path 以 UTF-8 打开成功时返回 json.load(f) 的解析结果，片段内无其它分支。
+def load_json(path):
+    with open(path, encoding="utf-8") as f:
+        return json.load(f)
+
+
+# 生效条件：raw 经 str() 后按“；”切分，仅含“=”的段被解析，其中键为身份/时间/摘要时写对应槽位、键为条件时按“|”与“:”写入 condition、键为词时按“,”拆出非空项写入 terms，其它键或未出现的槽位保持 out 的默认空值。
+def parse_zh(raw):
+    """中文层串 → 槽位 dict。
+
+    格式（manual_zh.json 既有形态，本函数只解析不改写）：
+        身份=用户；时间=2023/05/24 04:49；摘要=…；
+        条件=观测位置:会话陈述|观测工具:会话记录|时间窗口:2023-05-24|存在约束:公开；
+        词=礼物,礼物清单,场合
+    """
+    out = {"identity": "", "time": "", "summary": "", "condition": {},
+           "terms": []}
+    for seg in str(raw).split("；"):
+        seg = seg.strip()
+        if not seg or "=" not in seg:
+            continue
+        key, val = seg.split("=", 1)
+        key, val = key.strip(), val.strip()
+        if key == "身份":
+            out["identity"] = val
+        elif key == "时间":
+            out["time"] = val
+        elif key == "摘要":
+            out["summary"] = val
+        elif key == "条件":
+            for kv in val.split("|"):
+                if ":" in kv:
+                    k, v = kv.split(":", 1)
+                    out["condition"][k.strip()] = v.strip()
+        elif key == "词":
+            out["terms"] = [t.strip() for t in val.split(",") if t.strip()]
+    return out
+
+
+# 生效条件：当 MANUAL_ZH/MANUAL_Q/LM_Q/LM_H 可读取、hay 覆盖 want_ids 且 meta 含 man_q 全部 qid 时写出 CORPUS20/QUESTIONS20 并返回 (corpus, questions)，缺 turn 或 qid 分别 raise SystemExit，verbose（默认 True）为真值时额外打印统计、假值时静默。
+def prepare(verbose=True):
+    """生成 corpus20.jsonl 与 questions20.jsonl（幂等覆盖）。"""
+    man_zh = load_json(MANUAL_ZH)
+    man_q = load_json(MANUAL_Q)
+    meta = {r["qid"]: r for r in iter_jsonl(LM_Q)}
+    want_ids = set(man_zh)
+    hay = {}
+    for r in iter_jsonl(LM_H):
+        if r["id"] in want_ids:
+            hay[r["id"]] = r
+            if len(hay) == len(want_ids):
+                break
+
+    missing = want_ids - set(hay)
+    if missing:
+        raise SystemExit(f"[失败] haystack 缺以下 turn：{sorted(missing)}")
+
+    # corpus：按 turn id 的数值序（= 时间序），保证「承接前一条」有确定语义
+# 生效条件：tid 经 rsplit("t",1) 得到至少两段且最后一段可被 int() 解析时返回该整数，否则源码未做校验会抛错。
+    def turn_no(tid):
+        return int(tid.rsplit("t", 1)[1])
+
+    corpus = []
+    for tid in sorted(man_zh, key=turn_no):
+        t = hay[tid]
+        corpus.append({
+            "id": tid,
+            "text": str(t.get("text") or ""),
+            "speaker": str(t.get("speaker") or ""),
+            "date": str(t.get("date") or ""),
+            "zh": man_zh[tid],
+            "zh_fields": parse_zh(man_zh[tid]),
+        })
+
+    # questions：qid → 中文查询 + 证据（完整 evidence_turns，池里仅 ev0 存在）
+    questions = []
+    for qid, q in man_q.items():
+        m = meta.get(qid)
+        if m is None:
+            raise SystemExit(f"[失败] questions 缺 qid={qid}")
+        questions.append({
+            "qid": qid,
+            "qtype": m["qtype"],
+            "question": q,
+            "answer": str(m.get("answer") or ""),
+            "evidence_turns": list(m.get("evidence_turns") or []),
+        })
+
+    with open(CORPUS20, "w", encoding="utf-8") as f:
+        for r in corpus:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+    with open(QUESTIONS20, "w", encoding="utf-8") as f:
+        for r in questions:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+
+    if verbose:
+        print(f"语料 {len(corpus)} 条 → {CORPUS20}")
+        print(f"题库 {len(questions)} 条 → {QUESTIONS20}")
+        n_etype = {}
+        for q in questions:
+            n_etype[q["qtype"]] = n_etype.get(q["qtype"], 0) + 1
+        print("题型分布：" + ", ".join(f"{k}={v}" for k, v in sorted(n_etype.items())))
+    return corpus, questions
+
+
+# 生效条件：prepare(verbose=False) 返回 corpus/questions 后，对每题以 evidence_turns[0]（空则 ""）取 ev0，命中词限于 ev0 非空且词出现在 zh_of[ev0] 中，df1 收集池内 df==1 的词、all_df 收集 df==len(corpus) 的词，verbose（默认 True）为真值时打印后返回 per_q、为假值时直接返回 per_q。
+def analyze(verbose=True):
+    """诊断：查询词能否落到 gold 中文层 / 池内其他条目（决定各轴是否有可桥接的实体）。
+
+    只读既有产物，不修改任何语料。输出两类事实：
+      * 查询词在 gold 中文层的字面命中率 → 词法路的天花板；
+      * 查询词在**池内**的 df → 该词的判别力（df=1 是精确定位，df=20 则无信息量）。
+    """
+    corpus, questions = prepare(verbose=False)
+    zh_of = {c["id"]: c["zh"] for c in corpus}
+
+    per_q = []
+    for q in questions:
+        ev0 = q["evidence_turns"][0] if q["evidence_turns"] else ""
+        terms = [t for t in str(q["question"]).split() if t]
+        hit = [t for t in terms if ev0 and t in zh_of.get(ev0, "")]
+        globalish = [t for t in terms
+                     if sum(1 for c in corpus if t in zh_of[c["id"]]) == len(corpus)]
+        per_q.append({
+            "qid": q["qid"], "ev0": ev0, "qtype": q["qtype"],
+            "n_term": len(terms), "n_hit": len(hit),
+            "hit_terms": hit,
+            "df1": sorted({t for t in terms
+                           if sum(1 for c in corpus if t in zh_of[c["id"]]) == 1}),
+            "all_df": globalish,
+        })
+
+    if verbose:
+        print(f"\n== 查询词覆盖诊断（池 {len(corpus)} 条，题 {len(questions)} 道）==")
+        print(f"{'qid':<16}{'ev0':<12}{'词数':>5}{'命中':>5}  命中词")
+        print("-" * 72)
+        for r in per_q:
+            print(f"{r['qid']:<16}{r['ev0']:<12}{r['n_term']:>5}{r['n_hit']:>5}  "
+                  f"{','.join(r['hit_terms'])[:40]}")
+        tot_t = sum(r["n_term"] for r in per_q)
+        tot_h = sum(r["n_hit"] for r in per_q)
+        zero = [r["qid"] for r in per_q if r["n_hit"] == 0]
+        print("-" * 72)
+        print(f"合计：{tot_h}/{tot_t} 个查询词落在 gold 中文层"
+              f"（{tot_h / max(1, tot_t):.1%}）")
+        print(f"零重叠题（{len(zero)}）：{', '.join(zero) if zero else '无'}")
+        return per_q
+
+    return per_q
+
+
+# ---------------------------------------------------------------- 写入侧四轴
+# 全部为确定性纯规则：零 LLM、零外部依赖，同输入必同输出；词表随源码公开。
+# **盲于查询集**：以下规则只读 corpus20（语料）与中文层自身字段，从不打开 manual_q.json。
+
+STOP_ZH = frozenset(
+    "的 了 在 是 我 你 他 她 它 和 与 或 这 那 有 没 不 就 都 也 还 要 会 能 可以 "
+    "多少 什么 哪里 哪 怎么 为什么 几 一些 一个 之 其 与 及 等 被 把 给 对 从 到".split()
+)
+
+PERSON_HINTS = (
+    "妹妹", "姐姐", "哥哥", "弟弟", "妈妈", "爸爸", "母亲", "父亲", "父母", "奶奶",
+    "爷爷", "外婆", "外公", "同事", "朋友", "同学", "邻居", "老板", "上司", "教练",
+    "医生", "老师", "室友", "伴侣", "丈夫", "妻子", "儿子", "女儿", "叔叔", "阿姨",
+    "表亲", "未婚夫", "未婚妻",
+)
+
+PLACE_HINTS = (
+    "市", "州", "城", "镇", "岛", "公园", "中心", "大学", "海滩", "广场", "机场",
+    "河", "湖", "山", "街", "路", "区", "国家", "澳洲", "欧洲", "亚洲", "美洲",
+)
+
+EN_STOP = frozenset("""
+The A An And But Or For Nor So Yet This That These Those There Their They Them Then Than
+When What Where Which While Who Whom Whose Why How However Also Always Never Often Sometimes
+I You He She It We They Me Him Her Us My Your His Its Our Very Really Just Only Even Still
+Have Has Had Having Do Does Did Doing Be Been Being Am Is Are Was Were Will Would Shall
+Should Can Could May Might Must Not No Yes If In On At By To Of With From Into Onto Over
+Under Above Below Between During After Before About Around Because Since Until Upon While
+Monday Tuesday Wednesday Thursday Friday Saturday Sunday January February March April May
+June July August September October November December Today Yesterday Tomorrow Last Next
+New Old Good Bad Best Worst First Second Third One Two Three Four Five Six Seven Eight Nine
+Ten Okay Ok Well Thanks Thank Please Hi Hello Hey
+""".split())
+
+EN_NAME_RE = re.compile(r"\b[A-Z][a-z]{2,}(?:[ ][A-Z][a-z]{2,})*\b")
+DATE_RE = re.compile(r"(\d{4})[/-](\d{1,2})[/-](\d{1,2})")
+
+
+# 生效条件：DATE_RE.search(str(raw or "")) 有匹配时返回零填充的 YYYY-MM-DD，无匹配（含 raw 为假值回落成 ""）时返回 ""。
+def norm_time(raw):
+    """'2023/05/24 04:49' → '2023-05-24'（跨条目统一格式，使日期查询可命中）。"""
+    m = DATE_RE.search(str(raw or ""))
+    if not m:
+        return ""
+    y, mo, d = m.groups()
+    return f"{int(y):04d}-{int(mo):02d}-{int(d):02d}"
+
+
+# 生效条件：对 str(text or "") 用 EN_NAME_RE 扫描，匹配串按空白切分后任一部分命中 EN_STOP 即跳过，其余项按首次出现顺序去重加入 out 并返回；text 为假值时扫描空串返回 []。
+def en_names(text):
+    """英文原文中的专名候选（跨语言桥：中文查询里的英文专名可经 entity 路命中）。"""
+    out, seen = [], set()
+    for m in EN_NAME_RE.finditer(str(text or "")):
+        w = m.group(0)
+        if any(p in EN_STOP for p in w.split()):
+            continue
+        if w not in seen:
+            seen.add(w)
+            out.append(w)
+    return out
+
+
+# 生效条件：遍历 corpus，对每条记录的 zh_fields["terms"] 去重后逐词判断，词非空且不在 STOP_ZH 时使 df[词] 计数加一，返回 df。
+def build_tables(corpus):
+    """全库统计：# 词项 df（**只读语料**，与查询集无关）。"""
+    df = {}
+    for c in corpus:
+        for t in set(c["zh_fields"]["terms"]):
+            if t and t not in STOP_ZH:
+                df[t] = df.get(t, 0) + 1
+    return df
+
+
+# 生效条件：c 含 zh_fields（terms/condition/time/identity）且 df 为词到频次的映射时，返回 person/event/time/identity/place/condition 六轴取值字典。
+def axis_values(c, df):
+    """一条 turn 的六个关系轴取值（用户裁决：条件链 + 人物/事件/时间/身份/地点）。"""
+    f = c["zh_fields"]
+    terms = [t for t in f["terms"] if t and t not in STOP_ZH]
+    tw = norm_time(f["condition"].get("时间窗口") or f["time"])
+    person = [t for t in terms if any(h in t for h in PERSON_HINTS)]
+    place = [t for t in terms if any(h in t for h in PLACE_HINTS)]
+    event = [t for t in terms if df.get(t, 0) >= 2]
+    return {
+        "person": person,
+        "event": event,
+        "time": [tw] if tw else [],
+        "identity": [f["identity"]] if f["identity"] else [],
+        "place": place,
+        "condition": [f"{k}:{v}" for k, v in f["condition"].items()],
+    }
+
+
+# 意图类目：意图动词 → 规范类目（确定性词表，只读摘要，与查询集无关）
+INTENT_CLASSES = (
+    ("推荐", ("推荐", "建议", "咨询", "请教")),
+    ("购置", ("购买", "买", "挑选", "选购", "下单", "购买")),
+    ("整理", ("整理", "清理", "分类", "收纳", "归档")),
+    ("学习", ("学习", "了解", "阅读", "查阅", "研究")),
+    ("规划", ("计划", "安排", "准备", "制定")),
+    ("比较", ("比较", "对比", "估算", "计算")),
+    ("维修", ("维修", "修理", "更换", "保养")),
+    ("出行", ("旅行", "搬家", "搬迁", "游玩", "漂流")),
+    ("参加", ("参加", "报名", "出席")),
+    ("健身", ("锻炼", "跑步", "训练")),
+    ("取退", ("退还", "退回", "归还")),
+    ("完成", ("完成", "做完", "结课")),
+)
+
+
+# 生效条件：按 INTENT_CLASSES 顺序检查 c["zh_fields"]["summary"]，首个命中类目的首个包含于摘要的动词返回 (cls, v)，全不命中返回 ('', '')。
+def intent_of(c):
+    """意图抽象：摘要 → (规范类目, 命中的动词原形)。
+
+    规格要求「抽象」。原实现返回摘要切片 `f"{v}：" + summary[i-6:i+10]`——
+    那只是把原文再抄一遍：不产生任何新词、不构成类目，且只写进正文，
+    而正文只喂词法路、RRF 又只按**名次**融合（见 bench 报告），故边际恒为 0。
+    此处归一为固定类目，并保留命中的动词原形，二者一并进 tags（entity 路——
+    存在性匹配，不吃分数尺度），使该轴真正获得独立检索通道。
+    """
+    s = c["zh_fields"]["summary"]
+    for cls, verbs in INTENT_CLASSES:
+        for v in verbs:
+            if v in s:
+                return cls, v
+    return "", ""
+
+
+# 生效条件：把 c["zh_fields"]["terms"] 与 en_names(c["text"]) 逐项 strip 后跳过空串、STOP_ZH（原形或小写）及已见项去重入 out，再用 norm_time(条件.get("时间窗口") or c 的 time) 得到非空且未出现的时窗串追加；df 形参在该片段内未参与条件判断。
+def normalize_terms(c, df):
+    """实体规范化：去停用 + 去重 + 附时间规范式 + 附英文专名（跨语言对齐）。"""
+    f = c["zh_fields"]
+    out, seen = [], set()
+    for t in list(f["terms"]) + en_names(c["text"]):
+        t = t.strip()
+        if not t or t in STOP_ZH or t.lower() in STOP_ZH or t in seen:
+            continue
+        seen.add(t)
+        out.append(t)
+    tw = norm_time(f["condition"].get("时间窗口") or f["time"])
+    if tw and tw not in seen:
+        out.append(tw)
+    return out
+
+
+# 生效条件：遍历 corpus 并以 root=os.path.join(HERE, root_base or f"_md_cg_eval_zhprobe_{arm['name']}")（root_base 为 None/空串时回落）建库，graph 分支仅当 arm.get("graph") 为真且某轴取值的同值 id 数落在 [2, max_df]（默认 5）时为这些 id 两两建有向边，coref 仅当 arm.get("coref") 为真、本条 own 为空（own 只在 arm.get("norm") 为真时由 normalize_terms 生成，否则恒为 []）且 prev_own 非空时承接前一条自身 canonical，intent 分支仅当 arm.get("intent") 为真且 intent_of 返回 cls 非空时写意图行并把意图词与长度>=2 的动词加入 tags，verbose（默认 True）为真值时打印臂统计、root 已是目录时先整树删除再建 MdCGOS。
+def build_arm(corpus, arm, max_df=5, root_base=None, verbose=True):
+    """按消融臂建库。每臂一个独立 root，互不污染。
+
+    臂的差异**只体现在库内容**（正文/tags/edges），检索路固定
+    lexical+entity+graph——这样"能力未开"就等于"库内没有对应信息"，
+    归因干净：指标变化可直接归给该轴，而不是归给路开关。
+    """
+    from md_cg.mdcos import MdCGOS
+    root = os.path.join(HERE, root_base or f"_md_cg_eval_zhprobe_{arm['name']}")
+
+    df = build_tables(corpus)
+    axes = {c["id"]: axis_values(c, df) for c in corpus}
+
+    edges = {}
+    if arm.get("graph"):
+        for ax in AXES:
+            val2ids = {}
+            for c in corpus:
+                for v in axes[c["id"]][ax]:
+                    val2ids.setdefault(v, set()).add(c["id"])
+            for v, ids in val2ids.items():
+                if not (2 <= len(ids) <= max_df):
+                    continue  # df=1 无边；df>max_df 全连通，零信息量只注入噪声
+                for a in ids:
+                    for b in ids:
+                        if a != b:
+                            edges.setdefault(a, {})[b] = ax
+
+    if os.path.isdir(root):
+        import shutil
+        shutil.rmtree(root, ignore_errors=True)
+    cg = MdCGOS(root, autoflush=500)
+
+    prev_own = None  # 前一条**自身**的 canonical（不累积）
+    n_coref = 0
+    for c in corpus:
+        f = c["zh_fields"]
+        own = normalize_terms(c, df) if arm.get("norm") else []
+
+        # 轴2 指代消解（规格：保守附加）——**仅当本条自身无实体**时，
+        # 才承接**前一条自身**的 canonical。
+        # 原实现：`if coref and last_canon` 无条件承接，且 `last_canon = cur`
+        # 把「继承结果」也计入 → 单调累积成「历史全集」，tags 雪球污染。
+        inherit = []
+        if arm.get("coref") and not own and prev_own:
+            inherit = list(prev_own)
+            n_coref += 1
+
+        # 轴3 意图抽象：类目写正文（规格的「子功能行」），类目词 + 动词原形写 tags。
+        intent_terms = []
+        intent_line = ""
+        if arm.get("intent"):
+            cls, verb = intent_of(c)
+            if cls:
+                intent_line = f"意图：{cls}"
+                intent_terms = [f"意图:{cls}"] + ([verb] if len(verb) >= 2 else [])
+
+        body = [f"身份：{f['identity']}", f"时间：{f['time']}",
+                f"摘要：{f['summary']}", f"词：{','.join(f['terms'])}",
+                "条件：" + "|".join(f"{k}:{v}" for k, v in f["condition"].items())]
+        if intent_line:
+            body.append(intent_line)
+        if inherit:
+            body.append("承接：" + ",".join(inherit))
+        body.append("")
+        body.append(c["text"])
+
+        tags = own[:]
+        for t in intent_terms + inherit:
+            if t not in tags:
+                tags.append(t)
+
+        e = [{"target": t, "axis": a} for t, a in edges.get(c["id"], {}).items()]
+        cg.add(c["id"], "\n".join(body), layer="contextual", tags=tags,
+               edges=e, eval_src=f"zh_mad:{arm['name']}", verification_basis="data")
+
+        prev_own = own[:]
+
+    cg.flush()
+    if verbose:
+        n_e = sum(len(v) for v in edges.values())
+        print(f"  [{arm['name']}] root={os.path.basename(root)} "
+              f"tags_axis={'on' if arm.get('norm') else 'off'} "
+              f"coref={'on' if arm.get('coref') else 'off'} "
+              f"intent={'on' if arm.get('intent') else 'off'} "
+              f"graph={'on' if arm.get('graph') else 'off'} 有向边={n_e} "
+              f"承接条数={n_coref}")
+    return root
+
+
+ARMS = [
+    {"name": "a0_base", "norm": False, "coref": False, "intent": False, "graph": False},
+    {"name": "a1_norm", "norm": True, "coref": False, "intent": False, "graph": False},
+    {"name": "a2_coref", "norm": True, "coref": True, "intent": False, "graph": False},
+    {"name": "a3_intent", "norm": True, "coref": True, "intent": True, "graph": False},
+    {"name": "a4_graph", "norm": True, "coref": True, "intent": True, "graph": True},
+]
+
+
+# 生效条件：先执行 prepare(verbose=False) 取得 corpus，再对 ARMS 每臂以 max_df=max_df（默认 5，原样下传不做假值回落）调用 build_arm 并汇总为 roots 返回。
+def build_all(max_df=5):
+    corpus, _ = prepare(verbose=False)
+    print(f"== 建库（消融 {len(ARMS)} 臂，max_df={max_df}）==")
+    roots = {}
+    for arm in ARMS:
+        roots[arm["name"]] = build_arm(corpus, arm, max_df=max_df)
+    return roots
+
+
+RUST_BIN = os.path.join(HERE, "rust", "target", "release", "mdcg-eval.exe")
+ROW_RE = re.compile(
+    r"^\s*(precise|temporal|interference|reference)\s+(\d+)\s+"
+    r"([\d.]+)%\s+([\d.]+)%\s+([\d.]+)\s*$", re.M)
+GROUPS = ["precise", "temporal", "interference", "reference"]
+
+
+# 生效条件：os.path.exists(RUST_BIN) 为真时以 argv=[RUST_BIN,"--dataset","mad","--tag",name,"--lib",lib]（extra 为真值时追加 list(extra)）执行 subprocess，返回码非 0 或 ROW_RE 在 stdout 未匹配到任何组时 raise SystemExit，否则返回 {组:(n,hit@1,hit@5,MRR)}。
+def run_one(name, lib, extra=None):
+    """调用 **Rust 检索器** 跑一臂，返回 {组: (n, hit@1, hit@5, MRR)}。
+
+    命令执行走 subprocess argv 列表 + 显式 UTF-8 + PYTHONUTF8=1（不经 Windows shell），
+    规避 GBK 解码异常。
+    """
+    import subprocess
+
+    if not os.path.exists(RUST_BIN):
+        raise SystemExit(f"[失败] 未找到 Rust 评测器：{RUST_BIN}（先 cargo build --release）")
+    argv = [RUST_BIN, "--dataset", "mad", "--tag", name, "--lib", lib]
+    if extra:
+        argv += list(extra)
+    env = dict(os.environ, PYTHONUTF8="1")
+    p = subprocess.run(argv, capture_output=True, text=True,
+                       encoding="utf-8", errors="replace", env=env, cwd=HERE)
+    if p.returncode != 0:
+        raise SystemExit(f"[失败] {name}：{(p.stderr or '')[-900:]}")
+    got = {}
+    for m in ROW_RE.finditer(p.stdout):
+        g, n, h1, h5, mrr = m.groups()
+        got[g] = (int(n), float(h1), float(h5), float(mrr))
+    if not got:
+        raise SystemExit(f"[失败] {name}：未解析到组指标\n{p.stdout[-1200:]}")
+    return got
+
+
+# 生效条件：先打印 title 与表头，再遍历 rows 的 (label, got, note)，对 GROUPS 每组用 got[g] 取 (n,h1,h5,mrr) 并累计总体 hit@1/MRR，仅当 baseline 不为 None 且 label==baseline 时记 ref，仅当 ref 已记录且 label!=baseline 时输出 Δ。
+def print_table(title, rows, baseline=None):
+    """rows: [(label, got, note)]；baseline = 参照行 label（算 Δ）。"""
+    print(f"\n== {title} ==")
+    hdr = (f"{'臂':<14}" + "".join(f"{g[:12]:>15}" for g in GROUPS)
+           + f"{'总体hit@1':>12}{'总体MRR':>10}")
+    print(hdr)
+    print("-" * len(hdr))
+    ref = None
+    for label, got, note in rows:
+        cells, tot_h1, tot_n, tot_mrr = [], 0.0, 0, 0.0
+        for g in GROUPS:
+            n, h1, _h5, mrr = got[g]
+            cells.append(f"{h1:.0f}%/{mrr:.3f}")
+            tot_h1 += h1 / 100.0 * n
+            tot_n += n
+            tot_mrr += mrr * n
+        ov_h1 = tot_h1 / max(1, tot_n)
+        ov_mrr = tot_mrr / max(1, tot_n)
+        if baseline is not None and label == baseline:
+            ref = (ov_h1, ov_mrr)
+        delta = ""
+        if ref is not None and label != baseline:
+            delta = f"  (Δ{(ov_h1 - ref[0]) * 100:+.1f}pp)"
+        suffix = f"  {note}" if note else ""
+        print(f"{label:<14}" + "".join(f"{c:>15}" for c in cells)
+              + f"{ov_h1 * 100:>10.1f}%{ov_mrr:>10.3f}{delta}{suffix}")
+
+
+# 生效条件：对 ARMS 每臂以 lib=f"_md_cg_eval_zhprobe_{name}"、无 extra 调用 run_one 组成 rows，并以 ARMS[0]["name"] 为 baseline 调 print_table 后返回 rows。
+def run_ablation():
+    """消融主表：逐臂调用 Rust 检索器并汇总（种子口径 = 缺省，即生产现状）。"""
+    rows = []
+    for arm in ARMS:
+        name = arm["name"]
+        rows.append((name, run_one(name, f"_md_cg_eval_zhprobe_{name}"), ""))
+    print_table("消融主表（Rust 检索器，k=5，jaccard，证据命中；graph 种子=索引序）",
+                rows, baseline=ARMS[0]["name"])
+    print("\n随机基线 hit@1 = 5.0%（1/20）；池仅 20 条，±1 题 = ±5pp，"
+          "结论只作方向性证据。")
+    return rows
+
+
+# 生效条件：以最后一个臂 ARMS[-1]['name'] 对应的库路径，先无 extra 调 run_one("a4_index", lib)、再以 extra=("--graph-seeds","sorted") 调 run_one("a4_sorted", lib) 组成 rows，并以 baseline="a4/index" 调 print_table 后返回。
+def run_seed_control():
+    """对照：**同一个 a4 库**（写入侧与边结构完全相同），只切换 graph 路种子口径。
+
+    用于把 a4 相对 a3 的变化拆成两个因子：
+      * 边结构质量（本轴真正要测的能力）；
+      * `_path_graph`「种子须已排序」契约被违反 → seeds[:5] 退化为索引枚举序前 5。
+    """
+    lib = f"_md_cg_eval_zhprobe_{ARMS[-1]['name']}"
+    rows = [
+        ("a4/index", run_one("a4_index", lib), "现状：seeds=索引枚举序前 5"),
+        ("a4/sorted", run_one("a4_sorted", lib, ("--graph-seeds", "sorted")),
+         "文档语义：seeds=top-5 词法"),
+    ]
+    print_table("graph 种子口径对照（库内容完全相同，只换种子）", rows,
+                baseline="a4/index")
+    return rows
+
+
+# 生效条件：cmd 取 argv[1]（len(argv)<=1 时为 "prepare"），cmd=="prepare"/"analyze"/"build"/"run"/"seed-control" 分别调用 prepare/analyze/build_all/run_ablation/run_seed_control，cmd=="all" 依次调用 prepare、analyze、build_all、run_ablation、run_seed_control，其余值 raise SystemExit。
+def main(argv):
+    cmd = argv[1] if len(argv) > 1 else "prepare"
+    if cmd == "prepare":
+        prepare()
+    elif cmd == "analyze":
+        analyze()
+    elif cmd == "build":
+        build_all()
+    elif cmd == "run":
+        run_ablation()
+    elif cmd == "seed-control":
+        run_seed_control()
+    elif cmd == "all":
+        prepare()
+        analyze()
+        build_all()
+        run_ablation()
+        run_seed_control()
+    else:
+        raise SystemExit(
+            f"未知子命令：{cmd}"
+            "（可用：prepare / analyze / build / run / seed-control / all）")
+
+
+if __name__ == "__main__":
     main(sys.argv)