@furongjun1999/dsh-memory 0.4.6 → 0.4.7

package/md_cg/test_ccg_perturb.py

@@ -0,0 +1,184 @@
+# -*- coding: utf-8 -*-
+"""条件扰动反事实实验（P-T-42/43 · 理论仓 §15 命题的可执行化）。
+
+理论命题（docs/智能的公理化基石.md §15 + 附录二可证伪标准）：
+  「如果保持候选能力不变，只改变条件词，路由归属按条件发生变化，
+    那么路由控制因素就是条件，而不是单纯的语义相似度。」
+  可证伪口径：在保持候选能力不变、仅改变条件词的实验中，
+  路由结果不按条件变化 → 命题被推翻。
+
+本测试把该命题落为确定性反事实对照（tempdir，可复现）：
+  ① 结果变：同一节点，条件词互换 → judge 四态翻转（ACCEPT↔REJECT/DEFER），3/3 组
+  ② 路由变：两节点正文逐字相同（除条件行）、仅条件空间域词不同 → bucket 不同，
+     且镜像对称（互换构造后桶恰好互换）
+  ③ 计划变：检索路线（T0/T1 桶路 ↔ T2/T3 全局路）与 top1 归属随条件词切换；
+     无路由对照下两候选得分完全相等——「分数相同、归属不同」即路由控制因素
+     =条件的直接证据（相似度无法区分它们）
+  ④ 混合条件 BLINDSPOT：条件声明不完整（CCG 要素残缺）→ BLINDSPOT（停止猜测）；
+     如实边界：要素齐全但条件行混域词面 → 非 BLINDSPOT（当前判定序无矛盾检测）
+
+运行：python -m md_cg.test_ccg_perturb
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import tempfile
+
+from .mdcg import (STATE_ACCEPT, STATE_BLINDSPOT, STATE_DEFER, STATE_REJECT,
+                   MdCG, TIER_BUCKET_LIKE, TIER_BUCKET_SCAN,
+                   TIER_GLOBAL_LIKE, TIER_GLOBAL_SCAN)
+from .nodefile import condition_space_text
+
+PASS = FAIL = 0
+FAILS = []
+
+# 3 组条件域对（3/3 切换口径）：域词 ≥2 字（_cond_terms 滤 len<2）
+PAIRS = [("电路", "光学"), ("离线", "在线"), ("急救", "保健")]
+
+
+def ok(cond, label):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+    else:
+        FAIL += 1
+        FAILS.append(label)
+        print(f"  FAIL {label}")
+
+
+def node_body(domain: str, other: str, *, mix: bool = False,
+              drop_exec: bool = False) -> str:
+    """CCG 六要素正文。除条件两行外逐字相同（能力不变口径）：
+    生效条件由 condition_space_text 四槽合成（唯一入口，不手写冒充），
+    域词同时落在观测位置与约束槽，供 judge 正条件词面确认。"""
+    cs = {"observation_position": f"{domain}实验台",
+          "time_window": [0.0, 9999999999.0],
+          "observation_tool": "规程走查",
+          "existence_constraint": f"{domain}域，台面设备"}
+    eff = condition_space_text(cs)
+    assert eff, "四槽不全不构成生效条件（fail-closed）"
+    cond_line = f"# 生效条件：{eff}"
+    if mix:  # 混合域词面（要素齐全，用于④边界断言）
+        cond_line += f"与{other}混合域"
+    lines = [f"# 功能名：域路由实验规程\n\n",
+             f"本规程在声明条件域内执行标准检查流程，输出结论与依据。\n\n",
+             cond_line + "\n\n",
+             f"# 子功能：条件识别；规程执行；结论输出\n\n",
+             f"# 执行：确认条件域 → 执行规程 → 输出结论\n\n",
+             f"# 验证方式：规程执行结果落在声明条件域内即通过（measurement）\n\n",
+             f"# 不适用条件：{other}\n"]
+    if drop_exec:
+        lines = [l for l in lines if not l.startswith("# 执行：")]
+    return "".join(lines)
+
+
+def strip_cond_lines(content: str) -> str:
+    """剥条件两行——「能力不变」的对照口径。"""
+    return "\n".join(l for l in content.splitlines()
+                     if not (l.startswith("# 生效条件：")
+                             or l.startswith("# 不适用条件：")))
+
+
+def _node(domain: str, other: str, **kw) -> dict:
+    """judge 单元测输入：fm 显式负条件（不依赖盘上解析形态）。"""
+    return {"frontmatter": {"verification_basis": "measurement",
+                            "non_applicable_conditions": [other]},
+            "content": node_body(domain, other, **kw)}
+
+
+def run(verbose: bool = False):
+    global PASS, FAIL
+    # ---------- ① 结果变：条件词互换 → judge 四态翻转（3/3） ----------
+    for x, y in PAIRS:
+        jx = MdCG.judge_qualification(_node(x, y), f"问{x}域的规程", None)
+        jy = MdCG.judge_qualification(_node(x, y), f"问{y}域的规程", None)
+        ok(jx["state"] == STATE_ACCEPT and "生效条件已确认" in jx["reason"],
+           f"①[{x}/{y}] 本域情境 → ACCEPT（reason 记录命中）")
+        ok(jy["state"] == STATE_REJECT,
+           f"①[{x}/{y}] 反域情境 → REJECT（负条件命中，翻转①结果变）")
+        # 镜像节点对称：条件词互换后判定恰好互换
+        mjx = MdCG.judge_qualification(_node(y, x), f"问{x}域的规程", None)
+        mjy = MdCG.judge_qualification(_node(y, x), f"问{y}域的规程", None)
+        ok(mjx["state"] == STATE_REJECT and mjy["state"] == STATE_ACCEPT,
+           f"①[{x}/{y}] 镜像节点判定对称（双向反事实）")
+    # 无验证基底 → 反域下 DEFER 而非 REJECT 的次序确认（负条件优先于基底检查）
+    naker = {"frontmatter": {"non_applicable_conditions": ["光学"]},
+             "content": node_body("电路", "光学")}
+    j = MdCG.judge_qualification(naker, "问光学域的规程", None)
+    ok(j["state"] == STATE_REJECT, "①负条件 REJECT 先于验证基底 DEFER（判定序）")
+
+    # ---------- ②③ 写入库 + 路由变 + 计划变（链路） ----------
+    root = tempfile.mkdtemp(prefix="mdcg_ccg_perturb_")
+    try:
+        cg = MdCG(root)
+        buckets = {}
+        for i, (x, y) in enumerate(PAIRS):
+            for side, (dom, oth) in ((f"{i}a", (x, y)), (f"{i}b", (y, x))):
+                nid = f"perturb_{side}_{dom}"
+                cg.add(nid, node_body(dom, oth), layer="knowledge",
+                       tags=[f"domain:{dom}"], condition_space=None,
+                       verification_basis="measurement")
+                e = cg.index["nodes"].get(nid) or {}
+                buckets[nid] = e.get("bucket")
+        # ② 路由变：同能力（剥条件行后逐字相同）、不同条件域 → 不同桶
+        for i, (x, y) in enumerate(PAIRS):
+            a, b = f"perturb_{i}a_{x}", f"perturb_{i}b_{y}"
+            ca = strip_cond_lines(cg.get(a)["content"])
+            cb = strip_cond_lines(cg.get(b)["content"])
+            ok(ca == cb, f"②[{x}/{y}] 两节点剥条件行后正文逐字相同（能力不变）")
+            ok(buckets[a] and buckets[b] and buckets[a] != buckets[b],
+               f"②[{x}/{y}] 条件域词不同 → 路由桶不同（路由归属按条件变化）")
+        # ③ 计划变：检索路线与 top1 归属随条件词切换
+        # （context 带 tags 定路由桶 + scene 域词面供正条件确认——两者同属情境）
+        for i, (x, y) in enumerate(PAIRS):
+            a, b = f"perturb_{i}a_{x}", f"perturb_{i}b_{y}"
+            res, meta = cg.search("问实验规程", k=5, record=False,
+                                  context={"tags": [f"domain:{x}"],
+                                           "scene": f"{x}域情境检查"})
+            ok(meta["tier"] in (TIER_BUCKET_LIKE, TIER_BUCKET_SCAN),
+               f"③[{x}/{y}] 条件路由开启 → T0/T1 桶路（检索路线随条件变）")
+            ok(bool(res) and res[0][0]["id"] == a,
+               f"③[{x}/{y}] {x} 情境 → top1={a}")
+            ok(res and res[0][2]["state"] == STATE_ACCEPT,
+               f"③[{x}/{y}] top1 资格 ACCEPT（条件已确认）")
+            res2, meta2 = cg.search("问实验规程", k=5, record=False,
+                                    context={"tags": [f"domain:{y}"],
+                                             "scene": f"{y}域情境检查"})
+            ok(bool(res2) and res2[0][0]["id"] == b,
+               f"③[{x}/{y}] {y} 情境 → top1={b}（归属随条件切换）")
+            # 无路由对照：context=None → 全局路；同文两候选得分完全相等
+            res3, meta3 = cg.search("问实验规程", k=8, record=False, context=None)
+            ok(meta3["tier"] in (TIER_GLOBAL_LIKE, TIER_GLOBAL_SCAN),
+               f"③[{x}/{y}] 无情境 → T2/T3 全局路（路由关闭对照）")
+            sc = {r[0]["id"]: r[1] for r in res3}
+            ok(a in sc and b in sc and abs(sc[a] - sc[b]) < 1e-9,
+               f"③[{x}/{y}] 无路由时两候选得分相等——"
+               f"相似度无法区分，归属由条件决定（命题直接证据）")
+        # ④ 混合条件 BLINDSPOT
+        j = MdCG.judge_qualification(
+            _node("电路", "光学", drop_exec=True), "问电路域的规程", None)
+        ok(j["state"] == STATE_BLINDSPOT and "CCG 要素不全" in j["reason"],
+           "④条件声明不完整（缺执行要素）→ BLINDSPOT 停止猜测")
+        j = MdCG.judge_qualification(
+            _node("电路", "光学", mix=True), "问电路域的规程", None)
+        ok(j["state"] == STATE_ACCEPT,
+           "④边界（如实）：要素齐全+混域词面 → 非 BLINDSPOT（判定序无矛盾检测）")
+        cg.close()
+    finally:
+        shutil.rmtree(root, ignore_errors=True)
+
+    if verbose or FAIL:
+        print(f"ccg_perturb: {PASS} passed, {FAIL} failed")
+        for f in FAILS:
+            print(f"  - {f}")
+    return FAIL == 0
+
+
+def main():
+    okall = run(verbose=True)
+    raise SystemExit(0 if okall else 1)
+
+
+if __name__ == "__main__":
+    main()

package/md_cg/test_census_prune.py

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+"""PR #15 census 归档区剪枝探针（脚本式，exit code 定成败）。
+
+用法：python -X utf8 -m md_cg.test_census_prune
+覆盖：
+- ARCHIVE_DIRS 五个目录整体剪枝（含 _protected_history/<id>/<ts>.md 两层下钻）
+- _protected_history_* 前缀目录剪枝
+- 普通子目录不误伤
+- 无 frontmatter 的散落 md 仍被跳过（既有语义保持）
+- 真实库（data/mdcg）上活跃数不再被墓碑/快照稀释
+"""
+import os
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from md_cg import census  # noqa: E402
+
+FM = "---\nid: {nid}\nlayer: knowledge\n---\n正文\n"
+passed = 0
+
+
+def check(name, cond, detail=""):
+    global passed
+    if cond:
+        passed += 1
+        print("  [PASS] " + name)
+    else:
+        print("  [FAIL] " + name + "  " + detail)
+
+
+def main():
+    root = tempfile.mkdtemp(prefix="census_prune_")
+    nodes = {
+        # (相对路径, 是否活跃)
+        ("act_root.md", True),
+        ("sub", "act_sub.md", True),          # 普通子目录不误伤
+        ("trash", "t1.md", False),
+        ("_protected_history", "n1", "20260101_000000.md", False),  # 两层下钻
+        ("_protected", "p1.md", False),
+        ("_index_log", "i1.md", False),
+        ("hippocampus", "h1.md", False),
+        ("_protected_history_extra", "x.md", False),  # 前缀分支
+        ("note.md", None),                    # 无 frontmatter 散落文档 → 跳过
+    }
+    for n in nodes:
+        parts = [p for p in n if p is not True and p is not False and p is not None]
+        active = n[-1] is True
+        rel = os.path.join(*parts) if parts else "note.md"
+        p = os.path.join(root, rel)
+        os.makedirs(os.path.dirname(p), exist_ok=True)
+        with open(p, "w", encoding="utf-8") as f:
+            f.write("" if n[-1] is None else FM.format(nid=os.path.splitext(parts[-1])[0]))
+    rows = census.load(root)
+    ids = sorted(r[0] for r in rows)
+    check("仅活跃节点入普查（2 个）", ids == ["act_root", "act_sub"], str(ids))
+    for bad in ("t1", "p1", "i1", "h1", "x", "20260101_000000"):
+        check(f"归档区 {bad} 被剪枝", bad not in ids, str(ids))
+
+    # 真实库对比：PR 版活跃数 vs 全遍历数（含归档区）
+    real = os.path.join(os.path.dirname(os.path.dirname(
+        os.path.abspath(__file__))), "data", "mdcg")
+    if os.path.isdir(real):
+        n_active = len(census.load(real))
+        n_all = sum(1 for dp, _ds, fs in os.walk(real) for f in fs
+                    if f.endswith(".md"))
+        print(f"\n  真实库 {real}")
+        print(f"  PR 版活跃节点 {n_active} / 全遍历 {n_all}"
+              f"（归档区剪掉 {n_all - n_active}）")
+        check("真实库剪枝后不再被墓碑稀释", n_active < n_all,
+              f"{n_active} vs {n_all}")
+
+    print(f"\ntest_census_prune: {passed} 断言通过")
+    return 0 if passed >= 7 else 1
+
+
+if __name__ == "__main__":
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8")
+    sys.exit(main())

package/md_cg/test_cond_match.py

@@ -0,0 +1,165 @@
+# -*- coding: utf-8 -*-
+"""正条件参与资格判定（judge_qualification v2 · 设计态验收）。
+
+背景（外部评审 + 取证结论）：v1 的 ACCEPT 只查「六要素齐全 + 负条件未命中 +
+验证基底已声明」，**生效条件（正条件）完全不参与匹配**——「没发现拒绝理由」
+被冒充成「确认适用」。v2 补上正条件确认：
+
+  ① 情境 = query + context 合成；情境为空 → 跳过正条件段不降级
+     （「无情境」不能被误判成「不适用」，保 v1 兼容）。
+  ② 生效条件词面（剥槽标签、按短语切、滤全时窗哨兵）任一命中情境 → 确认。
+  ③ 有情境且一条都不命中 → DEFER（reason 点名未命中的条件短语）。
+  ④ 整行「无条件」声明 → 合法豁免。
+  ⑤ search→_emit 链路把 query 贯通进 judge（v1 恒传空串）。
+
+运行：python -m md_cg.test_cond_match
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import tempfile
+
+from .mdcg import (STATE_ACCEPT, STATE_BLINDSPOT, STATE_DEFER, STATE_REJECT,
+                   MdCG)
+from .mdcos import MdCGOS
+
+PASS = FAIL = 0
+FAILS = []
+
+
+def ok(cond, label):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+    else:
+        FAIL += 1
+        FAILS.append(label)
+        print(f"  FAIL {label}")
+
+
+def _doc(cond_line="# 生效条件：问浮力", neg_line="# 不适用条件：问完全无关主题"):
+    return ("# 功能名：浮力计算\n" + cond_line + "\n# 子功能：按阿基米德原理算\n"
+            "# 执行：代入公式\n# 验证方式：编译器/静态检查通过\n" + neg_line + "\n")
+
+
+def _node(fm_extra=None, doc=None):
+    fm = {"verification_basis": "compiler"}
+    if fm_extra:
+        fm.update(fm_extra)
+    return {"frontmatter": fm, "content": doc or _doc()}
+
+
+CS = {"observation_position": "本机进程", "time_window": [0, 9999999999.0],
+      "observation_tool": "代码走查", "existence_constraint": "仅测试库"}
+
+
+def main():
+    global PASS, FAIL
+    tmp = tempfile.mkdtemp(prefix="mdcg_cond_match_")
+    try:
+        # ---------- ① 纯函数：_cond_terms 确定性切分 ----------
+        terms = MdCG._cond_terms(
+            "载体/位置：本机进程；时间：全时窗（任意时刻成立）；"
+            "方法：代码走查；约束：仅测试库")
+        ok("载体/位置" not in terms and "时间" not in terms,
+           "①槽标签（载体/位置、时间）被剥离，不参与命中")
+        ok("本机进程" in terms and "代码走查" in terms and "仅测试库" in terms,
+           "①四槽实质短语保留")
+        ok(all("全时窗" not in t and "任意时刻" not in t for t in terms),
+           "①全时窗哨兵短语被过滤（时间维无信息量不降级）")
+        ok(MdCG._cond_terms("") == [], "①空条件 → 空词面（无从匹配即跳过）")
+
+        # ---------- ② 判定：无情境 → 跳过正条件段（v1 兼容） ----------
+        j = MdCG.judge_qualification(_node(), "", None)
+        ok(j["state"] == STATE_ACCEPT and "未做正条件确认" in j["reason"],
+           "②无 query 无 context → ACCEPT 且 reason 诚实标注未确认")
+
+        # ---------- ③ 判定：query 命中正条件 → ACCEPT 且 reason 确认 ----------
+        j = MdCG.judge_qualification(_node(), "问浮力", None)
+        ok(j["state"] == STATE_ACCEPT and "生效条件已确认" in j["reason"],
+           "③query 命中生效条件短语 → ACCEPT（reason 记录命中）")
+
+        # ---------- ④ 判定：仅 context 命中 → ACCEPT ----------
+        j = MdCG.judge_qualification(_node(), "", {"scene": "上下文提到问浮力"})
+        ok(j["state"] == STATE_ACCEPT and "生效条件已确认" in j["reason"],
+           "④context 命中 → ACCEPT")
+
+        # ---------- ⑤ 判定：有情境零命中 → DEFER（核心行为变更） ----------
+        j = MdCG.judge_qualification(_node(), "问电磁感应", None)
+        ok(j["state"] == STATE_DEFER and "生效条件未在情境确认" in j["reason"],
+           "⑤有情境但零命中 → DEFER（不再冒充 ACCEPT）")
+        ok("问浮力" in j["reason"], "⑤reason 点名未命中的条件短语（可审计）")
+
+        # ---------- ⑥ 整行「无条件」→ 豁免 ----------
+        j = MdCG.judge_qualification(
+            _node(doc=_doc(cond_line="# 生效条件：无条件")), "随便问点啥", None)
+        ok(j["state"] == STATE_ACCEPT, "⑥显式无条件声明 → 豁免正条件匹配")
+
+        # ---------- ⑦ frontmatter condition_space 兜底（正文行为空值） ----------
+        j = MdCG.judge_qualification(
+            _node(fm_extra={"condition_space": CS},
+                  doc=_doc(cond_line="# 生效条件：")),
+            "用代码走查核对", None)
+        ok(j["state"] == STATE_ACCEPT and "生效条件已确认" in j["reason"],
+           "⑦正文条件行空值时回退 condition_space 四槽合成")
+
+        # ---------- ⑧ 负条件仍 REJECT（v1 回归） ----------
+        j = MdCG.judge_qualification(
+            _node(fm_extra={"non_applicable_conditions": ["问ZXQ7"]}),
+            "问ZXQ7", {"query": "问ZXQ7"})
+        ok(j["state"] == STATE_REJECT, "⑧负条件命中仍先于正条件走 REJECT")
+
+        # ---------- ⑨ CCG 不全仍 BLINDSPOT（v1 回归） ----------
+        bad = ("# 功能名：残缺\n# 生效条件：问浮力\n# 子功能：x\n"
+               "# 执行：y\n# 不适用条件：z\n")          # 缺验证方式行
+        j = MdCG.judge_qualification(
+            {"frontmatter": {"verification_basis": "compiler"}, "content": bad},
+            "问浮力", None)
+        ok(j["state"] == STATE_BLINDSPOT, "⑨六要素不全仍 BLINDSPOT")
+
+        # ---------- ⑩ 正条件命中但无基底 → 仍 DEFER（信任根基优先级） ----------
+        no_basis = _node(doc=_doc())
+        no_basis["frontmatter"] = {}
+        j = MdCG.judge_qualification(no_basis, "问浮力", None)
+        ok(j["state"] == STATE_DEFER and "验证基底" in j["reason"],
+           "⑩正条件命中但未声明验证基底 → DEFER（不因条件确认而放行）")
+
+        # ---------- ⑪ search→judge 链路：query 贯通（v1 恒传空串） ----------
+        root = os.path.join(tmp, "root")
+        os.makedirs(root, exist_ok=True)
+        cg = MdCGOS(root)
+        cg.add("cm_a", _doc(), layer="knowledge", verification_basis="compiler")
+        cg.add("cm_b", _doc(cond_line="# 生效条件：问电磁"),
+               layer="knowledge", verification_basis="compiler")
+        res, _meta = cg.search("问浮力", judge=True)
+        states = {r[0]["id"]: r[2] for r in res if r[0].get("id") in ("cm_a", "cm_b")}
+        ok("cm_a" in states and states["cm_a"]["state"] == STATE_ACCEPT
+           and "生效条件已确认" in states["cm_a"]["reason"],
+           "⑪search 链路：命中节点 ACCEPT 且正条件已确认")
+        if "cm_b" in states:
+            ok(states["cm_b"]["state"] != STATE_ACCEPT,
+               "⑪search 链路：条件无关节点不再冒充 ACCEPT")
+        else:
+            ok(True, "⑪search 链路：条件无关节点未进入 top-k（等效）")
+
+        # mdcos 子类：ccg_exempt 短路优先（legacy 行为回归）
+        cg.add("cm_legacy", "自由文本 legacy 节点。\n", layer="knowledge",
+               ccg_exempt=True)
+        e = cg.index["nodes"]["cm_legacy"]
+        fm, c = cg._read(e)
+        j = MdCGOS.judge_qualification({"frontmatter": fm, "content": c},
+                                       "问浮力", {"query": "问浮力"})
+        ok(j["state"] == STATE_DEFER, "⑫legacy ccg_exempt 仍短路 DEFER（不被正条件段覆盖）")
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+    print(f"\ncond_match: {PASS} passed, {FAIL} failed")
+    if FAILS:
+        for f in FAILS:
+            print(f"  - {f}")
+    raise SystemExit(1 if FAIL else 0)
+
+
+if __name__ == "__main__":
+    main()

