@furongjun1999/dsh-memory 0.4.4 → 0.4.6

package/md_cg/test_lock.py

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+"""FileLock 跨进程互斥性验证（不猜，直接测）。
+
+N 个进程各做 M 次「锁内 读-加一-写」。若锁真互斥，最终值必然 == N*M。
+"""
+import os
+import sys
+import subprocess
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from md_cg.fsutil import FileLock, atomic_write
+
+TARGET = os.path.join(os.path.dirname(os.path.abspath(__file__)), "_locktest.txt")
+
+
+def worker(m):
+    for _ in range(m):
+        with FileLock(TARGET) as lk:
+            if not lk.acquired:
+                print("LOCK_TIMEOUT", file=sys.stderr)
+            try:
+                with open(TARGET) as f:
+                    v = int(f.read().strip() or 0)
+            except (OSError, ValueError):
+                v = 0
+            atomic_write(TARGET, str(v + 1))
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1 and sys.argv[1] == "--worker":
+        worker(int(sys.argv[2]))
+        sys.exit(0)
+    N, M = 6, 50
+    atomic_write(TARGET, "0")
+    ps = [subprocess.Popen([sys.executable, os.path.abspath(__file__), "--worker", str(M)])
+          for _ in range(N)]
+    [p.wait() for p in ps]
+    with open(TARGET) as f:
+        got = int(f.read().strip())
+    print(f"期望 {N*M}，实际 {got} → {'互斥正常' if got == N*M else '★锁失效，丢了 %d 次' % (N*M-got)}")
+    os.remove(TARGET)
+    if os.path.exists(TARGET + ".lock"):
+        os.remove(TARGET + ".lock")

package/md_cg/test_p0.py

