@furongjun1999/dsh-memory 0.4.4 → 0.4.6

package/md_cg/bench_axis_domain.py

@@ -0,0 +1,250 @@
+# -*- coding: utf-8 -*-
+"""域轴（条件约束）单变量消融 —— 验证 routing 条件路由在 locomo 中文层上的净效应。
+
+## 为什么做这个（先例取证）
+
+四轴消融（`bench_zh_mad.ARMS` a0..a4 → `bench_locomo_zh.cmd_build`）有三处把
+条件约束路**排除在外**，叠加起来使其从未被开启过：
+
+1. `build_arm` 注释明写「检索路固定 lexical+entity+graph」——`bucket` 不在其中；
+2. `build_arm` 写入用 `layer="contextual"`，而 `BUCKETED_LAYERS = ("knowledge",)`
+   （mdcg.py:37）→ `bucket` 字段恒为 None，**连分桶都没发生**；
+3. Rust 侧 `retrieval::bucket` 是空壳（`main.rs` 硬编码 `has_context=false`），
+   Python 侧 `mdcos._path_bucket` 在 `context is None` 时直接 `return []`。
+
+→ 四轴的全部边际变化只能来自 **entity（裸词 tags）** 与 **graph（edges）** 两路。
+实测 a0(91.10%) → a1(32.40%) 的塌陷即裸词 tags 把 `_path_entity`
+（判据 `t in query or query in t`，二值、score 恒 1.0）从「恒空」激活为「恒满」——
+**不是能力未开，是把信息接进了一条无区分度的端口**。
+
+本系统条件约束的**正确输入**是 tags 的 `domain:` 前缀（`routing.route_key`
+优先级 1）；写入侧与查询侧共用 `routing.BIG_DOMAINS` 词表，保证两侧同构
+（routing.py 模块头「风险2 的前提」）。
+
+## 实验设计（单变量：四臂只差 tags 内容）
+
+正文 / 层（knowledge）/ 无 edges 完全相同：
+
+| 臂 | tags | bucket |
+|---|---|---|
+| d0_base | `[]` | orphan |
+| d1_bare | 裸词（**与 a1_norm 同源**，复现四轴错法） | orphan |
+| d2_dom | `[domain:<域>]` | `<域>` |
+| d3_shuf | `[domain:<随机域>]`（保持分布） | `<随机域>` |
+
+检索路：`lexical` | `lexical,bucket` | `lexical,entity` | `lexical,bucket,entity`。
+查询侧 context 由 `routing` 同词表分类构造（`big_domain_classify`）。
+
+## 裁决标准
+
+* `d2(lexical,bucket) > d0(lexical)` → 条件约束是**净增益**；
+* `d3(lexical,bucket) ≈ d0(lexical)` → 增益来自**正确的域**，而非「有桶就行」（因果对照）；
+* `d1(lexical,entity) < d0(lexical)` → 裸词 tags 是**净污染**（复现四轴）。
+
+## 诚实条款
+
+* 语料/题库为既有产物（`corpus567.jsonl` / `questions500.jsonl`），本脚本不改一字；
+* 域判定是确定性纯规则（routing 词表，零 LLM），同输入必同输出，可第三方重放；
+* 域判定**盲于查询集**：写入侧只读 turn 的 `zh_fields`，不读 question/answer；
+* 本语料是**日常生活对话**，14 大域为学科词表 → 落域覆盖有限（实测写入侧 31.0%、
+  查询侧 30.6%），故预期增益只作用在有域子集上，不做「全量标题」式宣称。
+"""
+import json
+import os
+import random
+import sys
+import time
+
+HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+for _p in (HERE, os.path.join(HERE, "md_cg")):
+    if _p not in sys.path:
+        sys.path.insert(0, _p)
+
+from md_cg import bench_zh_mad as bz        # noqa: E402  复用 a1 的 tags 来源（同源）
+from md_cg import eval_common as ec         # noqa: E402
+from md_cg import mdcg as mg                # noqa: E402
+from md_cg import routing                   # noqa: E402
+
+# 数据集路径解析：优先随仓库公开的 data/benchmarks/locomo-zh-500/，回退本地
+# data/external/locomo_zh/（.gitignore 覆盖，含中文层分批中间件，不随仓库公开）。
+# 公开目录只含 corpus567/questions500 两个成品文件——本脚本只需这两个，故外部
+# 拿到仓库即可跑通（此前硬编码 data/external 会让"公开可复现"落空，见数据集
+# README「怎么用」节的复现命令）。
+_PUBLIC_DIR = os.path.join(HERE, "data", "benchmarks", "locomo-zh-500")
+WORK = (_PUBLIC_DIR if os.path.exists(os.path.join(_PUBLIC_DIR, "corpus567.jsonl"))
+        else os.path.join(ec.EXT, "locomo_zh"))
+CORPUS567 = os.path.join(WORK, "corpus567.jsonl")
+QUESTIONS500 = os.path.join(WORK, "questions500.jsonl")
+
+SEED = 7
+ARM_PREFIX = "_md_cg_eval_domax_"           # .gitignore 的 /_md_cg_eval_*/ 已覆盖
+
+ARMS = (("d0_base", "base"), ("d1_bare", "bare"),
+        ("d2_dom", "dom"), ("d3_shuf", "shuf"))
+PATHSETS = (("lexical",), ("lexical", "bucket"),
+            ("lexical", "entity"), ("lexical", "bucket", "entity"),
+            ("lexical", "fuzzy"), ("lexical", "fuzzy", "bucket"))
+
+
+# ------------------------------------------------------------------ 写入侧加工
+
+def body_of(c):
+    """正文：与 bench_zh_mad.build_arm 的 a0 臂**逐字一致**（无意图行/无承接行）。"""
+    f = c["zh_fields"]
+    return "\n".join([
+        f"身份：{f['identity']}",
+        f"时间：{f['time']}",
+        f"摘要：{f['summary']}",
+        f"词：{','.join(f['terms'])}",
+        "条件：" + "|".join(f"{k}:{v}" for k, v in f["condition"].items()),
+        "",
+        c["text"],
+    ])
+
+
+def write_domain(c):
+    """写入侧域判定：只读 turn 自身的 zh_fields（盲于查询集）。"""
+    f = c["zh_fields"]
+    terms = list(f["terms"]) + [t for t in str(f["summary"]).split() if t]
+    return routing.big_domain_classify(terms)
+
+
+def query_domain(q):
+    """查询侧域判定：与写入侧共用同一份 routing 词表（两侧同构）。"""
+    return routing.big_domain_classify(list(mg.expand_query_terms(q["question"])))
+
+
+def arm_tags(c, mode, df, doms):
+    if mode == "base":
+        return []
+    if mode == "bare":
+        # 与 a1_norm 同源：同一函数、同一 df 表 → 严格复现四轴的 tags
+        return list(bz.normalize_terms(c, df))
+    d = doms.get(c["id"])
+    return [f"domain:{d}"] if d else []
+
+
+def build_domain_arm(corpus, name, mode, df, verbose=True):
+    """按臂建库。四臂唯一差异是 tags 内容（layer/正文/edges 全同）。"""
+    import shutil
+    from md_cg.mdcos import MdCGOS
+    root = os.path.join(HERE, ARM_PREFIX + name)
+    if os.path.isdir(root):
+        shutil.rmtree(root, ignore_errors=True)
+    cg = MdCGOS(root, autoflush=500)
+
+    doms = {c["id"]: write_domain(c) for c in corpus}
+    if mode == "shuf":
+        # 因果对照：把「有域」节点的域整体随机重排（保持域分布不变，
+        # 只破坏「域↔节点」的对应关系）→ 若增益消失，则增益来自正确的域。
+        present = [d for d in doms.values() if d]
+        random.Random(SEED).shuffle(present)
+        it = iter(present)
+        doms = {k: (next(it) if v else None) for k, v in doms.items()}
+
+    for c in corpus:
+        cg.add(c["id"], body_of(c), layer="knowledge",
+               tags=arm_tags(c, mode, df, doms),
+               eval_src=f"domax:{name}", verification_basis="data")
+    cg.flush()
+    if verbose:
+        h = routing.bucket_health(cg.index["buckets"])
+        verdict = "OK" if h["ok"] else "；".join(h["problems"])
+        print(f"  桶数={h['buckets']} 最大桶占比={h['max_bucket_share']:.1%} "
+              f"单例桶率={h['singleton_ratio']:.1%} 期望扫描={h['expected_scan']:.1%}"
+              f" → {verdict}")
+    return cg, doms
+
+
+# ------------------------------------------------------------------ 主流程
+
+def main():
+    corpus = list(ec.iter_jsonl(CORPUS567))
+    questions = list(ec.iter_jsonl(QUESTIONS500))
+    print(f"池 {len(corpus)} 条，题 {len(questions)} 道")
+
+    # 评测口径（与既有公开基准口径一致，否则不可比）
+    ec.unlock_global_cap()
+    ec.use_jaccard()
+
+    df = bz.build_tables(corpus)
+    qctx = {}
+    for q in questions:
+        d = query_domain(q)
+        qctx[q["qid"]] = {"tags": [f"domain:{d}"]} if d else None
+    n_ctx = sum(1 for v in qctx.values() if v)
+    print(f"查询侧落域 {n_ctx}/{len(questions)} = {n_ctx / len(questions):.1%}")
+
+    def context_of(q):
+        return qctx.get(q["qid"])
+
+    out = {"n_pool": len(corpus), "n_q": len(questions),
+           "q_with_domain": n_ctx, "seed": SEED, "cells": {}}
+    table = {}
+    t_all = time.time()
+    for name, mode in ARMS:
+        print(f"\n== 建库 {name}（mode={mode}）==")
+        cg, doms = build_domain_arm(corpus, name, mode, df)
+        ec.install_read_cache(cg)
+        entries = cg._candidates()
+
+        n_write_dom = sum(1 for v in doms.values() if v)
+        # 机制探针（白箱）：各路在本题上的非空数 —— 直接看该路是否真的活
+        ne = sum(1 for q in questions if qctx.get(q["qid"])
+                 and cg._path_bucket(q["question"], entries, qctx[q["qid"]]))
+        nf = sum(1 for q in questions
+                 if cg._path_fuzzy(q["question"], entries,
+                                   qctx.get(q["qid"]))[0])
+        print(f"  写入侧落域 {n_write_dom}/{len(corpus)} = "
+              f"{n_write_dom / len(corpus):.1%}；bucket 路非空 {ne}/{n_ctx}；"
+              f"fuzzy 路非空 {nf}/{len(questions)}")
+
+        for paths in PATHSETS:
+            pk = ",".join(paths)
+            rows = ec.evaluate_group(cg, questions, k=5, paths=paths,
+                                     context_of=context_of, verbose=False)
+            s = ec.summarize(rows, k=5)
+            s["write_with_domain"] = n_write_dom
+            s["bucket_nonempty"] = ne
+            s["bucket_ctx_total"] = n_ctx
+            out["cells"][f"{name}|{pk}"] = s
+            table[f"{name:<8} {pk:<22}"] = s
+            print(f"  {pk:<22} hit@1={s['hit@1']:>6.1%} "
+                  f"hit@5={s['hit@5']:>6.1%} MRR={s['mrr']:.4f}")
+
+    ec.print_table(f"域轴单变量消融（池 {len(corpus)} / 题 {len(questions)}，"
+                   f"jaccard + GLOBAL_CAP 解除）", table, k=5)
+    out["elapsed_s"] = round(time.time() - t_all, 1)
+    ec.save_result("axis_domain_locomo_zh.json", out)
+
+    # ---- 裁决摘要 ----
+    def cell(a, p):
+        return out["cells"].get(f"{a}|{p}", {})
+
+    print("\n== 裁决 ==")
+    d0 = cell("d0_base", "lexical")
+    d1 = cell("d1_bare", "lexical,entity")
+    d2 = cell("d2_dom", "lexical,bucket")
+    d3 = cell("d3_shuf", "lexical,bucket")
+    if d0 and d1:
+        print(f"  1) 裸词 tags（entity 路）   ：hit@1 {d0['hit@1']:.1%} → "
+              f"{d1['hit@1']:.1%}（Δ {d1['hit@1'] - d0['hit@1']:+.1%}）")
+    if d0 and d2:
+        print(f"  2) domain: tags（bucket 路）：hit@1 {d0['hit@1']:.1%} → "
+              f"{d2['hit@1']:.1%}（Δ {d2['hit@1'] - d0['hit@1']:+.1%}）")
+    if d2 and d3:
+        print(f"  3) 打乱域对照（d2 vs d3）  ：hit@1 {d2['hit@1']:.1%} vs "
+              f"{d3['hit@1']:.1%}（Δ {d3['hit@1'] - d2['hit@1']:+.1%}）")
+    f0 = cell("d0_base", "lexical,fuzzy")
+    f2 = cell("d2_dom", "lexical,fuzzy")
+    if d0 and f0:
+        print(f"  4) 同义查找（fuzzy 路）    ：hit@1 {d0['hit@1']:.1%} → "
+              f"{f0['hit@1']:.1%}（Δ {f0['hit@1'] - d0['hit@1']:+.1%}）")
+    if f0 and f2:
+        print(f"  5) domain: 标签激活 fuzzy 大域亲和：{f0['hit@1']:.1%} → "
+              f"{f2['hit@1']:.1%}（Δ {f2['hit@1'] - f0['hit@1']:+.1%}）")
+    print(f"  总耗时 {out['elapsed_s']}s")
+
+
+if __name__ == "__main__":
+    main()