package/md_cg/test_en_pipeline.py

@@ -0,0 +1,142 @@
+# -*- coding: utf-8 -*-
+"""原子级中英归一管线（lexicon + semantic + mdcg 集成）· 设计态验收。
+
+管线四件套：
+  lexicon/build_standard_en.py  英文标准库构建器（牛肉→cow_meat，构建即验证）
+  lexicon/standard_en.json      词条真源（语素拼接自洽 + snake_case）
+  semantic/en_normalizer.py     英文 query → 中文语素序列（时态归零→停用词→映射→专有词保留）
+  semantic/zh_en_atoms.py       中文文本 → 标准英文原子序列（反方向序列化）
+
+集成面（mdcg.en_zh_terms → expand_query_terms）：
+  英→中语素追加为召回词+打分 bigram（en_zh_bigrams）；默认关闭
+  （双语双路裁定：md_cg 主链路英文走独立 Jaccard 路，见 semantic/REPRODUCE.md），
+  MDCG_EN_ATOMS=1 显式开启；纯中文 query 零触发；
+  mdcos 四路 RRF 的 lexical 路同源复用 expand_query_terms，自动受益。
+
+运行：python -m md_cg.test_en_pipeline
+"""
+from __future__ import annotations
+
+import io
+import json
+import os
+import shutil
+import tempfile
+
+from . import mdcg
+from .semantic import en_normalizer, zh_en_atoms
+
+PASS = FAIL = 0
+FAILS = []
+
+
+def ok(cond, name=""):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+    else:
+        FAIL += 1
+        FAILS.append(name)
+
+
+# ---- 1 · en_normalizer：屈折归零 ----
+ok(en_normalizer.strip_tense("Ate") == "eat", "irregular ate→eat")
+ok(en_normalizer.strip_tense("went") == "go", "irregular went→go")
+ok(en_normalizer.strip_tense("regretted") == "regret", "-ed 剥离+双辅音还原")
+ok(en_normalizer.strip_tense("running") == "run", "-ing 剥离+双辅音还原")
+ok(en_normalizer.strip_tense("stopped") == "stop", "stopped→stop")
+ok(en_normalizer.strip_tense("crossed") == "cross", "ss 保留（正字法例外）")
+ok(en_normalizer.strip_tense("called") == "call", "ll 保留（正字法例外）")
+ok(en_normalizer.strip_tense("dogs") == "dog", "-s 复数剥离")
+ok(en_normalizer.strip_tense("class") == "class", "-ss 例外不剥")
+ok(en_normalizer.strip_tense("be") == "be", "短词不动")
+
+# ---- 2 · en_normalizer：停用词 / 专有词 / 复合词 ----
+t, d = en_normalizer.normalize_en_query("I eat beef yesterday")
+ok(t == ["我", "吃", "牛肉", "昨天"], "端到端映射 beef→牛肉: %s" % t)
+t2, _ = en_normalizer.normalize_en_query("Caroline went to Paris")
+ok("Caroline" in t2 and "Paris" in t2, "专有词保留原名: %s" % t2)
+ok(en_normalizer.normalize_en_query("soul hub")[0] == ["灵枢"], "短语级复合 soul hub→灵枢")
+ok(en_normalizer.normalize_en_query("beef")[0] == ["牛肉"], "单词级复合 beef→牛肉")
+ok(en_normalizer.normalize_en_query("xyzzy")[0] == ["xyzzy"], "未知词 unknown_keep")
+t3, _ = en_normalizer.normalize_en_query("The dogs were running")
+ok("the" not in [x.lower() for x in t3] and "were" not in [x.lower() for x in t3],
+   "停用词剔除: %s" % t3)
+
+# ---- 3 · zh_en_atoms：中文→标准英文原子序列 ----
+ok(zh_en_atoms.serialize("我昨天吃牛肉") == "i yester day eat cow meat",
+   "serialize 复合词拆原子")
+ok(zh_en_atoms.serialize("灵枢记忆库") == "soul hub memory store", "serialize 灵枢记忆库")
+ok(zh_en_atoms.segment("吃牛肉") == ["吃", "牛肉"], "贪心最长匹配")
+
+# ---- 4 · mdcg.en_zh_terms：集成单元（双态：默认关 / MDCG_EN_ATOMS=1 开） ----
+ok(mdcg.en_zh_terms("I eat beef yesterday") == [],
+   "默认关闭：en_zh_terms 不触发（双语双路裁定）")
+os.environ["MDCG_EN_ATOMS"] = "1"
+ok(mdcg.en_zh_terms("I eat beef yesterday") == ["吃", "牛肉", "昨天"],
+   "开启：en_zh_terms 三语素（代词剔除）: %s" % mdcg.en_zh_terms("I eat beef yesterday"))
+ok(mdcg.en_zh_terms("我昨天吃了牛肉面") == [], "纯中文零触发")
+ok(all(t not in mdcg._EN_ZH_PRONOUNS for t in mdcg.en_zh_terms("She saw my dog")),
+   "代词全剔除、实词保留")
+os.environ["MDCG_EN_ATOMS"] = "0"
+ok(mdcg.en_zh_terms("I eat beef") == [], "显式关闭回退 legacy")
+del os.environ["MDCG_EN_ATOMS"]
+
+# ---- 5 · expand_query_terms：召回词融合 + 纯中文回归守卫 ----
+os.environ["MDCG_EN_ATOMS"] = "1"
+et = mdcg.expand_query_terms("I ate beef yesterday")
+ok("牛肉" in et and "昨天" in et, "开启：英文 query 产出中文召回词: %s" % et)
+ok("eat" in et, "形态归一仍在（ate→eat）")
+del os.environ["MDCG_EN_ATOMS"]
+ok("牛肉" not in mdcg.expand_query_terms("I ate beef yesterday"),
+   "默认关闭：expand_query_terms 回 legacy（无中文语素）")
+_zc = "抑制剂怎么选择效果好"
+os.environ["MDCG_EN_ATOMS"] = "1"
+zc_on = mdcg.expand_query_terms(_zc)
+del os.environ["MDCG_EN_ATOMS"]
+zc_off = mdcg.expand_query_terms(_zc)
+ok(zc_on == zc_off, "纯中文 query 开关前后零差异（回归守卫）")
+
+# ---- 6 · 端到端：英文 query 召回中文记忆 ----
+tmp = tempfile.mkdtemp(prefix="mdcg_en_pipe_")
+try:
+    cg = mdcg.MdCG(root=tmp)
+    cg.add("n_beef", "昨天中午我在家里吃了牛肉面，配了可乐。",
+           layer="contextual", verification_basis="data")
+    cg.add("n_unrel", "我喜欢在雨天听爵士乐。",
+           layer="contextual", verification_basis="data")
+    cg.flush()
+    os.environ["MDCG_EN_ATOMS"] = "1"
+    res, _meta = cg.search("I ate beef yesterday", judge=False)
+    ids = [r[0].get("id") for r in res]
+    del os.environ["MDCG_EN_ATOMS"]
+    ok(len(res) >= 1 and ids[0] == "n_beef", "开启：英文 query top1 召回中文牛肉节点 %s" % ids)
+    res0, _m0 = cg.search("I ate beef yesterday", judge=False)   # 默认未设=关闭
+    ok(not res0 or all(r[1] <= 0 for r in res0),
+       "默认关闭：词面零重叠召回归零（跨语断点复现）")
+finally:
+    shutil.rmtree(tmp, ignore_errors=True)
+
+# ---- 7 · 构建自洽：standard_en.json / search_index.json ----
+_here = os.path.dirname(os.path.abspath(__file__))
+std = json.load(io.open(os.path.join(_here, "lexicon", "standard_en.json"), encoding="utf-8"))
+entries = {e["zh"]: e for e in std["entries"]}
+ok(len(entries) == 62, "词条数 62（真源守卫）")
+ok(entries["牛肉"]["standard_en"] == "cow_meat" and "beef" in entries["牛肉"]["legacy_en"],
+   "牛肉=cow_meat（legacy 别名 beef）")
+ok(entries["火山"]["standard_en"] == "fire_mountain", "语素序直拼 火山=fire_mountain")
+ok(sum(1 for e in std["entries"] if e["class"] == "opaque") == 5, "opaque 化石词 5 条")
+si = json.load(io.open(os.path.join(_here, "semantic", "search_index.json"), encoding="utf-8"))
+ok(si["meta"]["atom_count"] == 815 and si["meta"]["zh_terms"] == 815,
+   "search_index 与 atoms 数一致")
+ok(si["en_index"].get("meat") and "牛肉" in si["en_index"]["meat"],
+   "en_index 倒排 meat→牛肉")
+
+# ---- 8 · mdcos lexical 路同源受益 ----
+from .mdcos import MdCGOS
+from .mdcg import expand_query_terms as _eqt
+ok(_eqt is mdcg.expand_query_terms, "mdcos 复用同一 expand_query_terms（同源单实现）")
+
+print("en_pipeline: %d assertions all green" % PASS if not FAIL
+      else "en_pipeline: %d passed, %d FAILED: %s" % (PASS, FAIL, FAILS))
+raise SystemExit(1 if FAIL else 0)