@@ -0,0 +1,250 @@
+# -*- coding: utf-8 -*-
+"""md 认知图 P0 验收测试 · 逐条对应四个风险
+
+语料：自建 md 文档记忆库（14 域 × 6 知识点 × 4 侧面 = 336 个 md 节点，CCG 五要素
+正文），不依赖任何外部数据库。旧版依赖 wisdom-book-cloud-new.db 做「迁移等价」与
+「sqlite 基线对比」；本仓库没有该库（也不该有），故按「用新的 md 文档记忆库做验证」
+把三处绑定全部换成 md 原生等价物：
+  · 迁移节点数/字段等价        → md 语料完整落盘 + md 文档形态（五要素齐备）
+  · sqlite 读 condition_space  → 直接从 md 节点 frontmatter 读（退化对照）
+  · sqlite 版 recall@10 基线   → md 原生：无 context 全量阶梯 vs 有 context 桶路由
+
+幂等：重跑 ≡ 首跑，且**不靠清空目录**——`corpus.seed()` 按固定 node id 原子覆盖，
+清空多余且脆弱（依赖 rmtree 全量删除，在批量删除安全策略下会被拦截并中断进程，
+见 corpus.reset_root 的说明）。守门断言是本用例的**等号**断言「索引节点数 ==
+语料期望数」：一旦有残留污染，它会被打红，而不会被清空动作悄悄掩盖。
+
+跑法：
+    python -m md_cg.test_p0
+"""
+import os
+import sys
+import json
+import time
+import subprocess
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from md_cg.mdcg import (MdCG, TIER_BUCKET_LIKE, TIER_BUCKET_SCAN,
+                        TIER_GLOBAL_LIKE, TIER_GLOBAL_SCAN)
+from md_cg import routing
+from md_cg import corpus
+
+BASE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+ROOT = os.path.join(BASE, "_md_cg_p0")
+CONC_ROOT = ROOT + "_conc"
+
+# 语料、域划分与根目录重置见 md_cg/corpus.py（P0/P1 共用一套，避免两个验收测试
+# 各写一份 14 域清单后互相漂移）
+
+PASS, FAIL = [], []
+
+
+def check(name, cond, detail=""):
+    (PASS if cond else FAIL).append(name)
+    print(f"  [{'PASS' if cond else 'FAIL'}] {name}{'  ' + detail if detail else ''}")
+    return cond
+
+
+# ---------------------------------------------------------------- 并发子进程入口
+def _conc_worker(root, wid, n):
+    # wid 形如 "0_3"（轮次_进程序号）；域按进程序号定，保证跨进程可复现
+    dom = int(str(wid).split("_")[-1]) % 3
+    cg = MdCG(root, autoflush=7)
+    for i in range(n):
+        cg.add(f"w{wid}_{i}", f"并发写入 worker{wid} 第{i}条 记忆内容",
+               tags=[f"domain:并发域{dom}"], importance=0.5)
+    cg.flush()
+    cg.close()
+
+
+def main():
+    print("=" * 68)
+    print("md 认知图 P0 验收 · 四风险逐条验证")
+    print("=" * 68)
+
+    # ============================================================ 风险1
+    print("\n【风险1】分桶键退化 —— 归一化路由键 vs 文档原方案")
+    # 先重置根目录再灌语料：写入幂等，但残留会让「首跑」与「重跑」不等价
+    corpus.reset_root(ROOT)
+    corpus.reset_root(CONC_ROOT)
+    cg = MdCG(ROOT, autoflush=64)
+    written = corpus.seed(cg, marks=True)
+    # 落盘 _index.json 快照（等价于旧版 migrate 的收尾动作）：风险4 要断言
+    # 「检索不改写索引快照」，前提是快照本身已经存在
+    cg.rebuild_index()
+    print(f"  自建语料：{len(corpus.DOMAINS)} 域 × {len(corpus.ASPECTS)} 侧面 → "
+          f"写入 {written} 节点，索引 {len(cg.index['nodes'])} 节点")
+    check("自建 md 语料完整落盘（节点数一致）",
+          written == corpus.EXPECTED_NODES
+          and len(cg.index["nodes"]) == corpus.EXPECTED_NODES,
+          f"{written} == {corpus.EXPECTED_NODES}")
+    sample_ids = list(cg.index["nodes"])[:30]
+    bad = [nid for nid in sample_ids
+           if not all(m in (cg.get(nid)["content"] or "") for m in corpus.MARKS)]
+    check("节点是 md 文档形态（CCG 五要素齐备）", not bad, f"缺要素 {len(bad)} 个 {bad[:3]}")
+
+    h = cg.health()
+    print(f"  归一化路由键：{h['buckets']} 桶 / {h['total_nodes']} 节点，"
+          f"最大桶 {h['max_bucket_share']:.1%}，单例桶率 {h['singleton_ratio']:.1%}，"
+          f"期望扫描 {h['expected_scan']:.1%}")
+    check("分区健康度自检通过", h["ok"], str(h.get("problems")))
+    check("期望扫描占比 < 10%（条件路由确实非全量）", h["expected_scan"] < 0.10,
+          f"{h['expected_scan']:.1%}")
+
+    # 对照：文档原方案（原始四元组哈希）在同一批 md 节点上的表现
+    raw = {}
+    for nid in cg.index["nodes"]:
+        cs = cg.get(nid)["frontmatter"].get("condition_space") or {}
+        key = routing.bucket_dir(json.dumps(cs, sort_keys=True))
+        raw[key] = raw.get(key, 0) + 1
+    raw_h = routing.bucket_health(raw)
+    print(f"  对照·原四元组哈希：{raw_h['buckets']} 桶，单例桶率 {raw_h['singleton_ratio']:.1%}")
+    check("原方案确被判定为退化（自检能抓到）", not raw_h["ok"], str(raw_h["problems"]))
+
+    # ============================================================ 风险2
+    print("\n【风险2】检索情境入参 —— 有/无 context 的行为都必须是显式定义的")
+    total = len(cg.index["nodes"])
+    r_no, m_no = cg.search("知识点", layer="knowledge", k=10, context=None)
+    check("无 context 时不做条件路由（bucket=None）", m_no["bucket"] is None)
+    check("无 context 时走全量阶梯", m_no["tier"] in (TIER_GLOBAL_LIKE, TIER_GLOBAL_SCAN),
+          m_no["tier"])
+
+    ctx = {"tags": ["domain:计算机科学"]}
+    r_ctx, m_ctx = cg.search("知识点", layer="knowledge", k=10, context=ctx)
+    check("有 context 时命中路由桶", m_ctx["bucket"] is not None, m_ctx["bucket"])
+    check("有 context 时扫描量远小于全库", m_ctx["scanned"] < total * 0.10,
+          f"扫 {m_ctx['scanned']} / 全库 {total} = {m_ctx['scanned']/total:.1%}")
+    check("写入侧与查询侧路由键同构（桶内确实有节点）", m_ctx["candidates"] > 0,
+          f"候选 {m_ctx['candidates']}")
+
+    # ============================================================ 风险3
+    print("\n【风险3】回退阶梯 —— 桶内落空不得返回空，且必须自报命中层级")
+    # 情境正确但查询词在该桶内不存在 → 必须继续往下走，而不是"分区隔离，预期无"
+    r_fb, m_fb = cg.search("量子色动力学夸克禁闭", layer="knowledge", k=5, context=ctx)
+    check("桶内落空后仍有结果（未被条件分区误杀）", len(r_fb) > 0,
+          f"{len(r_fb)} 条 @ {m_fb['tier']}")
+    check("回退结果自报层级", m_fb["tier"] in (TIER_BUCKET_SCAN, TIER_GLOBAL_LIKE,
+                                              TIER_GLOBAL_SCAN), m_fb["tier"])
+    # 情境完全不存在的桶 → 直接落到全量阶梯
+    r_gh, m_gh = cg.search("能量守恒", layer="knowledge", k=5,
+                           context={"tags": ["domain:根本不存在的域xyz"]})
+    check("不存在的路由桶 → 落到全量阶梯而非返回空", len(r_gh) > 0,
+          f"{len(r_gh)} 条 @ {m_gh['tier']}")
+    tiers = {}
+    for q in ("能量守恒", "二分查找", "贝塞尔不等式", "不存在词zzz999", "细胞呼吸"):
+        _, m = cg.search(q, layer="knowledge", k=5, context=ctx)
+        tiers[q] = m["tier"]
+    print(f"  层级分布：{json.dumps(tiers, ensure_ascii=False)}")
+
+    # ============================================================ 风险4
+    print("\n【风险4】检索不得变成写操作")
+    sample = list(cg.index["nodes"].values())[:200]
+    before = {e["path"]: os.path.getmtime(os.path.join(ROOT, e["path"])) for e in sample}
+    idx_before = os.path.getmtime(cg.index_path)
+    ilog_before = sum(os.path.getsize(os.path.join(cg.index_log_dir, f))
+                      for f in os.listdir(cg.index_log_dir)) \
+        if os.path.isdir(cg.index_log_dir) else 0
+    log_before = os.path.getsize(cg.access_log) if os.path.exists(cg.access_log) else 0
+    time.sleep(0.05)
+    for q in ("能量守恒", "二分查找", "知识点", "细胞", "函数"):
+        cg.search(q, layer="knowledge", k=10, context=ctx)
+    after = {p: os.path.getmtime(os.path.join(ROOT, p)) for p in before}
+    check("检索未修改任何节点 .md（mtime 全不变）", before == after,
+          f"变动 {sum(1 for p in before if before[p] != after[p])} 个")
+    check("检索未重写索引快照", os.path.getmtime(cg.index_path) == idx_before)
+    check("检索未写索引日志",
+          (sum(os.path.getsize(os.path.join(cg.index_log_dir, f))
+               for f in os.listdir(cg.index_log_dir))
+           if os.path.isdir(cg.index_log_dir) else 0) == ilog_before)
+    log_after = os.path.getsize(cg.access_log)
+    check("访问计数写入了 append-only 日志", log_after > log_before,
+          f"{log_before} → {log_after} 字节")
+    counts, _last = cg.access_counts()
+    check("日志可聚合出访问计数", len(counts) > 0, f"{len(counts)} 个节点有计数")
+    hot = max(counts, key=counts.get)
+    n_compact = cg.compact_access()
+    fm = cg.get(hot)["frontmatter"]
+    check("compact 后计数落盘到 frontmatter", fm.get("access_count", 0) > 0,
+          f"{hot} access_count={fm.get('access_count')}，共合并 {n_compact} 节点")
+    check("compact 后日志被截断", os.path.getsize(cg.access_log) == 0)
+
+    # ============================================================ 索引可重建 / 并发
+    print("\n【附加】索引可重建（单点风险）与多进程写")
+    n_before = len(cg.index["nodes"])
+    cg.compact_index()
+    os.remove(cg.index_path)
+    cg2 = MdCG(ROOT)
+    check("删掉 _index.json 后能从 md 目录完整重建", len(cg2.index["nodes"]) == n_before,
+          f"{len(cg2.index['nodes'])} == {n_before}")
+    with open(cg2.index_path, "w", encoding="utf-8") as f:
+        f.write("{ 这不是合法 json")
+    cg3 = MdCG(ROOT)
+    check("索引损坏能自愈重建", len(cg3.index["nodes"]) == n_before,
+          f"{len(cg3.index['nodes'])}")
+
+    # 并发跑多轮：索引竞态是间歇性的，单轮通过说明不了问题。
+    # 各轮用不同 id 前缀写进同一目录（幂等，不需要清理），校验「本轮写入的 id
+    # 是否一条不少地进了索引」——这比比总数更严格，能定位到是谁丢的。
+    W, N, ROUNDS = 6, 40, 3
+    ok_disk, ok_idx = True, True
+    for rd in range(ROUNDS):
+        procs = [subprocess.Popen([sys.executable, os.path.abspath(__file__),
+                                   "--worker", CONC_ROOT, f"{rd}_{i}", str(N)],
+                                  cwd=os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+                 for i in range(W)]
+        rc = [p.wait() for p in procs]
+        expect = {f"w{rd}_{i}_{j}" for i in range(W) for j in range(N)}
+        cgc = MdCG(CONC_ROOT)
+        missing_idx = expect - set(cgc.index["nodes"])
+        missing_disk = expect - set(cgc.rebuild_index()["nodes"])
+        if not all(x == 0 for x in rc) or missing_disk:
+            ok_disk = False
+            print(f"    轮次 {rd}：磁盘缺 {len(missing_disk)} 条")
+        if missing_idx:
+            ok_idx = False
+            print(f"    轮次 {rd}：索引缺 {len(missing_idx)} / {W * N} 条")
+    check(f"多进程写：磁盘文件无丢失（{ROUNDS} 轮 × {W} 进程 × {N} 条）", ok_disk)
+    check(f"多进程写：索引无覆盖丢失（{ROUNDS} 轮 × {W} 进程 × {N} 条）", ok_idx)
+
+    # ============================================================ 基线对比
+    print("\n【基线】条件路由不得丢召回：无 context 全量阶梯 vs 有 context 桶路由")
+    queries = [("能量守恒", "物理学"), ("牛顿第二定律", "物理学"), ("熵增", "物理学"),
+               ("二分查找", "计算机科学"), ("事务隔离", "计算机科学"),
+               ("细胞呼吸", "生物学"), ("光合作用", "生物学"),
+               ("贝塞尔不等式", "数学"), ("内力与截面法", "机械工程"),
+               ("机会成本", "经济学")]
+    rows = []
+    for q, dom in queries:
+        r_all, _ma = cg.search(q, layer="knowledge", k=10, context=None, record=False)
+        r_bk, mb = cg.search(q, layer="knowledge", k=10,
+                             context={"tags": [f"domain:{dom}"]}, record=False)
+        a_ids = [r[0]["id"] for r in r_all]
+        b_ids = [r[0]["id"] for r in r_bk]
+        inter = len(set(a_ids) & set(b_ids))
+        rec = inter / len(a_ids) if a_ids else 1.0
+        rows.append((q, dom, len(a_ids), len(b_ids), inter, rec, mb["tier"]))
+    print(f"  {'query':<16}{'域':<11}{'全量':>5}{'桶内':>5}{'交集':>5}{'recall@10':>11}  tier")
+    for q, dom, a, b, i, r, t in rows:
+        print(f"  {q:<16}{dom:<11}{a:>5}{b:>5}{i:>5}{r:>10.0%}  {t}")
+    avg = sum(x[5] for x in rows) / len(rows)
+    check("桶路由平均 recall@10 ≥ 0.9（加 context 不丢召回）", avg >= 0.9,
+          f"avg={avg:.1%}")
+
+    print("\n" + "=" * 68)
+    print(f"通过 {len(PASS)} / 失败 {len(FAIL)}")
+    if FAIL:
+        print("失败项：" + ", ".join(FAIL))
+    print("=" * 68)
+    return 1 if FAIL else 0
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1 and sys.argv[1] == "--worker":
+        _conc_worker(sys.argv[2], sys.argv[3], int(sys.argv[4]))
+        sys.exit(0)
+    # 用 reconfigure 而非「包一层 TextIOWrapper」：后者在 stdout 被重定向到文件时
+    # 会在解释器退出阶段丢缓冲（实测只落盘 444 字节），CI 里会看不到失败原因。
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8")
+    sys.exit(main())

package/md_cg/test_p1.py

@@ -0,0 +1,317 @@
+# -*- coding: utf-8 -*-
+"""md 认知图 P1 验收 · 白箱认知架构 9 维度补全
+
+覆盖（对照 docs/认知图_MD目录方案_v0.1.md v0.3 待办 + 白箱 5 篇）：
+  1. MARKS 5 要素 + 验证基底 + 不适用条件
+  2. 负记忆目录（rejected/unresolved）
+  3. 资格判定四态（ACCEPT/REJECT/DEFER/BLINDSPOT）
+  4. Top-1/Top-5/盲区触发率指标（vs 客观真值 oracle）
+  5. 两阶段并行收敛路由（14 大域 → 桶内 KCCS）
+  6. 信息差 D(t,C) 与 d²D/dt²
+  7. 知识飞轮：错误→补条件→结构更新
+  8. 五大单元之反思/验证
+  9. CCG 完整度 + 验证基底覆盖率健康度自检
+
+语料：md_cg/corpus.py 自建的 md 文档记忆库（336 节点），但用 **marks=False 的纯
+叙述正文** 写入 —— 模拟「从旧库迁移来的节点」，这样维度9 的「完整度不得虚报」
+才有对照物（只有本测试显式写的完整 CCG 节点才该被 health 计入）。
+旧版依赖 wisdom-book-cloud-new.db（迁移 + sqlite Top-5 基线）；本仓库按「用新的
+md 文档记忆库做验证」改为 md 原生，不再依赖任何外部数据库。
+
+说明：测试自建节点全部用「完整 CCG 正文」格式 + domain:数学 tag（否则
+资格判定会因 MARKS 不全而 BLINDSPOT——那是正确行为，不是 bug）。
+固定 id → 幂等可重跑；不靠清空目录（见 corpus.reset_root），重跑 ≡ 首跑由
+「knowledge 层节点数 == 语料数 + 本测试显式写入数」的等号断言守门。
+
+跑法：python -m md_cg.test_p1
+"""
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from md_cg.mdcg import (MdCG, STATE_ACCEPT, STATE_REJECT, STATE_DEFER,
+                        STATE_BLINDSPOT)
+from md_cg import nodefile, routing, corpus
+
+_BASE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+ROOT = os.path.join(_BASE, "_md_cg_p1")
+DOM_TAG = ["domain:数学"]
+
+PASS, FAIL = [], []
+
+
+def check(name, cond, detail=""):
+    (PASS if cond else FAIL).append(name)
+    print(f"  [{'PASS' if cond else 'FAIL'}] {name}"
+          + (f"   · {detail}" if detail not in ("", None) else ""))
+    return cond
+
+
+def ccg_body(subject, verify="由第 5 章实验记录验证", neg="无需例外"):
+    """构造完整 CCG 5 要素正文（第 1 篇第 17 章格式）。"""
+    return (f"# 功能名：{subject}\n"
+            f"# 生效条件：默认满足\n"
+            f"# 子功能：对 {subject} 建立白箱资格判定\n"
+            f"# 执行：检索 {subject} 相关条件证据\n"
+            f"# 验证方式：{verify}\n"
+            f"# 不适用条件：{neg}\n"
+            f"{subject} 的白箱执行正文。")
+
+
+def main():
+    print("=" * 68)
+    print("md 认知图 P1 验收 · 白箱认知架构 9 维度")
+    print("=" * 68)
+
+    # 自建 md 语料（纯叙述正文、无 MARKS）替代「从 sqlite 迁移」这一步：
+    # 维度9 要验「叙述节点不得被计为 CCG 完整」，迁移节点只是它的一个实例
+    corpus.reset_root(ROOT)
+    cg = MdCG(ROOT, autoflush=64)
+    written = corpus.seed(cg, marks=False)
+    cg.rebuild_index()
+    print(f"自建 md 语料：{written} 节点（纯叙述正文，模拟旧库迁移节点）\n")
+
+    # ===================================================== 维度 1
+    print("【维度1】MARKS 5 要素 + 验证基底 + 不适用条件（白箱第 1 篇第 17 章）")
+    cg.add("p1_ok", ccg_body("能量守恒的判定"),
+           layer="knowledge", tags=DOM_TAG,
+           verification_basis="formal_proof",
+           non_applicable_conditions=["开放系统"])
+    cg.flush()
+    fm = cg.get("p1_ok")["frontmatter"]
+    check("frontmatter 含 verification_basis（枚举内）",
+          fm.get("verification_basis") == "formal_proof")
+    check("frontmatter 含 non_applicable_conditions",
+          fm.get("non_applicable_conditions") == ["开放系统"])
+    cpl = nodefile.ccg_completeness(cg.get("p1_ok")["content"])
+    check("完整 CCG 正文 → complete=True",
+          cpl["complete"] is True, f"required_present={cpl['required_present']}")
+    bad_vb = False
+    try:
+        cg.add("p1_badvb", ccg_body("x"), verification_basis="magic_guess")
+    except ValueError:
+        bad_vb = True
+    check("非法 verification_basis 被拒（枚举约束）", bad_vb)
+
+    # ===================================================== 维度 2
+    print("\n【维度2】负记忆目录（白箱第 5 篇 L2/L5）")
+    rej1 = cg.add_rejected(hypothesis="绿按钮是传送门",
+                           reason="按了 5 次门都没反应",
+                           verification_basis="test")
+    rej2 = cg.add_rejected(hypothesis="绿按钮是传送门",
+                           reason="按了 5 次门都没反应")
+    check("add_rejected 幂等（同假设不重复）", rej1 == rej2)
+    cg.add_unresolved(question="白箱资格判定能否跨域迁移",
+                      known_clues="CCG 5 要素在数学域 100%",
+                      goal="找反例")
+    check("rejected/ 目录存在且有节点",
+          os.path.isdir(os.path.join(ROOT, "rejected")) and
+          any(f.endswith(".md") for f in os.listdir(os.path.join(ROOT, "rejected"))))
+    check("unresolved/ 目录存在且有节点",
+          os.path.isdir(os.path.join(ROOT, "unresolved")) and
+          any(f.endswith(".md") for f in os.listdir(os.path.join(ROOT, "unresolved"))))
+    # rejected 的 MARKS 必填 = 假设/否决原因/验证（与 knowledge 不同）
+    rej_doc = cg.get(rej1)
+    check("rejected 节点用自身 MARKS（假设/否决原因）",
+          rej_doc and "# 假设：" in rej_doc["content"] and
+          "# 否决原因：" in rej_doc["content"])
+
+    # ===================================================== 维度 3
+    print("\n【维度3】资格判定四态（与性能 tier 正交）")
+    # 4 个测试节点正文都要含查询词「白箱资格判定」，否则召回不了（score=0 不返回）
+    cg.add("p1_accept", ccg_body("纯数学恒等式证明的白箱资格判定"),
+           tags=DOM_TAG, verification_basis="formal_proof",
+           non_applicable_conditions=["需要测量的物理量"])
+    cg.add("p1_defer", ccg_body("未经验证的观察假设的白箱资格判定"),
+           tags=DOM_TAG, non_applicable_conditions=[])
+    # BLINDSPOT：CCG 不完整（只给功能名），但仍含查询词可被召回
+    cg.add("p1_spot",
+           "# 功能名：残缺知识\n白箱资格判定正文没写完整要素。",
+           tags=DOM_TAG, verification_basis="test")
+    # REJECT：不适用条件命中 context（同一 query，context 含海拔词）
+    cg.add("p1_reject", ccg_body("海拔环境的白箱资格判定"),
+           tags=DOM_TAG, verification_basis="test",
+           non_applicable_conditions=["海拔 > 5000 米"])
+    cg.flush()
+
+    ctx = {"tags": DOM_TAG, "环境": "当前测量在海拔 > 5000 米进行"}
+    r, m = cg.search("白箱资格判定", k=30, context=ctx)
+    states = {x[0]["id"]: x[2]["state"] for x in r}
+    check("CCG 完整+基底+条件未命中 → ACCEPT",
+          states.get("p1_accept") == STATE_ACCEPT, str(states.get("p1_accept")))
+    check("CCG 完整但无验证基底 → DEFER",
+          states.get("p1_defer") == STATE_DEFER, str(states.get("p1_defer")))
+    check("CCG 要素不全 → BLINDSPOT",
+          states.get("p1_spot") == STATE_BLINDSPOT, str(states.get("p1_spot")))
+    check("不适用条件命中 → REJECT",
+          states.get("p1_reject") == STATE_REJECT, str(states.get("p1_reject")))
+    check("被 REJECT 的节点仍被召回（资格≠性能）",
+          "p1_reject" in states, f"tier={m['tier']}")
+
+    # ===================================================== 维度 4
+    print("\n【维度4】Top-1 / Top-5 / 盲区触发率（第 1 篇第 9 章 CCG 指标）")
+    # 真值来源：客观 oracle —— 正文含查询词的 knowledge 节点全集（即 LIKE 的严格定义）。
+    # 旧版拿 sqlite 版 Top-5 当基线，本质是「拿另一个实现的排序偏好当真值」；
+    # md 原生下换成 oracle 反而更硬：它不依赖任何实现的排序，只依赖语料事实。
+    queries = ["能量守恒", "二分查找", "细胞呼吸", "贝塞尔不等式", "牛顿第二定律",
+               "光合作用", "事务隔离", "内力与截面法", "熵增", "机会成本"]
+    contents = {nid: (cg.get(nid) or {}).get("content", "")
+                for nid, e in cg.index["nodes"].items() if e["layer"] == "knowledge"}
+    t1 = t5 = 0
+    n = 0
+    blindspots = []
+    print(f"  {'query':<14}{'真值集':>7}{'召回':>6}{'Top-1':>7}")
+    for q in queries:
+        gold = [nid for nid, c in contents.items() if q in c]
+        if not gold:
+            blindspots.append(q)
+            continue
+        n += 1
+        r, _m = cg.search(q, layer="knowledge", k=5, context=None, judge=False)
+        got = [x[0]["id"] for x in r]
+        hit = set(got) & set(gold)
+        top1_ok = bool(got) and got[0] in gold
+        if top1_ok:
+            t1 += 1
+        if hit:
+            t5 += 1
+        print(f"  {q:<14}{len(gold):>7}{len(hit):>6}{'是' if top1_ok else '否':>7}")
+    top1, top5 = (t1 / n if n else 0.0), (t5 / n if n else 0.0)
+    print(f"  Top-1 = {top1:.0%}（md Top-1 落在客观真值集内）")
+    print(f"  Top-5 = {top5:.0%}，无真值（盲区）查询 = {blindspots}")
+    check("Top-1 ≥ 0.7（最强证据放在最前）", top1 >= 0.7, f"{top1:.0%}")
+    check("Top-5 ≥ 0.9（不漏召回）", top5 >= 0.9, f"{top5:.0%}")
+    check("无盲区（每个查询在语料中都有真值）", not blindspots, str(blindspots))
+
+    # ===================================================== 维度 5
+    print("\n【维度5】两阶段并行收敛路由（第 2 篇第 5 章 + 第 3 篇第 4 章）")
+    check("物理词收敛到物理大域",
+          routing.big_domain_classify(["能量守恒", "海拔", "沸点"]) == "物理")
+    check("数学词收敛到数学大域",
+          routing.big_domain_classify(["贝塞尔不等式", "矩阵", "证明"]) == "数学")
+    check("生物词收敛到生物大域",
+          routing.big_domain_classify(["细胞呼吸", "光合作用", "酶"]) == "生物")
+    check("无命中词 → None（不做错误收敛）",
+          routing.big_domain_classify(["qzzzz完全虚构"]) is None)
+    r, m = cg.search("能量守恒", k=5, context=None)
+    check("search meta 报告大域收敛",
+          m.get("big_domain") == "物理", f"big_domain={m.get('big_domain')}")
+    scores = m.get("big_domain_scores", {})
+    check("大域打分明细可审计",
+          isinstance(scores, dict) and scores.get("物理", 0) >= 1 and
+          scores["物理"] == max(scores.values()),
+          f"scores[物理]={scores.get('物理')}")
+
+    # ===================================================== 维度 6
+    print("\n【维度6】信息差 D(t,C) 与 d²D/dt²（第 3/4 篇）")
+    # 无结果查询 → D=1.0（信息差空白）；含 ACCEPT 结果 → D 应显著回落
+    rf_empty = cg.reflect("完全虚构词 qzzzz", [])
+    fake_hit = [({"id": "x", "frontmatter": {}, "content": "c"}, 1.0,
+                 {"state": "ACCEPT"})]
+    rf_hit = cg.reflect("能量守恒", fake_hit)
+    check("无结果查询 → D=1.0（信息差空白）",
+          rf_empty["d_curr"] == 1.0, f"D={rf_empty['d_curr']:.2f}")
+    check("有效命中 → D 显著回落（D=D(t,C) 演化）",
+          rf_hit["d_curr"] <= 0.5, f"D={rf_hit['d_curr']:.2f}")
+    check("d_delta（一阶变化）被记录", "d_delta" in rf_hit)
+    check("d2 = d²D/dt² 被计算", "d2" in rf_hit,
+          f"d2={rf_hit.get('d2')}")
+    check("反思日志追加落盘",
+          os.path.exists(cg.reflection_log) and os.path.getsize(cg.reflection_log) > 0)
+
+    # ===================================================== 维度 7
+    print("\n【维度7】知识飞轮（第 2 篇第 8 章：误差→找条件→更新）")
+    fw = cg.flywheel_step({"query": "能量守恒", "expected_state": "ACCEPT",
+                           "actual_state": "BLINDSPOT",
+                           "missing": "缺少开放/封闭系统的条件分支"})
+    unr_doc = cg.get(fw["unresolved_id"])
+    check("飞轮产出 unresolved 条目", unr_doc is not None and
+          "已知线索" in unr_doc["content"])
+    # 飞轮是知识闭环入口：同一 query 再次遇盲区不重复建条目（幂等）
+    fw2 = cg.flywheel_step({"query": "能量守恒", "expected_state": "ACCEPT",
+                            "actual_state": "BLINDSPOT",
+                            "missing": "缺少开放/封闭系统的条件分支"})
+    check("飞轮幂等（同问题不重复产条目）",
+          fw["unresolved_id"] == fw2["unresolved_id"])
+
+    # ===================================================== 维度 8
+    print("\n【维度8】验证单元（第 3 篇第 13 章）")
+    cg.add("p1_verify", ccg_body("验证目标卡片"), tags=DOM_TAG,
+           verification_basis="test")
+    cg.flush()
+    pre = float(cg.get("p1_verify")["frontmatter"]["confidence"])
+    cg.verify("p1_verify", "通过 5 次实验确认", "confirmed")
+    post = float(cg.get("p1_verify")["frontmatter"]["confidence"])
+    check("confirmed → confidence 上调", post > pre, f"{pre} → {post}")
+    # weakened：confidence 非对称下调（反例权重大于正例）
+    pre2 = float(cg.get("p1_verify")["frontmatter"]["confidence"])
+    cg.verify("p1_verify", "与另一实验组结果不符", "weakened")
+    post2 = float(cg.get("p1_verify")["frontmatter"]["confidence"])
+    check("weakened → confidence 下调", post2 < pre2, f"{pre2} → {post2}")
+    # falsified：add_rejected 按内容 hash 幂等，故断言「存在负记忆条目」而非计数增量
+    cg.verify("p1_verify", "发现反例：条件不成立", "falsified")
+    neg_ids = [e.get("path") for e in cg.index["nodes"].values()
+               if e["layer"] == "rejected"]
+    neg_hit = False
+    for p in neg_ids:
+        full_p = os.path.join(ROOT, p)
+        try:
+            with open(full_p, encoding="utf-8") as f:
+                neg_hit = neg_hit or "验证目标卡片" in f.read()
+        except OSError:
+            pass
+    check("falsified → 节点负记忆化（rejected/ 出现对应条目）", neg_hit,
+          f"rejected 节点数={len(neg_ids)}")
+    gone = cg.get("p1_verify")
+    check("falsified 后原 knowledge 节点被移除", gone is None,
+          "p1_verify 已不在 knowledge")
+
+    # ===================================================== 维度 9
+    print("\n【维度9】CCG 完整度 + 验证基底覆盖率（health 自检）")
+    # 守门断言（重跑 ≡ 首跑）：既然不再靠清空目录（见 corpus.reset_root），
+    # 「knowledge 层恰好 = 语料 + 本测试显式写入」就必须被显式守住——
+    # 有残留节点会在这里打红，而不是被 rmtree 静默掩盖。
+    explicit_knowledge = ("p1_ok", "p1_accept", "p1_defer", "p1_spot", "p1_reject")
+    n_know = sum(1 for e in cg.index["nodes"].values() if e["layer"] == "knowledge")
+    check("重跑 ≡ 首跑：knowledge 层节点数不多不少（无残留污染）",
+          n_know == corpus.EXPECTED_NODES + len(explicit_knowledge),
+          f"{n_know} == {corpus.EXPECTED_NODES} + {len(explicit_knowledge)}")
+    h = cg.health()
+    kb = h.get("ccg_by_layer", {}).get("knowledge", {})
+    rej_cnt = h.get("neg_memory_counts", {}).get("rejected", 0)
+    unr_cnt = h.get("neg_memory_counts", {}).get("unresolved", 0)
+    check("health 报告 knowledge 层 CCG 完整度统计",
+          kb.get("total", 0) >= corpus.EXPECTED_NODES and "ccg_complete" in kb,
+          f"total={kb.get('total')}")
+    check("health 报告负记忆密度（rejected/unresolved 均 >0）",
+          rej_cnt >= 1 and unr_cnt >= 1,
+          f"rejected={rej_cnt}, unresolved={unr_cnt}")
+    # 叙述节点（无 MARKS）不得被计为完整；只有我们显式写的完整 CCG 才算
+    full_ids = [nid for nid in ("p1_ok", "p1_accept", "p1_defer", "p1_reject")
+                if cg.get(nid) and nodefile.ccg_completeness(
+                    cg.get(nid)["content"])["complete"]]
+    expected_full = len(full_ids)
+    # corpus.seed(marks=False) 的 336 个节点是纯叙述正文（不含 MARKS 行）→ 不被计入；
+    # 我们显式写的完整 CCG 节点必须都被统计到
+    check("所有完整 CCG 测试节点均被 health 计入",
+          kb.get("ccg_complete", 0) >= expected_full,
+          f"expected>= {expected_full}, got={kb.get('ccg_complete')}")
+    check("叙述节点完整度不虚报（完整数远小于总数）",
+          kb.get("ccg_complete", 0) < kb.get("total", 0) * 0.05,
+          f"complete={kb.get('ccg_complete')}/{kb.get('total')}")
+
+    print("\n" + "=" * 68)
+    print(f"通过 {len(PASS)} / 失败 {len(FAIL)}")
+    if FAIL:
+        print("失败项：\n  - " + "\n  - ".join(FAIL))
+    print("=" * 68)
+    return 1 if FAIL else 0
+
+
+if __name__ == "__main__":
+    # 用 reconfigure 而非「包一层 TextIOWrapper」：后者在 stdout 重定向到文件时
+    # 会在解释器退出阶段丢缓冲，CI 里会看不到失败原因。
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8")
+    sys.exit(main())