package/md_cg/bench_lme_zh.py

@@ -0,0 +1,396 @@
+# -*- coding: utf-8 -*-
+"""LongMemEval-S 中文结构层小样本探针（默认 20 题 gold + 180 干扰 = 池 200）。
+
+被测假设（用户提出）：写入时把英文 turn「翻译为结构化中文」，让中文查询也能
+零-LLM 检索；同时保留英文原文供词法路，避免「翻译即断链」。
+
+先验（eval_common.calibrate_turn 注释）：v1 五要素模板是**同质模板词**，
+抽样 3.3% < legacy 16% —— 同质模板对词法是净稀释。故中文层设计红线：
+  · 只放**特异词**（人名/日期/实体/意图/主题），禁「用户/会话/记录/关于」等同质词；
+  · 极短（≤60 汉字），不加任何固定槽位前缀（前缀=全体同质词=纯稀释）；
+  · 英文原文一字不动，中文层是**附加**而非替换。
+
+四臂（只变 写入内容 / 查询语言，其余全同）：
+  A legacy   裸文本                + 英文原问
+  B jaccard  裸文本                + 英文原问   ← 已修底座
+  C jaccard  裸文本 + 中文层(20条)  + 英文原问   ← 测「稀释」
+  D jaccard  裸文本 + 中文层(20条)  + 中文问     ← 测「增益」
+
+池 200 条 = 20 条 gold（20 题各取 evidence_turns[0]）+ 180 条随机干扰。
+随机基线 hit@1 = 20/200 = 10%（报告须以此为参照，不能只看 0 个百分点）。
+
+跑法：
+    python -m md_cg.bench_lme_zh --build        # 采样池 + 调 LLM 生成中文层（落缓存）
+    python -m md_cg.bench_lme_zh                # 四臂评测
+    python -m md_cg.bench_lme_zh --n-q 20 --n-distract 180
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import random
+import re
+import shutil
+import sys
+import time
+from concurrent.futures import ThreadPoolExecutor
+
+from md_cg import eval_common as ec
+from md_cg.bench_longmem import GROUPS
+
+MODEL = os.environ.get("ZH_PROBE_MODEL") or "deepseek-flash"
+BASE = "https://api.deepseek.com/v1"
+DIR = os.path.join(ec.EXT, "zh_probe")
+POOL = os.path.join(DIR, "pool.jsonl")
+CACHE = os.path.join(DIR, "cache.json")
+# 中文层 / 中文查询词的**真源文件**：由会话模型直接产出并落盘，脚本只读。
+MAN_ZH = os.path.join(DIR, "manual_zh.json")
+MAN_Q = os.path.join(DIR, "manual_q.json")
+ROOT_A = os.path.join(ec.HERE, "_md_cg_eval_zhprobe_a")
+# 版本化 root：写入加工改版必须换名。build_eval_cg 的幂等按**节点数**判断
+# （have >= n_rows），同节点数的旧加工库会被静默复用——首轮 C 臂就会因此
+# 拿到旧的「整句翻译」中文层，实验白跑。
+ROOT_C = os.path.join(ec.HERE, "_md_cg_eval_zhprobe_c2_bag")
+# 「中文层做唯一索引、原文只做载荷」架构的验证库：正文只放中文层，英文原文不入库。
+ROOT_E = os.path.join(ec.HERE, "_md_cg_eval_zhprobe_e_zhonly")
+ROOT_F = os.path.join(ec.HERE, "_md_cg_eval_zhprobe_f_zhpool")
+POOL20 = os.path.join(DIR, "pool20.jsonl")     # 只含 20 条 gold（隔离语言隔离假象）
+
+# 探针实测（2026-09-11）三则：
+#  1) deepseek-flash / deepseek-v4-pro **均为推理模型**（简单任务 reasoning_tokens
+#     就占 36/38）。**长 prompt 让推理失控**：「6 条硬约束+示例」版在
+#     max_tokens=2000 时 completion 全烧在 reasoning 上、content 返回空串
+#     （finish_reason=length）→ prompt 必须极短，额度须 ≥1200。
+#  2) 首版 prompt「译成中文检索词」被模型理解成**整句翻译**（均 89.9 字，且带
+#     「用户/我/的」等同质词）→ 实测 C 15% < B 20%，即**净稀释**。本轮改真词袋。
+#  3) 写入侧若是词袋，查询侧必须**同样词袋化**（自然语言长句与词袋的 bigram 交集
+#     很小）→ 否则两侧不同源，「翻译即断链」的变体。
+# 另：首轮 zh_question 只给 max_tokens=120 → 推理烧空 content → 静默 fallback
+# 英文原问，导致 D 臂逐项等于 C 臂（假结论）。额度不足即为该类静默失效的根源。
+ZH_PROMPT = """从下面英文里抽出中文关键词：只输出名词与动词的中文词，逗号分隔，一行。不要句子、不要「我/你/的/了/是/在」这类虚词、不要解释。英文：
+"""
+
+ZH_Q_PROMPT = """从下面英文问题里抽出中文关键词：只输出名词与动词的中文词，逗号分隔，一行。不要句子、不要虚词、不要解释。问题："""
+
+
+# ------------------------------------------------------------------ LLM
+def _llm(messages, max_tokens=400, retries=3):
+    from md_cg.bench_task_ab_llm import llm_chat
+    key = os.environ.get("DEEPSEEK_API_KEY")
+    if not key:
+        raise RuntimeError("需要 DEEPSEEK_API_KEY")
+    last = None
+    for i in range(retries):
+        try:
+            content, usage, dt = llm_chat(MODEL, BASE, key, messages,
+                                          timeout=120, max_tokens=max_tokens,
+                                          temperature=0.0)
+            return content, usage
+        except Exception as exc:                     # noqa: BLE001
+            last = exc
+            time.sleep(1.5 * (i + 1))
+    raise RuntimeError(f"LLM 调用失败：{type(last).__name__}: {last}")
+
+
+# 条件空间字段名：中文标签 → eval_common 口径
+_COND_KEYS = {"观测位置": "observation_position", "观测工具": "observation_tool",
+              "时间窗口": "time_window", "存在约束": "existence_constraint"}
+_DEFAULT_COND = {"observation_position": "会话陈述", "observation_tool": "会话记录",
+                 "existence_constraint": "公开"}
+
+
+def _load_json(p):
+    if os.path.isfile(p):
+        with open(p, encoding="utf-8") as f:
+            return json.load(f)
+    return {}
+
+
+def _load_manual():
+    """读入会话模型直接产出的中文层 / 中文查询词（零 API 依赖）。
+
+    为什么不由本脚本调 LLM：探针实测（2026-09-11）deepseek-flash 与
+    deepseek-v4-pro **都是推理模型**，该任务上 completion 全烧在 reasoning
+    上、content 返回空串（首轮 0/20；次轮 13/20 且形态是整句翻译）。故改为
+    会话模型本人产出并落盘、脚本只读文件——顺带消除「额度不足 → 静默
+    fallback 成英文原问」这类失效模式（次轮 D 臂逐项等于 C 臂即由此而来）。
+    """
+    return _load_json(MAN_ZH), _load_json(MAN_Q)
+
+
+def _cond_of(z):
+    """从中文层的「条件=观测位置:…|观测工具:…|…」抽条件空间 dict。"""
+    m = re.search(r"条件=([^；;]+)", z or "")
+    if not m:
+        return None
+    out = {}
+    for part in re.split(r"[|｜]", m.group(1)):
+        kv = re.split(r"[:：]", part, 1)
+        if len(kv) == 2 and kv[0].strip() in _COND_KEYS:
+            out[_COND_KEYS[kv[0].strip()]] = kv[1].strip()
+    return out or None
+
+
+def _load_cache():
+    if os.path.isfile(CACHE):
+        with open(CACHE, encoding="utf-8") as f:
+            return json.load(f)
+    return {}
+
+
+def _save_cache(c):
+    os.makedirs(DIR, exist_ok=True)
+    with open(CACHE, "w", encoding="utf-8") as f:
+        json.dump(c, f, ensure_ascii=False, indent=1)
+
+
+def zh_layer(turn, cache):
+    """一条 turn → 中文词袋。缓存 key 带版本号：prompt 改版必须失效旧缓存。
+
+    不传 speaker：角色标签（user/assistant）是**全体同质词**，翻成「用户」只会
+    稀释词法信号（首轮实测即如此）。date 保留——它是特异词。
+    """
+    key = "L2:" + turn["id"]
+    if key in cache:
+        return cache[key]
+    msg = [{"role": "user", "content":
+            ZH_PROMPT + json.dumps({"date": turn.get("date"),
+                                    "text": turn.get("text")},
+                                   ensure_ascii=False)}]
+    s = ""
+    for mt in (1200, 2600):          # 推理模型额度被 reasoning 吃光 → 空 content，故加额重试
+        content, _u = _llm(msg, max_tokens=mt)
+        s = content or ""
+        s = re.sub(r"```.*?```", " ", s, flags=re.S)
+        s = re.sub(r"(人物|日期|实体|意图|主题)\s*[:：|]", " ", s)
+        s = " ".join(s.split()).strip(" ,，、|")
+        if s:
+            break
+    cache[key] = s
+    return s
+
+
+def zh_question(q, cache):
+    """英文问题 → 中文关键词（与写入侧同源；额度须 ≥1200，否则推理烧空 content）。"""
+    key = "Q2:" + q["qid"]
+    if key in cache:
+        return cache[key]
+    content, _u = _llm([{"role": "user",
+                         "content": ZH_Q_PROMPT + q["question"]}], max_tokens=1200)
+    s = re.sub(r"```.*?```", " ", content or "", flags=re.S)
+    cache[key] = " ".join(s.split()).strip(" ,，、")
+    if not cache[key]:
+        raise RuntimeError("查询侧关键词为空（额度被 reasoning 吃光）")
+    return cache[key]
+
+
+# ------------------------------------------------------------------ 池
+def build_pool(n_q, n_distract, seed=7):
+    """采样：n_q 题（分组覆盖）各取 evidence_turns[0] 为 gold，再取干扰。"""
+    if os.path.isfile(POOL):
+        with open(POOL, encoding="utf-8") as f:
+            return [json.loads(l) for l in f if l.strip()]
+    rows = list(ec.iter_jsonl(ec.LM_H))
+    byid = {r["id"]: r for r in rows}
+    qs = ec.load_questions("lm")
+    rng = random.Random(seed)
+    per = max(1, n_q // len(GROUPS))
+    picked, gold_ids, chosen = [], set(), []
+    for gname in GROUPS:
+        qtypes = GROUPS[gname]
+        cand = [q for q in qs if q["qtype"] in qtypes and q.get("evidence_turns")]
+        rng.shuffle(cand)
+        for q in cand:
+            if len([p for p in picked if p["_g"] == gname]) >= per:
+                break
+            tid = q["evidence_turns"][0]
+            if tid not in byid or tid in gold_ids:
+                continue
+            gold_ids.add(tid)
+            picked.append({**byid[tid], "_g": gname, "_gold": True})
+            chosen.append(q)
+    pool = list(picked)
+    rest = [r for r in rows if r["id"] not in gold_ids]
+    pool += rng.sample(rest, min(n_distract, len(rest)))
+    os.makedirs(DIR, exist_ok=True)
+    with open(POOL, "w", encoding="utf-8") as f:
+        for r in pool:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+    with open(os.path.join(DIR, "questions.json"), "w", encoding="utf-8") as f:
+        json.dump(chosen, f, ensure_ascii=False, indent=1)
+    return pool
+
+
+def load_questions_zh():
+    with open(os.path.join(DIR, "questions.json"), encoding="utf-8") as f:
+        return json.load(f)
+
+
+# ------------------------------------------------------------------ 建库 / 评测
+def build(root, pool, zh_of=None, rebuild=False, zh_only=False, corpus=None):
+    """zh_of: turn_id → 中文层；None = 裸文本库。
+
+    zh_only=True → **纯中文索引**：正文只放中文层，英文原文不入库（供「中文检索、
+    原文只做载荷回填」架构验证）。无中文层的行退化为裸英文——本轮 180 条干扰项
+    未译，故 E 臂存在「语言隔离」：中文查询几乎不可能命中英文干扰项，其 hit 是
+    上界而非全译库真值。故另设 F 臂（池只含 20 条 gold、正文全中文）隔离该假象，
+    单测中文层自身的可区分性。
+    """
+    def calib(r, ctx=None):
+        z = zh_of.get(r["id"]) if zh_of else None
+        cs = dict(_DEFAULT_COND)
+        if z:
+            cs = _cond_of(z) or cs      # 条件空间逐条来自中文层，而非全局写死
+        if zh_only:
+            return (z or ec.lm_turn_text(r)), [], cs
+        body = ec.lm_turn_text(r)
+        if z:
+            body = body + "\n" + z
+        return body, [], cs
+    return ec.build_eval_cg(None, root, corpus or POOL, ec.lm_turn_text, "lmezh",
+                            calib_of=calib if zh_of else None, rebuild=rebuild)
+
+
+def eval_arm(cg, questions, qtext_of, k=5):
+    rows = []
+    for q in questions:
+        qq = dict(q)
+        qq["question"] = qtext_of(q)
+        rows += ec.evaluate_group(cg, [qq], k=k, paths=ec.PATHS, verbose=False)
+    return ec.summarize(rows, k=k)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--n-q", type=int, default=20)
+    ap.add_argument("--n-distract", type=int, default=180)
+    ap.add_argument("--k", type=int, default=5)
+    ap.add_argument("--build", action="store_true", help="只生成池与中文层")
+    ap.add_argument("--rebuild", action="store_true")
+    ap.add_argument("--workers", type=int, default=6)
+    args = ap.parse_args()
+
+    pool = build_pool(args.n_q, args.n_distract)
+    golds = [r for r in pool if r.get("_gold")]
+    qs = load_questions_zh()
+    print(f"池 {len(pool)} 条（gold {len(golds)} / 干扰 "
+          f"{len(pool) - len(golds)}），题 {len(qs)} 道，随机基线 hit@1="
+          f"{len(golds) / len(pool):.1%}")
+
+    cache = _load_cache()
+    man_zh, man_q = _load_manual()
+    for tid, v in man_zh.items():        # 会话模型产出 → 直接进缓存，零 API
+        cache["L2:" + tid] = v
+    for qid, v in man_q.items():
+        cache["Q2:" + qid] = v
+    print(f"中文层：本地 {len(man_zh)} 条（查询词本地 {len(man_q)} 条），"
+          f"缓存合计 {len(cache)} 条，模型 {MODEL}（本轮不调用）")
+
+    def work(r):
+        try:
+            return r["id"], zh_layer(r, cache), None
+        except Exception as exc:                      # noqa: BLE001
+            return r["id"], "", f"{type(exc).__name__}: {exc}"
+
+    zh = {}
+    with ThreadPoolExecutor(max_workers=args.workers) as ex:
+        for i, (tid, s, err) in enumerate(ex.map(work, golds), 1):
+            if err:
+                print(f"  [{i}/{len(golds)}] {tid} 失败：{err}")
+            else:
+                zh[tid] = s
+    _save_cache(cache)
+    okzh = [v for v in zh.values() if v]
+    print(f"中文层成功 {len(okzh)}/{len(golds)}，平均长度 "
+          f"{sum(len(v) for v in okzh) / max(1, len(okzh)):.1f} 字")
+    for t in okzh[:5]:
+        print("   ·", t[:110])
+
+    if args.build:
+        print("（--build 只生成，不评测）")
+        return
+    if not okzh:
+        print("中文层为空，终止")
+        return 1
+
+    qzh = {}
+    for q in qs:
+        try:
+            qzh[q["qid"]] = zh_question(q, cache)
+        except Exception as exc:                      # noqa: BLE001
+            print(f"  问题翻译失败 {q['qid']}：{exc}")
+            qzh[q["qid"]] = q["question"]
+    _save_cache(cache)
+
+    en = lambda q: q["question"]
+    zhq = lambda q: qzh.get(q["qid"]) or q["question"]
+
+    # 只含 gold 的 20 条池：E 臂的「语言隔离」假象在其中被消除（全部是中文文档）
+    with open(POOL20, "w", encoding="utf-8") as f:
+        for r in golds:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+
+    import md_cg.mdcg as m
+    results = {}
+    arms = (
+        ("A legacy  裸+英问", ROOT_A, POOL, False, False, en, "legacy"),
+        ("B jaccard 裸+英问", ROOT_A, POOL, False, False, en, "jaccard"),
+        ("C jaccard 中+英问", ROOT_C, POOL, True, False, en, "jaccard"),
+        ("D jaccard 中+中问", ROOT_C, POOL, True, False, zhq, "jaccard"),
+        ("E 纯中索引+中问", ROOT_E, POOL, True, True, zhq, "jaccard"),
+        ("F 纯中池+中问", ROOT_F, POOL20, True, True, zhq, "jaccard"),
+        ("G 纯中池+英问", ROOT_F, POOL20, True, True, en, "jaccard"),
+    )
+    for tag, root, corpus, usezh, zonly, qf, mode in arms:
+        m.SCORE_MODE = mode
+        cg = build(root, pool, zh_of=zh if usezh else None, rebuild=args.rebuild,
+                   zh_only=zonly, corpus=corpus)
+        ec.install_read_cache(cg)
+        results[tag] = eval_arm(cg, qs, qf, k=args.k)
+        print(f"  {tag}: hit@1 {results[tag]['hit@1']:.1%} "
+              f"hit@{args.k} {results[tag][f'hit@{args.k}']:.1%} "
+              f"MRR {results[tag]['mrr']:.3f}")
+
+    # 命中后回填原始英文原文：原文不进索引、只做载荷 → 验证「中文检索→英文返回」链路
+    m.SCORE_MODE = "jaccard"
+    cg_e = build(ROOT_E, pool, zh_of=zh, corpus=POOL, zh_only=True)
+    ec.install_read_cache(cg_e)
+    payload = {r["id"]: ec.lm_turn_text(r) for r in pool}
+    line = results["E 纯中索引+中问"]["score_p10"]
+    print(f"\n回填验证（中文命中 → 确认匹配 → 返回英文原文；原文不在索引内）："
+          f"\n  匹配确认线 = 正例 Top-1 分 p10 = {line:.4f}"
+          f"（低于线判未匹配，不回填原文）")
+    conf_n = conf_hit = 0
+    for q in qs:
+        res, _meta = ec.run_query(cg_e, zhq(q), k=1, paths=ec.PATHS)
+        sc = res[0][1] if res else 0.0
+        if sc >= line:
+            conf_n += 1
+            if ec.first_evidence_rank(res, set(q.get("evidence_turns") or [])):
+                conf_hit += 1
+    print(f"  确认匹配 {conf_n}/{len(qs)} 题，其中真命中 {conf_hit} → "
+          f"确认后精度 {conf_hit / max(1, conf_n):.1%}")
+    for q in qs[:2]:
+        res, _meta = ec.run_query(cg_e, zhq(q), k=2, paths=ec.PATHS)
+        print(f"  中文查询: {zhq(q)}")
+        for it in res[:2]:
+            nid, sc = it[0]["id"], it[1]
+            verdict = "确认匹配→回填" if sc >= line else "未确认→不回填"
+            print(f"   · {nid} 分={sc:.4f} [{verdict}] 载荷原文: "
+                  f"{payload.get(nid, '')[:70]}")
+
+    ec.print_table("LongMemEval-S 中文层探针（%d 题 / 池 %d）"
+                   % (len(qs), len(pool)), results, k=args.k)
+    ec.save_result("zh_probe.json", {
+        "dataset": "LongMemEval-S slice", "model": MODEL,
+        "pool": len(pool), "n_q": len(qs), "baseline_hit1": len(golds) / len(pool),
+        "arms": results,
+        "zh_layer_samples": okzh[:20],
+        "questions_zh": qzh,
+    })
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())