@furongjun1999/dsh-memory 0.4.3 → 0.4.5

package/md_cg/test_p44_md_whitebox.py

@@ -0,0 +1,218 @@
+# -*- coding: utf-8 -*-
+"""P44 · md 原生知识库的白箱问答（端到端实测）。
+
+验证目标
+--------
+1) 结构等价：md 语料还原库与源库 nodes / edges 计数一致（4355 / 2948）；
+2) **数据等价**：逐题比较 `dex_respond` 的**全量候选集**（name+score）——
+   这是「md 语料 = 源库知识」的硬证据，不受 top-N 截断与排序影响；
+3) **端到端一致**：同一批实际问题上，md 库与源库的 `chat` 回答
+   （route / 命中卡 / 分值）逐题一致；同分并列单独标注（排序取决于
+   表的物理顺序，非数据差异）；
+4) 效果报告：打印每题的 route、命中卡、回答摘要，供人工评估。
+
+源库保护
+--------
+对比跑在源库的**临时副本**上：白箱问答会 `increment_access` 写库，
+绝不能污染随包的只读 `wisdom-book-cloud.db`。
+
+运行：`python -m md_cg.test_p44_md_whitebox`
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import sqlite3
+import sys
+import tempfile
+
+_HERE = os.path.dirname(os.path.abspath(__file__))
+
+from .md_whitebox import build_db_from_md  # noqa: E402
+
+SOURCE_DB = os.path.join(_HERE, "whitebox_kb", "wisdom", "wisdom-book-cloud.db")
+
+#: 20 题实际题库：口语提问 × 跨域，覆盖白箱各条确定性检索通路。
+QUESTIONS = [
+    # —— 翻译表（俗语 → 规范知识词）
+    "水烧开是什么现象",
+    "为什么会打雷",
+    "铁球和羽毛谁落得快",
+    "天空为什么是蓝的",
+    # —— 学科术语直配
+    "什么是熵",
+    "什么是勾股定理",
+    "什么是光合作用",
+    "什么是质数",
+    # —— 极短 / 单字学科词
+    "熵",
+    # —— 领域知识点卡（KCCS 注释索引）
+    "古巴比伦有什么文明成就",
+    "秦始皇是谁",
+    "月亮为什么会有阴晴圆缺",
+    "什么是通货膨胀",
+    # —— 英文缩写
+    "什么是TCP三次握手",
+    "KKT条件是什么",
+    # —— 系统概念（含「定律」先验）
+    "光的反射定律是什么",
+    "一天有多少小时",
+    # —— 元层 / 理论
+    "什么是条件论",
+    "什么是存在论",
+    # —— 诚实边界（白箱应拒答或降级，而非编造）
+    "外星人存在吗",
+]
+
+
+def _probe(db_path, questions, label):
+    """在同一引擎上顺序提问，返回逐题结果。
+
+    两库按**同题同序**跑，access 累积轨迹相同，故对比公平。
+    候选集用 `dex_respond`（全库打分，不被 graph_retrieve 的
+    top-N 早返回截断），端到端用 `chat`（真实入口）。
+    """
+    from .whitebox_kb.engine import WhiteboxEngine  # 先导入：注入 sys.path
+    import semantic_translate as _st  # noqa: E402 —— 平铺导入，需上行先执行
+
+    eng = WhiteboxEngine(db_path=db_path, seed=False)
+    out = []
+    try:
+        dex = eng.dex
+        for q in questions:
+            try:
+                # limit 放大到不截断：截断会让「同分并列」的保留集合
+                # 取决于排序，从而把排序差异误判成数据差异。
+                _hits = dex.dex_respond(q, limit=10 ** 6, translator=_st)
+                _c = {}
+                for h in _hits:
+                    _sc = round(float(h.get("score") or 0), 4)
+                    _c.setdefault(_sc, set()).add(h.get("name") or "")
+                cand = {k: frozenset(v) for k, v in _c.items()}
+            except Exception as exc:  # 诊断用：不掩盖底层异常
+                cand = {"__error__": frozenset([f"{type(exc).__name__}: {exc}"])}
+            res = eng.chat(q, session_id=f"p44-{label}")
+            hits = res.get("hits") or []
+            top = hits[0] if hits else {}
+            out.append({
+                "q": q, "cand": cand,
+                "route": res.get("route") or "",
+                "top": top.get("name") or "",
+                "score": (round(float(top.get("score") or 0), 4)
+                          if hits else None),
+                "matched": list(top.get("matched") or []),
+                "reply": (res.get("reply") or "").strip(),
+            })
+    finally:
+        eng.close()
+    return out
+
+
+def _count(db_path, table):
+    con = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
+    try:
+        return int(con.execute(f"SELECT COUNT(*) FROM {table}").fetchone()[0])
+    finally:
+        con.close()
+
+
+def _report(rows):
+    print(f"\n===== md 原生知识库 · 白箱回答（{len(rows)} 题） =====")
+    print(f"{'#':>2}  {'route':<14} {'score':>6}  {'命中卡':<28} 问题")
+    for i, r in enumerate(rows, 1):
+        print(f"{i:>2}  {r['route']:<14} {str(r['score']):>6}  "
+              f"{r['top'][:26]:<28} {r['q']}")
+        if r["reply"]:
+            print(f"      └─ {r['reply'][:140]}")
+
+
+def main():
+    ok = True
+
+    # ---- 1) 结构等价 ----
+    # force：从 md 语料**重新**还原，保证 access_count 等可变字段与源库快照
+    # 同起点（复用旧库会带上此前问答累积的 access，造成假差异）。
+    md = build_db_from_md(force=True, verbose=False)
+    src_nodes, src_edges = _count(SOURCE_DB, "nodes"), _count(SOURCE_DB, "edges")
+    print(f"[结构] md 还原库  nodes={md['nodes']}  edges={md['edges']}")
+    print(f"[结构] 源库      nodes={src_nodes}  edges={src_edges}")
+    if (md["nodes"], md["edges"]) != (src_nodes, src_edges):
+        print("[FAIL] 结构不等价")
+        ok = False
+    else:
+        print("[PASS] 结构等价（nodes / edges 计数一致）")
+
+    # ---- 2) 跑两库（源库用临时副本，绝不写包内库） ----
+    tmp_dir = tempfile.mkdtemp(prefix="p44_src_")
+    tmp = os.path.join(tmp_dir, "src_copy.db")
+    shutil.copy2(SOURCE_DB, tmp)
+    try:
+        rows_md = _probe(md["db"], QUESTIONS, "md")
+        rows_src = _probe(tmp, QUESTIONS, "src")
+    finally:
+        shutil.rmtree(tmp_dir, ignore_errors=True)
+
+    # ---- 3) 数据等价：全量候选集逐一比对 ----
+    cand_bad = []
+    for a, b in zip(rows_md, rows_src):
+        if a["cand"] != b["cand"]:
+            cand_bad.append({"q": a["q"], "md": a["cand"], "src": b["cand"]})
+    print(f"\n[数据] 候选集逐题一致 {len(QUESTIONS) - len(cand_bad)}/{len(QUESTIONS)}"
+          f"（dex_respond 全量打分，不受排序影响）")
+    if cand_bad:
+        ok = False
+        print("[FAIL] md 库与源库候选集不一致：")
+        for d in cand_bad[:5]:
+            print(f"   {d['q']}")
+            for tag in ("md", "src"):
+                keys = sorted(d[tag], reverse=True)[:6]
+                print(f"     {tag:<3}: " + "; ".join(
+                    f"{k}={sorted(d[tag][k])[:3]}" for k in keys))
+    else:
+        print("[PASS] 数据等价（每题候选集完全相同）")
+
+    # ---- 4) 端到端一致：route / 命中卡 / 分值 ----
+    diff, parallel = [], []
+    for a, b in zip(rows_md, rows_src):
+        if a["route"] != b["route"]:
+            diff.append((a["q"], "route", a["route"], b["route"]))
+        elif a["score"] != b["score"]:
+            diff.append((a["q"], "score", a["score"], b["score"]))
+        elif a["top"] != b["top"]:
+            # 同分并列：两侧 top 都出现在对方候选集内且分值相同
+            # → 差异仅来自表的物理遍历顺序，非数据差异
+            _an = {n for ns in a["cand"].values() for n in ns}
+            _bn = {n for ns in b["cand"].values() for n in ns}
+            if (a["score"] == b["score"]
+                    and a["top"] in _bn and b["top"] in _an):
+                parallel.append((a["q"], a["top"], b["top"], a["score"]))
+            else:
+                diff.append((a["q"], "top", a["top"], b["top"]))
+    same = len(QUESTIONS) - len(diff) - len(parallel)
+    print(f"\n[行为] 严格一致 {same}/{len(QUESTIONS)}"
+          f" · 同分并列 {len(parallel)} · 不一致 {len(diff)}")
+    for q, md_top, src_top, sc in parallel:
+        print(f"   并列 {q}（同为 {sc}）：md={md_top} / src={src_top}")
+    if diff:
+        ok = False
+        print("[FAIL] 端到端不一致：")
+        for q, field, x, y in diff[:8]:
+            print(f"   {q} · {field}: md={x!r} vs src={y!r}")
+    else:
+        print("[PASS] 端到端一致（差异仅为同分并列的排序）")
+
+    # ---- 5) 效果报告 ----
+    _report(rows_md)
+    answered = [r for r in rows_md if r["reply"]]
+    print(f"\n[效果] 有回答 {len(answered)}/{len(QUESTIONS)}"
+          f" · route=self {sum(1 for r in rows_md if r['route'] == 'self')}"
+          f" · self_fallback "
+          f"{sum(1 for r in rows_md if r['route'] == 'self_fallback')}"
+          f" · 命中 KCCS 注释索引 "
+          f"{sum(1 for r in rows_md if 'KCCS注释索引' in r['matched'])}")
+    print("\n" + ("全部通过" if ok else "存在失败项"))
+    return 0 if ok else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_p4_fuzzy.py

@@ -0,0 +1,223 @@
+# -*- coding: utf-8 -*-
+"""md_cg · P4 验收：分级隶属度 + LLM 查询侧扩展 + fuzzy RRF 路径
+
+运行：python -m md_cg.test_p4_fuzzy
+
+验证口径（对齐「只新增、不改既有语义」）：
+  1. 分级隶属度：membership / IDF 加权大域打分 / 域相似度，且老二值实现不变
+  2. LLM 查询侧扩展：llm / whitebox / whitebox_fallback 三态 + 缓存
+  3. fuzzy 路径：作为**第 5 路**接入 RRF，默认路径不含它（基线不受影响）
+"""
+from __future__ import annotations
+
+import shutil
+import sys
+import tempfile
+
+from . import routing
+from .mdcg import (expand_query_terms, expand_query_terms_weighted,
+                   expand_query_terms_llm, SYNONYM_GROUPS,
+                   SYNONYM_GROUPS_WEIGHTED)
+from .mdcos import MdCGOS, _term_degree, _weighted_coverage
+
+PASS = FAIL = 0
+FAILS = []
+
+
+def check(name, cond, detail=""):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  [PASS] {name}" + (f"  · {detail}" if detail else ""))
+    else:
+        FAIL += 1
+        FAILS.append(name)
+        print(f"  [FAIL] {name}  · {detail}")
+
+
+CCG = ("# 功能名：{n}\n# 生效条件：{c}\n# 子功能：{s}\n# 执行：{e}\n"
+       "# 验证方式：test\n# 不适用条件：{neg}\n\n{body}\n")
+
+
+def mk(n, cond, body, neg="其它"):
+    return CCG.format(n=n, c=cond, s=body[:20], e=body, neg=neg, body=body)
+
+
+def main():
+    # ---------------- 1. 分级隶属度 ----------------
+    print("\n【1】分级隶属度（手写隶属函数）")
+    check("完全相同 → 隶属度 1.0", routing.membership("物理", "物理") == 1.0)
+    check("term 包含 word → 长度比",
+          abs(routing.membership("牛顿第二定律", "牛顿") - 2 / 6) < 1e-9,
+          f"{routing.membership('牛顿第二定律', '牛顿')}")
+    check("word 包含 term → 长度比",
+          abs(routing.membership("物理", "高中物理") - 2 / 4) < 1e-9,
+          f"{routing.membership('物理', '高中物理')}")
+    check("无包含关系 → 0.0", routing.membership("物理", "化学") == 0.0)
+
+    idf_rare = routing.domain_idf("贝塞尔")     # 只覆盖数学
+    idf_common = routing.domain_idf("文明")     # 覆盖历史 + 通用（跨域）
+    check("IDF：稀有词区分度 > 跨域通用词", idf_rare > idf_common,
+          f"贝塞尔={idf_rare:.3f} 文明={idf_common:.3f}")
+
+    w_bd = routing.big_domain_score_weighted({"贝塞尔": 1.0})
+    check("IDF 加权大域打分：贝塞尔 → 数学最高",
+          max(w_bd, key=lambda d: w_bd[d]) == "数学",
+          f"数学={w_bd['数学']:.3f} 物理={w_bd['物理']:.3f}")
+    w_bd2 = routing.big_domain_score_weighted({"牛顿第二定律": 1.0})
+    check("加权打分为连续值（部分命中→非整数）",
+          0 < w_bd2["物理"] < 2 and w_bd2["物理"] != int(w_bd2["物理"]),
+          f"物理={w_bd2['物理']:.3f}")
+    check("加权收敛 top-1",
+          routing.big_domain_classify_weighted({"贝塞尔": 1.0}) == "数学")
+
+    # 老二值实现不变（基线可比性的前提）
+    old_scores = routing.big_domain_score_breakdown(["贝塞尔"])
+    check("老二值打分仍为整数计数", all(isinstance(v, int) for v in old_scores.values()),
+          f"数学={old_scores['数学']}")
+    check("老 big_domain_classify 结果不变",
+          routing.big_domain_classify(["贝塞尔"]) == "数学")
+
+    check("域相似度：包含 → 长度比",
+          abs(routing.domain_similarity("计算机", "计算机科学") - 3 / 5) < 1e-9,
+          f"{routing.domain_similarity('计算机', '计算机科学')}")
+    check("域相似度：无关 → 0", routing.domain_similarity("物理", "音乐") == 0.0)
+
+    # ---------------- 2. 加权扩展 + LLM 查询侧扩展 ----------------
+    print("\n【2】加权扩展 + LLM 查询侧扩展")
+    check("加权同义词组与老表组数一致",
+          len(SYNONYM_GROUPS_WEIGHTED) == len(SYNONYM_GROUPS),
+          f"{len(SYNONYM_GROUPS_WEIGHTED)} vs {len(SYNONYM_GROUPS)}")
+    check("组内权重落在 0.3~1.0",
+          all(0.3 <= w <= 1.0 for g in SYNONYM_GROUPS_WEIGHTED for w in g.values()))
+    check("每组恰有一个 1.0 组心",
+          all(sum(1 for v in g.values() if v == 1.0) == 1
+              for g in SYNONYM_GROUPS_WEIGHTED))
+
+    tw = expand_query_terms_weighted("图片识别")
+    check("加权扩展：整句权重 1.0", tw.get("图片识别") == 1.0)
+    check("加权扩展：同义词带权重（图片→图像 0.9）", tw.get("图像") == 0.9, str(tw))
+    check("加权扩展：弱相关低权（发现 0.5）", tw.get("发现") == 0.5, str(tw))
+    check("老扩展仍返回 list（未改语义）",
+          isinstance(expand_query_terms("图片识别"), list))
+
+    # 分级命中（模糊匹配）
+    check("整词命中 → 1.0", _term_degree("红按钮", "红按钮控制角色") == 1.0)
+    check("部分命中 → 长度比 × 0.5（贝塞尔不等式 vs 贝塞尔公式）",
+          abs(_term_degree("贝塞尔不等式", "贝塞尔公式") - 0.5 * 3 / 6) < 1e-9,
+          f"{_term_degree('贝塞尔不等式', '贝塞尔公式')}")
+    check("部分命中 < 整词命中（模糊路不压倒词法路）",
+          _term_degree("红按钮", "蓝按钮") < 1.0,
+          f"共享后缀「按钮」={_term_degree('红按钮', '蓝按钮')}")
+    check("完全未命中 → 0", _term_degree("红按钮", "天气晴朗") == 0.0)
+    check("加权覆盖率 ∈ [0,1]",
+          0 <= _weighted_coverage({"红按钮": 1.0, "发现": 0.5}, "红按钮") <= 1.0)
+
+    # LLM 三态
+    fake_ok = lambda p: '[{"term": "视觉识别", "weight": 0.8}, {"term": "图片", "weight": 0.5}]'
+    out = expand_query_terms_llm("图片", llm_fn=fake_ok)
+    check("LLM 扩展：source=llm", out.get("__source__") == "llm", str(out))
+    check("LLM 扩展：合并 LLM 词", out.get("视觉识别") == 0.8)
+    check("LLM 扩展：不压低白箱精确命中", out.get("图片") == 1.0, f"图片={out.get('图片')}")
+    n_calls = []
+
+    def counting(p):
+        n_calls.append(1)
+        return '[{"term": "视觉识别", "weight": 0.8}]'
+
+    cache = {}
+    expand_query_terms_llm("图片", llm_fn=counting, cache=cache)
+    expand_query_terms_llm("图片", llm_fn=counting, cache=cache)
+    check("LLM 扩展：显式缓存下同 query 只调一次", len(n_calls) == 1, f"调用={len(n_calls)}")
+
+    def boom(_p):
+        raise RuntimeError("llm down")
+
+    out_fb = expand_query_terms_llm("图片", llm_fn=boom)
+    check("LLM 失败 → 回退白箱", out_fb.get("__source__") == "whitebox_fallback"
+          and out_fb.get("图像") == 0.9, str(out_fb)[:80])
+    out_wb = expand_query_terms_llm("图片")
+    check("无 llm_fn → 纯白箱", out_wb.get("__source__") == "whitebox")
+    out_bad = expand_query_terms_llm("图片", llm_fn=lambda p: "抱歉我不能")
+    check("LLM 输出非 JSON → 回退白箱",
+          out_bad.get("__source__") == "whitebox_fallback")
+
+    # ---------------- 3. fuzzy RRF 路径 ----------------
+    print("\n【3】fuzzy 路径接入 RRF（默认不启用）")
+    root = tempfile.mkdtemp(prefix="mdcg_fuzzy_")
+    try:
+        cg = MdCGOS(root, actor="test")
+        cg.add("img_strong", mk("图像节点", "问图片", "画面渲染管线"),
+               tags=["图像"], condition_space={"observation_position": "视觉知识点（渲染）"})
+        cg.add("img_weak", mk("视像节点", "问图片", "画面渲染管线"),
+               tags=["视像"], condition_space={"observation_position": "视觉知识点（渲染）"})
+        cg.add("math1", mk("贝塞尔不等式", "问贝塞尔", "贝塞尔不等式的证明与推导"),
+               tags=["domain:数学"], condition_space={"observation_position": "数学知识点（贝塞尔）"})
+        cg.add("noise", mk("无关节点", "问无关", "完全无关的内容"), tags=["其它"])
+
+        # 默认路径不含 fuzzy → 既有行为不变
+        res0, meta0 = cg.search_rrf("图片", k=5)
+        check("默认 RRF 路径不含 fuzzy",
+              "fuzzy" not in meta0.get("paths", {}), str(list(meta0.get("paths", {}))))
+        check("默认 RRF meta 仍有 expand_source 字段（值为 None）",
+              "expand_source" in meta0 and meta0["expand_source"] is None)
+
+        # 显式启用 fuzzy
+        paths5 = ("lexical", "bucket", "entity", "graph", "fuzzy")
+        res, meta = cg.search_rrf("图片", k=5, paths=paths5)
+        check("fuzzy 路径被记录进 meta", "fuzzy" in meta.get("paths", {}),
+              str(meta.get("paths")))
+        check("fuzzy 扩展来源标注（白箱）", meta.get("expand_source") == "whitebox",
+              str(meta.get("expand_source")))
+        prov = meta.get("provenance", {})
+        check("结果 provenance 含 fuzzy 路",
+              any(any(p["path"] == "fuzzy" for p in prov.get(nid, [])) for nid in prov),
+              str({k: [p['path'] for p in v] for k, v in prov.items()})[:160])
+
+        # 分级：强同义词节点分数 > 弱同义词节点（fuzzy 路内）
+        fuzzy_scored, _src = cg._path_fuzzy("图片", cg._candidates())
+        smap = {n["id"]: s for n, s in fuzzy_scored}
+        check("fuzzy 分级：图像(0.9) > 视像(0.6)",
+              smap.get("img_strong", 0) > smap.get("img_weak", 0),
+              f"图像={smap.get('img_strong')} 视像={smap.get('img_weak')}")
+        check("fuzzy 打分 ∈ (0,1]", all(0 < s <= 1.0 for s in smap.values()),
+              str({k: round(v, 3) for k, v in smap.items()}))
+
+        # 大域亲和：数学节点在「贝塞尔」查询下获得 fuzzy 分
+        fuzzy_math, _ = cg._path_fuzzy("贝塞尔不等式", cg._candidates())
+        mids = {n["id"] for n, _ in fuzzy_math}
+        check("fuzzy 大域亲和命中数学节点", "math1" in mids, str(mids))
+
+        # 注入 LLM 查询侧扩展 → meta 标注 llm
+        llm_expand = lambda q: expand_query_terms_llm(
+            q, llm_fn=lambda p: '[{"term": "画面", "weight": 0.9}]')
+        res_l, meta_l = cg.search_rrf("图片", k=5, paths=paths5, query_expand=llm_expand)
+        check("注入 LLM 扩展 → meta expand_source=llm",
+              meta_l.get("expand_source") == "llm", str(meta_l.get("expand_source")))
+        check("LLM 扩展后仍有结果", len(res_l) > 0, f"{len(res_l)} 条")
+
+        # recall 透传 paths
+        rec = cg.recall("图片", budget_tokens=400, k=5, paths=paths5)
+        check("recall 可透传 paths 启用 fuzzy",
+              "fuzzy" in rec["meta"].get("paths", {}), str(rec["meta"].get("paths")))
+        check("recall 仍遵守预算", rec["tokens_used"] <= rec["budget"],
+              f"used={rec['tokens_used']}/{rec['budget']}")
+
+        # 无 context 时 fuzzy 不应因缺 context 报错
+        res_nc, meta_nc = cg.search_rrf("贝塞尔", k=5, paths=("fuzzy",))
+        check("fuzzy 单路在无 context 下可运行", isinstance(res_nc, list),
+              f"{len(res_nc)} 条")
+        cg.close()
+    finally:
+        shutil.rmtree(root, ignore_errors=True)
+
+    print("\n" + "=" * 68)
+    print(f"通过 {PASS} / 失败 {FAIL}")
+    if FAILS:
+        print("失败项：" + ", ".join(FAILS))
+    print("=" * 68)
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_p5_semantic.py

@@ -0,0 +1,226 @@
+# -*- coding: utf-8 -*-
+"""md_cg · P5 验收：条件空间结构化匹配（白箱语义路）
+
+运行：python -m md_cg.test_p5_semantic
+
+验证口径（对齐「只新增、不改既有语义」）：
+  1. 条件证据提取：CCG 字段解析 / 三处来源合并 / 时间窗交叠 / 整词负路由
+  2. semantic 路径：条件结构驱动（生效条件 + condition_space 四槽）
+  3. 条件级负路由：不适用条件命中 → 剔除（fuzzy 做不到）
+  4. 与 fuzzy 正交：condition_space.observation_tool 只有 semantic 读得到
+  5. 默认 RRF 不含 semantic（四路基线不受影响）
+"""
+from __future__ import annotations
+
+import shutil
+import sys
+import tempfile
+
+from .mdcos import (MdCGOS, _term_degree, _weighted_coverage, _ccg_field,
+                    _declared_conditions, _neg_hit, _window_overlap,
+                    _slot_overlap)
+
+PASS = FAIL = 0
+FAILS = []
+
+
+def check(name, cond, detail=""):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  [PASS] {name}" + (f"  · {detail}" if detail else ""))
+    else:
+        FAIL += 1
+        FAILS.append(name)
+        print(f"  [FAIL] {name}  · {detail}")
+
+
+CCG = ("# 功能名：{n}\n# 生效条件：{c}\n# 子功能：{s}\n# 执行：{e}\n"
+       "# 验证方式：test\n# 不适用条件：{neg}\n\n{body}\n")
+
+
+def mk(n, cond, body, neg="其它"):
+    return CCG.format(n=n, c=cond, s=body[:20], e=body, neg=neg, body=body)
+
+
+# 真实迁移语料形态的 condition_space（高等数学骨架填充）
+CS_MATH = {
+    "observation_position": "高等数学知识点内容（按骨架填充） 知识点（微分方程应用）",
+    "observation_tool": "学科知识卡拆分",
+    "time_window": [0.0, 9999999999.0],
+    "existence_constraint": "通用规律/知识（开源非盈利知识库）",
+}
+
+
+def main():
+    # ---------------- 1. 条件证据提取 ----------------
+    print("\n【1】条件证据提取（确定性、零依赖）")
+    body = mk("微分方程应用", "问微分方程应用 问微分方程", "微分方程应用：建模与求解",
+              neg="问数列极限 问函数极限")
+    check("_ccg_field：中文冒号提取生效条件",
+          _ccg_field(body, "生效条件") == "问微分方程应用 问微分方程",
+          _ccg_field(body, "生效条件"))
+    check("_ccg_field：不适用条件", _ccg_field(body, "不适用条件") == "问数列极限 问函数极限")
+    check("_ccg_field：无该字段 → 空串", _ccg_field(body, "不存在字段") == "")
+    check("_ccg_field：英文冒号亦可",
+          _ccg_field("# 生效条件: 问天气\n正文", "生效条件") == "问天气")
+
+    pos, neg = _declared_conditions(
+        {"non_applicable_conditions": ["海拔 > 5000 米"],
+         "state_attributes": {"comment": {"生效条件": ["问微分方程"],
+                                          "不适用条件": ["问数列极限"]}}},
+        body)
+    check("_declared_conditions：正文生效条件在列", "问微分方程应用 问微分方程" in pos)
+    check("_declared_conditions：合并 state_attributes 生效条件", "问微分方程" in pos, str(pos))
+    check("_declared_conditions：合并 frontmatter 负条件",
+          "海拔 > 5000 米" in neg, str(neg))
+    check("_declared_conditions：去重保序",
+          len(neg) == len(set(neg)) and len(pos) == len(set(pos)))
+
+    check("_window_overlap：完全包含 → 1.0",
+          _window_overlap([0, 100], [10, 20]) == 1.0)
+    check("_window_overlap：半交叠 → 0.5",
+          abs(_window_overlap([0, 10], [5, 15]) - 0.5) < 1e-9,
+          f"{_window_overlap([0, 10], [5, 15])}")
+    check("_window_overlap：不相交 → 0.0",
+          _window_overlap([0, 10], [20, 30]) == 0.0)
+    check("_window_overlap：非法输入 → 0.0", _window_overlap(None, [1, 2]) == 0.0)
+
+    # 条件级负路由：只认高置信整词，泛化短词不误杀
+    check("_neg_hit：整词命中 → True",
+          _neg_hit({"数列极限": 1.0}, ["问数列极限 问函数极限"]))
+    check("_neg_hit：低权词不触发",
+          not _neg_hit({"数列极限": 0.4}, ["问数列极限 问函数极限"]))
+    check("_neg_hit：部分命中不触发",
+          not _neg_hit({"数列": 1.0}, ["问函数极限"]))
+    check("_neg_hit：无负条件 → False", not _neg_hit({"x": 1.0}, []))
+
+    # 槽位重合：缺失槽不进分母
+    cs_pos_only = {"observation_position": CS_MATH["observation_position"]}
+    check("_slot_overlap：域相似度（高等数学 vs 数学 → 0.5）",
+          abs(_slot_overlap({"微分方程": 1.0}, cs_pos_only, q_domain="数学") - 0.5) < 1e-9,
+          f"{_slot_overlap({'微分方程': 1.0}, cs_pos_only, q_domain='数学')}")
+    cs_two = dict(cs_pos_only)
+    cs_two["observation_tool"] = "学科知识卡拆分"
+    s2 = _slot_overlap({"微分方程": 1.0}, cs_two, q_domain="数学")
+    check("_slot_overlap：未命中的槽进分母 → 分数被摊薄",
+          abs(s2 - (2 * 0.5) / 3) < 1e-9, f"{s2}")
+    check("_slot_overlap：无槽信息 → 0.0",
+          _slot_overlap({"x": 1.0}, {}) == 0.0)
+
+    # ---------------- 2. semantic 路径 ----------------
+    print("\n【2】semantic 路径：条件结构驱动")
+    root = tempfile.mkdtemp(prefix="mdcg_sem_")
+    try:
+        cg = MdCGOS(root, actor="test")
+        cg.add("diff_eq", mk("微分方程应用", "问微分方程应用 问微分方程",
+                             "微分方程应用：建模与求解",
+                             neg="问数列极限 问函数极限"),
+               tags=["domain:高等数学"], condition_space=CS_MATH)
+        cg.add("series", mk("数列极限", "问数列极限 问函数极限",
+                            "数列极限的定义与性质",
+                            neg="问微分方程 问贝塞尔"),
+               tags=["domain:高等数学"],
+               condition_space=dict(CS_MATH,
+                                    observation_position="高等数学知识点内容（按骨架填充） 知识点（数列极限）"))
+        cg.add("noise", mk("无关节点", "问天气", "今天天气晴朗", neg="其它"),
+               tags=["domain:通用"])
+
+        cands = cg._candidates()
+        scored, = [cg._path_semantic("微分方程", cands)]
+        smap = {n["id"]: s for n, s in scored}
+        check("生效条件命中 → diff_eq 被召回", "diff_eq" in smap, str(smap))
+        check("不适用条件命中 → series 被条件级负路由剔除",
+              "series" not in smap, str(smap))
+        check("无任何条件证据 → noise 不进候选", "noise" not in smap, str(smap))
+        check("semantic 打分 ∈ (0,1]", all(0 < s <= 1.0 for s in smap.values()),
+              str({k: round(v, 3) for k, v in smap.items()}))
+
+        # 对称性：换查询，命中关系反转
+        scored2, = [cg._path_semantic("数列极限", cands)]
+        smap2 = {n["id"]: s for n, s in scored2}
+        check("对称性：查询「数列极限」→ series 召回、diff_eq 剔除",
+              "series" in smap2 and "diff_eq" not in smap2, str(smap2))
+
+        # ---------------- 3. 与 fuzzy 正交 ----------------
+        print("\n【3】与 fuzzy 正交（condition_space 槽位只有 semantic 读得到）")
+        # 用不可分解的 ASCII 令牌隔离「字段可见性」：正文/tags 均不含它，
+        # 排除 fuzzy 通过子词扩展误命中的干扰。
+        cg.add("tool_node", mk("采集流程", "none", "nothing here", neg="none"),
+               tags=[], condition_space={"observation_tool": "ZXQ7"})
+        cands = cg._candidates()
+        sem_tool = {n["id"]: s for n, s in cg._path_semantic("ZXQ7", cands)}
+        fuz_tool, _ = cg._path_fuzzy("ZXQ7", cands)
+        fuz_ids = {n["id"] for n, _ in fuz_tool}
+        check("semantic 命中 observation_tool 槽", "tool_node" in sem_tool, str(sem_tool))
+        check("fuzzy 读不到 condition_space 字段（正交证据）",
+              "tool_node" not in fuz_ids, str(fuz_ids))
+
+        # 负条件（不适用条件）是反例声明，两条路径都不作召回键
+        # （语义修正：反例的正确去向是 judge_qualification 的 REJECT，不是召回）
+        cg.add("neg_declared", mk("通用流程", "问通用流程", "通用流程说明",
+                                  neg="问ZXQ7"),
+               tags=[], condition_space={})
+        cands = cg._candidates()
+        fuz_neg, _ = cg._path_fuzzy("ZXQ7", cands)
+        sem_neg = {n["id"] for n, _ in cg._path_semantic("ZXQ7", cands)}
+        check("fuzzy 不再召回「不适用条件」命中的节点（反例不作召回键）",
+              "neg_declared" not in {n["id"] for n, _ in fuz_neg})
+        check("semantic 同样剔除「不适用条件」命中的节点（条件级负路由）",
+              "neg_declared" not in sem_neg)
+        check("但正条件仍作召回键（生效条件命中照常召回）",
+              "neg_declared" in
+              {n["id"] for n, _ in cg._path_fuzzy("通用流程", cands)[0]})
+
+        # 迁移语料形态：state_attributes.comment.生效条件
+        cg.add("mig", mk("骨架卡", "（隐含）", "骨架填充的知识点",
+                         neg="其它"),
+               tags=["domain:高等数学"], condition_space=CS_MATH,
+               state_attributes={"comment": {"生效条件": ["问微分方程应用", "问微分方程"],
+                                             "不适用条件": ["问数列极限"]}})
+        sem_mig = {n["id"]: s for n, s in cg._path_semantic("微分方程", cg._candidates())}
+        check("迁移语料 state_attributes 生效条件被读取", "mig" in sem_mig, str(sem_mig))
+
+        # ---------------- 4. RRF 接入 ----------------
+        print("\n【4】semantic 接入 RRF（默认不启用）")
+        res0, meta0 = cg.search_rrf("微分方程", k=5)
+        check("默认 RRF 路径不含 semantic",
+              "semantic" not in meta0.get("paths", {}), str(list(meta0.get("paths", {}))))
+
+        paths6 = ("lexical", "bucket", "entity", "graph", "fuzzy", "semantic")
+        res, meta = cg.search_rrf("微分方程", k=5, paths=paths6)
+        check("显式启用后 meta 记录 semantic 路",
+              "semantic" in meta.get("paths", {}), str(meta.get("paths")))
+        prov = meta.get("provenance", {})
+        check("provenance 含 semantic 路",
+              any(any(p["path"] == "semantic" for p in prov.get(nid, []))
+                  for nid in prov),
+              str({k: [p["path"] for p in v] for k, v in prov.items()})[:160])
+        check("结果非空", len(res) > 0, f"{len(res)} 条")
+
+        # 单路可独立运行（无 context）
+        res_s, meta_s = cg.search_rrf("微分方程", k=5, paths=("semantic",))
+        check("semantic 单路在无 context 下可运行",
+              isinstance(res_s, list) and len(res_s) > 0, f"{len(res_s)} 条")
+
+        # recall 透传 paths
+        rec = cg.recall("微分方程", budget_tokens=400, k=5, paths=paths6)
+        check("recall 可透传 paths 启用 semantic",
+              "semantic" in rec["meta"].get("paths", {}),
+              str(rec["meta"].get("paths")))
+        check("recall 仍遵守预算", rec["tokens_used"] <= rec["budget"],
+              f"used={rec['tokens_used']}/{rec['budget']}")
+        cg.close()
+    finally:
+        shutil.rmtree(root, ignore_errors=True)
+
+    print("\n" + "=" * 68)
+    print(f"通过 {PASS} / 失败 {FAIL}")
+    if FAILS:
+        print("失败项：" + ", ".join(FAILS))
+    print("=" * 68)
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())