@furongjun1999/dsh-memory 0.4.7 → 0.4.9

package/md_cg/test_p27_docindex.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 """条件文档图端到端测试（P27 · 认知图的文档面）。
 
-R2 改造的验收（对照 docs/认知图_索引与工程规范化_计划_v0.1.md §六 R2、§七）：
+R2 改造的验收（对照 docs/mdcg/认知图_索引与工程规范化_计划_v0.1.md §六 R2、§七）：
 
   ① 切块纪律：只切 level<=3；直接正文 <200 字且无子节的小节**合并进父节**
      （不单独建节点，其文字进父节摘要）。既不过细，也不丢内容。
@@ -20,20 +20,31 @@ R2 改造的验收（对照 docs/认知图_索引与工程规范化_计划_v0.1.
   ⑦ 不静默：truncated / skipped_suffixes / skipped_dirs 显式上报；排除为**追加**
      （只增不减，内置 .git/.venv/node_modules 不可被关闭）；只读契约（源 mtime 不变）；
      幂等（重跑节点数不变）；`index_doc` 进 ALL_OPS 且与工具 schema 一致。
+  ⑧ fence 往返列六件套的形状与边界：BINDING_FIELDS / binding_of / binding_key
+     （**不含行位**）/ binding_slug / validate_binding / binding_drift / locate。
+     为什么必须钉死：列形状漂移会让对账器把坏列当好消息（漏报）；键若悄悄带上
+     行位，真源上方插一行就会让整库失配——两者都是静默退化，只有断言看得见。
+  ⑨ 逐字节回放回归：对**真实索引出的卡**断言 `render(条目) + "\n" == 卡片正文`。
+     ⑧ 只证「列可定位」；只有逐字节相等才证明卡片是真源条目的**派生物**而非另一份
+     副本（渲染漂移或人工改写时列全然不变，对账器看不出来）。外部历史库另段抽样
+     （设 MDCG_ROOT 则跑，未设如实 SKIP 不虚报通过）。
 
 运行：python -m md_cg.test_p27_docindex
+     设 MDCG_ROOT=<认知图库根> 追加跑【12b】外部历史库逐字节回放抽样
 """
 from __future__ import annotations
 
 import os
+import random
 import shutil
 import sys
 import tempfile
 
-from . import codeindex, corpus, docindex, nodefile, routing, tokens
+from . import codeindex, corpus, docindex, nodefile, refindex, routing, tokens
 from . import mcp_server
-from .mdcos import MdCGOS          # 生产路径：forget 属 OS 层，基础层 MdCG 无删除原语
+from .mdcos import MdCGOS, MdCGSecure   # 生产路径：forget 属 OS 层，基础层 MdCG 无删除原语
 from .mcp_server import call_tool
+from .security import Principal
 
 PASS = FAIL = 0
 FAILS = []
@@ -41,7 +52,7 @@ FAILS = []
 _BASE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 ROOT = os.path.join(_BASE, "_md_cg_p27")
 DOCS = os.path.join(_BASE, "docs")
-PLAN_DOC = "认知图_MD目录方案_v0.1.md"
+PLAN_DOC = "mdcg/认知图_MD目录方案_v0.1.md"
 
 
 def check(name, cond, detail=""):
@@ -55,6 +66,79 @@ def check(name, cond, detail=""):
         print(f"  [FAIL] {name}  · {detail}")
 
 
+def _norm(p):
+    """路径归一（大小写 + 分隔符）：root 归属比对用，避免同一目录被判成两个。"""
+    return os.path.normcase(os.path.normpath(str(p or "")))
+
+
+# 逐字节回放：把「往返列」从「形状可校验」推进到「内容可无损重建」。
+# 生效条件：cg 已索引完成的库；索引条目 tags 含 "doc" 且 frontmatter 有非空 doc_ref。
+# 判据：真源同键条目 `render(条目)` 补一个换行 == 卡片正文——`nodefile.dumps` 对不以
+# 换行结尾的正文补 '\n'，故卡片正文恒比 render 多 1 字节（是常态，不是缺陷；判等
+# 一律按 `render + "\n"`，避免把口径差当回归）。
+# 为什么非此不可：列形状对（validate_binding）只保证「可定位」；只有逐字节相等才
+# 证明卡片是真源条目的**派生物**而非另一份副本。渲染漂移或人工改写卡片正文时，
+# 列全都不变（路径/行位/hash 都是真源侧的值），对账器看不出来——本函数才看得见。
+# 悬空（真源已移出）/ 未解析如实计数：那是数据面事实，不冒充渲染失败。
+def _replay_cards(cg, roots=None, sample=0, seed=7):
+    nodes = (getattr(cg, "index", {}) or {}).get("nodes") or {}
+    picks = []
+    for nid in sorted(nodes):
+        if "doc" not in ((nodes.get(nid) or {}).get("tags") or []):
+            continue
+        kind, ref = refindex.ref_of(cg.get(nid))
+        if kind != "doc_ref" or not ref:
+            continue
+        if roots is not None and _norm(ref.get("root")) not in roots:
+            continue
+        picks.append((nid, ref))
+    if sample and len(picks) > sample:
+        picks = sorted(random.Random(seed).sample(picks, sample))
+    out = {"sampled": len(picks), "ok": 0, "dangling": 0, "gone": 0,
+           "unreadable": 0, "mismatch": []}
+    cache = {}
+    for nid, ref in picks:
+        fp = (str(ref.get("root") or ""), str(ref.get("path") or ""))
+        ckey = (_norm(fp[0]), fp[1])
+        if ckey not in cache:
+            # 把「源文件已移出」（数据面事实，非缺陷）与其它 IO/抽取异常（可能是真
+            # 问题：权限、编码、源被改成无标题文档）分开计数——混为一谈会把真实
+            # 故障伪装成历史遗留，静默吞掉回归。三态：True 读得 / False 不存在 /
+            # None 读不了。
+            try:
+                with open(os.path.join(fp[0], fp[1]), "r", encoding="utf-8",
+                          errors="replace") as f:
+                    cache[ckey] = (True, docindex.extract(f.read(), fp[1]))
+            except FileNotFoundError:
+                cache[ckey] = (False, None)
+            except (OSError, ValueError):
+                cache[ckey] = (None, None)
+        hit, items = cache[ckey]
+        if hit is not True:
+            out["gone" if hit is False else "unreadable"] += 1
+            continue
+        node = cg.get(nid) or {}
+        want = docindex.binding_key(docindex.binding_of(node))
+        # 键（path#heading_path）在同名标题重复时可能命中多条：先按行位锁定同名代，
+        # 行位也漂了才回落首条（此时本来就判「不符」，不掩盖结论）。
+        cands = [i for i in items if docindex.binding_key(i) == want]
+        if not cands:
+            out["dangling"] += 1
+            continue
+        item = next((i for i in cands if i.get("lineno") == ref.get("lineno")),
+                    cands[0])
+        got = docindex.render(item) + "\n"
+        content = node.get("content") or ""
+        if got == content:
+            out["ok"] += 1
+            continue
+        k = next((i for i in range(min(len(got), len(content)))
+                  if got[i] != content[i]), min(len(got), len(content)))
+        out["mismatch"].append(
+            f"{nid}@{k} 回放={got[k:k + 24]!r} 卡片={content[k:k + 24]!r}")
+    return out
+
+
 LONG = "这是总览段落，" + "用以验证章节切块在长正文下的表现，" * 12 + "结束。"
 
 GUIDE_LINES = [
@@ -494,6 +578,176 @@ def main():
         check("清退后悬空归零", not (ck3.get("dangling") or []),
               str(ck3.get("dangling"))[:130])
 
+        # 跨进程一致性：新实例重放 _index_log 后，已清退节点不得复活成幽灵条目
+        # （索引有条目、文件不存在）——只有把「删除」也写进增量日志才成立。
+        cg2 = MdCGOS(ROOT)
+        revived = sorted(n for n in ids4 if n in (cg2.index.get("nodes") or {}))
+        check("清退后重开不复活幽灵条目", not revived, f"复活={revived}")
+
+        # 存量幽灵（历史「删除只摘内存索引」遗留）：索引有条目、节点文件不存在
+        # 也必须清得掉，否则 dangling 永远够不着零。
+        gid = "doc_ghost_probe0001"
+        cg.index["nodes"][gid] = {"path": "knowledge/ghost_probe.md",
+                                  "layer": "knowledge", "tags": ["doc"],
+                                  "bucket": None, "importance": 0.5}
+        g1 = call_tool(cg, "cg", {"op": "ref", "action": "prune"})
+        check("幽灵条目被清退（索引有、文件无）",
+              len(g1.get("ghost_pruned") or []) >= 1
+              and gid not in (cg.index.get("nodes") or {}), str(g1)[:130])
+        ck4 = call_tool(cg, "cg", {"op": "ref", "action": "check", "max_nodes": 5000})
+        check("清幽灵后悬空仍为零", not (ck4.get("dangling") or []),
+              str(ck4.get("dangling"))[:130])
+
+        # ============================================ ⑪ fence 往返列（binding）
+        # 缺口：往返列（取列 / 造键 / 校验 / 漂移 / 反查）是「条件卡 ↔ Markdown 真源」
+        # 的可校验面，此前零测试。列形状一旦漂移，对账器会把坏列当好消息（漏报）；
+        # 键若悄悄带上行位，真源上方插一行就会让整库失配——故两者都要钉死。
+        print("\n【11】fence 往返列：形状 / 键不含行位 / 校验 / 漂移 / 反查")
+        li = docindex.extract(GUIDE, "guide.md")
+        s9b = next(i for i in li if i["heading"] == "9. 分阶段实施")
+        rendered = docindex.render(s9b)
+        gnode = cg.get(g_id) or {}
+        g_ref = (gnode.get("frontmatter") or {}).get("doc_ref") or {}
+        b0 = docindex.binding_of(gnode)
+        check("必需列齐全且无空值",
+              isinstance(b0, dict)
+              and all(b0.get(k) not in (None, "") for k in docindex.BINDING_FIELDS),
+              str(sorted(docindex.BINDING_FIELDS)))
+        check("列面 = 必需列 + 附加列（无第二份列口径）",
+              set(b0 or {}) == set(docindex.BINDING_FIELDS)
+              | set(docindex.BINDING_OPTIONAL),
+              str(sorted(set(b0 or {}) ^ (set(docindex.BINDING_FIELDS)
+                                          | set(docindex.BINDING_OPTIONAL)))))
+        check("必需列/附加列 ⊆ 写侧 doc_ref 列（读写同一列面）",
+              (set(docindex.BINDING_FIELDS) | set(docindex.BINDING_OPTIONAL))
+              <= set(g_ref),
+              str(sorted(set(docindex.BINDING_FIELDS) - set(g_ref))))
+        check("binding_of 与直接读 frontmatter 同源（同一投影）",
+              b0 == docindex.binding_of({"frontmatter": {"doc_ref": g_ref}}))
+        check("binding_of 对非索引节点返回 None（不猜、不补默认值）",
+              docindex.binding_of(None) is None
+              and docindex.binding_of([]) is None
+              and docindex.binding_of({}) is None
+              and docindex.binding_of({"frontmatter": {"tags": ["doc"]}}) is None)
+        check("validate_binding：本仓卡片列形状合法（ok + 零 issue）",
+              docindex.validate_binding(b0) == {"ok": True, "issues": []},
+              str(docindex.validate_binding(b0)))
+        check("validate_binding：非 dict 如实报错且不抛",
+              docindex.validate_binding(None)
+              == {"ok": False, "issues": ["绑定不是字典（该节点无 doc_ref）"]})
+        lo0 = b0["lineno"]
+        bad_detail = []
+        for _nm, _b, _want in (
+                ("缺列", {k: v for k, v in b0.items() if k != "anchor"},
+                 "缺列 anchor"),
+                ("类型错 root", {**b0, "root": 123},
+                 "root 应为字符串，实为 int"),
+                ("类型错 lineno", {**b0, "lineno": "十"}, "行位不是整数"),
+                ("行位越界", {**b0, "lineno": 0}, "lineno 越界（0 < 1）"),
+                ("区间倒置", {**b0, "end": lo0 - 1},
+                 f"end 早于 lineno（{lo0}-{lo0 - 1}）")):
+            _v = docindex.validate_binding(_b)
+            if _v["ok"] or _want not in _v["issues"]:
+                bad_detail.append(f"{_nm}→{_v['issues']}")
+        check("validate_binding 逐类坏列均被点出（缺列/类型错/越界/区间倒置）",
+              not bad_detail, "; ".join(bad_detail)[:170])
+        b_shift = docindex.binding_of({"frontmatter": {"doc_ref": {
+            **g_ref, "lineno": lo0 + 40, "end": g_ref["end"] + 40}}})
+        check("键不含行位：行位位移不改键（重排后仍是同一章节）",
+              docindex.binding_key(b0) == docindex.binding_key(b_shift)
+              == "guide.md#总览/9. 分阶段实施",
+              docindex.binding_key(b0))
+        check("漂移按固定列序报出变化项（lineno → end → hash）",
+              docindex.binding_drift(b0, b_shift) == ["lineno", "end"]
+              and docindex.binding_drift(b0, {**b0, "hash": "zz"}) == ["hash"]
+              and docindex.binding_drift(
+                  b0, {**b0, "hash": "zz", "lineno": lo0 + 1})
+              == ["lineno", "hash"],
+              str(docindex.binding_drift(b0, b_shift)))
+        check("同列零漂移（无变化不报 / 空值不炸）",
+              docindex.binding_drift(b0, dict(b0)) == []
+              and docindex.binding_drift(None, None) == [])
+        check("binding_key 缺 heading_path 回落 path#anchor · 非 dict 返空串",
+              docindex.binding_key({"path": "a.md", "anchor": "s1"}) == "a.md#s1"
+              and docindex.binding_key({"path": "a.md"}) == "a.md#"
+              and docindex.binding_key(None) == "")
+        check("binding_slug 与 render 正文「本条目属于」逐字同源",
+              docindex.binding_slug(b0) == "guide.md#9-分阶段实施"
+              and f"本条目属于 {docindex.binding_slug(b0)}" in rendered,
+              docindex.binding_slug(b0))
+        check("反查取最内层（父节区间内的子节优先，不回落父节）",
+              docindex.locate(li, 12)["heading"] == "9. 分阶段实施"
+              and docindex.locate(li, 30)["heading"] == "代码示例",
+              str((docindex.locate(li, 12) or {}).get("heading")))
+        check("反查区间闭合（标题行与末行都算本节）",
+              docindex.locate(li, s9b["lineno"])["heading"] == "9. 分阶段实施"
+              and docindex.locate(li, s9b["end"])["heading"] == "9. 分阶段实施")
+        check("反查越界/非整数/空表 → None（fail-closed 不猜）",
+              docindex.locate(li, 10 ** 6) is None
+              and docindex.locate(li, 0) is None
+              and docindex.locate(li, "x") is None
+              and docindex.locate(li, None) is None
+              and docindex.locate([], 10) is None)
+
+        # ================================ ⑫ 逐字节回放回归（往返列无损）
+        # ⑪ 只证「列可校验」；本段把口径推到内容无损：卡片必须是真源条目的派生物
+        # （render 补一个换行 == 卡片正文）。root 限定为本次真正索引过的两个真源，
+        # 断言只落在本轮写入的卡上——历史残留不参与，避免把脏数据当回归。
+        print("\n【12】逐字节回放回归：render(条目) + 换行 == 卡片正文")
+        cg.flush()
+        rp = _replay_cards(cg, roots={_norm(fx), _norm(DOCS)})
+        print(f"      取样 {rp['sampled']} 卡：一致 {rp['ok']} · 键未命中 "
+              f"{rp['dangling']} · 源已移出 {rp['gone']} · 读不了 "
+              f"{rp['unreadable']}")
+        check("回放取样命中卡片（root 限定=本次索引的两个真源）",
+              rp["sampled"] > 0, str(rp["sampled"]))
+        check("可读卡 100% 逐字节回放一致（写侧 render 与读侧同源）",
+              not rp["mismatch"],
+              f"一致 {rp['ok']}/{rp['sampled']}；" + "；".join(rp["mismatch"][:2]))
+        check("零键未命中 / 零源已移出 / 零读不了（源在库则必可重定位并读回）",
+              rp["dangling"] == 0 and rp["gone"] == 0
+              and rp["unreadable"] == 0,
+              f"键未命中={rp['dangling']} 源已移出={rp['gone']} "
+              f"读不了={rp['unreadable']}")
+        check("回放账目闭合（一致 + 键未命中 + 源已移出 + 读不了 = 取样数）",
+              (rp["ok"] + rp["dangling"] + rp["gone"] + rp["unreadable"])
+              == rp["sampled"],
+              f"{rp['ok']}+{rp['dangling']}+{rp['gone']}+{rp['unreadable']}"
+              f" vs {rp['sampled']}")
+
+        # 历史抽样：真实认知图库（仓外数据面，历史卡最多）。以 MDCG_ROOT 显式声明；
+        # 裸 clone / CI 无此数据面 → 如实报 SKIP（不虚报通过、也不 FAIL）。
+        ext_root = os.environ.get("MDCG_ROOT") or ""
+        if not (ext_root and os.path.isdir(ext_root)):
+            print("\n【12b】历史抽样：跳过（未设 MDCG_ROOT 或目录不存在）"
+                  "—— 本仓语料回放见【12】")
+        else:
+            print(f"\n【12b】历史抽样：外部认知图库 {ext_root}（只读身份）")
+            ext = MdCGSecure(ext_root, principal=Principal(
+                actor="p27-replay", clearance="secret", can_write=False,
+                can_admin=False, role="designer", auth_mode="local-cli"))
+            try:
+                hp = _replay_cards(ext, sample=120)
+            finally:
+                ext.close()
+            print(f"      抽样 {hp['sampled']} 卡：一致 {hp['ok']} · 键未命中 "
+                  f"{hp['dangling']} · 源已移出 {hp['gone']} · 读不了 "
+                  f"{hp['unreadable']}")
+            check("【12b】历史库抽样命中卡片（数据面可达）",
+                  hp["sampled"] > 0, str(hp["sampled"]))
+            check("【12b】可读历史卡零回放不符（未被渲染漂移/人工改写腐化）",
+                  not hp["mismatch"],
+                  f"一致 {hp['ok']}/{hp['sampled']}；"
+                  + "；".join(hp["mismatch"][:2]))
+            check("【12b】未读回的全部是「源已移出」（非 IO/抽取故障）",
+                  hp["unreadable"] == 0,
+                  f"源已移出={hp['gone']} 读不了={hp['unreadable']}")
+            check("【12b】抽样账目闭合（无静默丢弃）",
+                  (hp["ok"] + hp["dangling"] + hp["gone"] + hp["unreadable"])
+                  == hp["sampled"],
+                  f"{hp['ok']}+{hp['dangling']}+{hp['gone']}+{hp['unreadable']}"
+                  f" vs {hp['sampled']}")
+
     finally:
         shutil.rmtree(tmp, ignore_errors=True)
 

package/md_cg/test_p28_refcheck.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 """ref 增量索引 + 漂移/悬空巡检（P28 · R3 改造验收）。
 
-对照 `docs/认知图_索引与工程规范化_计划_v0.1.md` 的 R3：
+对照 `docs/mdcg/认知图_索引与工程规范化_计划_v0.1.md` 的 R3：
 
   ① 统一 ref 协议 + 提取器注册表：调用方只说 `kind`，`refindex` 决定用哪个
      提取器；无提取器后缀显式报错。

package/md_cg/test_p29_session_ingest_export.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 """会话层 + 摄取分派 + 全库导出（P29 · P0 工程缺口验收）。
 
-对照 `docs/灵枢82工具_功能整理与迁移映射_v0.1.md` §五：P0 新增三个 op。
+对照 `docs/mdcg/灵枢82工具_功能整理与迁移映射_v0.1.md` §五：P0 新增三个 op。
 
   ① op 三处同步：`tokens.ALL_OPS` == `cg` 工具 op 描述 == `_cg_call` 分支
   ② session：note 幂等写入；recall 一次返回可续接上下文包；compact 启发式压缩

package/md_cg/test_p2_mcp.py

@@ -262,12 +262,18 @@ def main():
             kn = [t["name"] for t in kt]
             check("kernel 只暴露 2 个基元", kn == ["cg", "stg"], str(kn))
             info = kc.call("cg", {"op": "info"})
+            # 注：新增 content_kind（如 ccg_marks）须同步本清单——工具面自描述
+            # 与 audit.CONTENT_KINDS 真源逐类对齐，防「真源扩了、自描述没跟」。
             check("cg info 自描述审核体系",
                   info.get("surface") == "kernel"
                   and set(info.get("audit_kinds", {})) == {
                       "code", "image_desc", "text", "permission",
-                      "work_done", "work_wip"},
+                      "work_done", "work_wip", "ccg_marks", "hyperedge"},
                   str(list(info.get("audit_kinds", {})))[:120])
+            check("cg info 自描述 CCG 契约角色（裁定 B）",
+                  info.get("ccg_contract", {}).get("生效条件") == "前置条件 precondition"
+                  and len(info.get("ccg_contract", {})) == 6,
+                  str(info.get("ccg_contract"))[:120])
             w = kc.call("cg", {"op": "write", "content_kind": "text",
                                "content": "hello", "node_id": "kw1"})
             check("未验证的写入进审核队列",

package/md_cg/test_p31_insight.py

@@ -201,6 +201,30 @@ def main():
               mfm.get("induced_concept") == cid
               and cid in {e.get("target") for e in (mfm.get("edges") or [])},
               str(mfm.get("induced_concept")))
+        # ---- 2026-09-19 阶段一：巩固留痕字段一等公民 ----
+        check("成员侧记 consolidated_into（规范名·巩固进哪一条）",
+              mfm.get("consolidated_into") == cid
+              and mfm.get("induced_concept") == cid,
+              str(mfm.get("consolidated_into")))
+        check("成员侧记 consolidated_at（何时巩固）",
+              bool(mfm.get("consolidated_at")), str(mfm.get("consolidated_at")))
+        check("概念侧记 consolidated_at（概念形成即巩固时刻）",
+              bool(cfm.get("consolidated_at"))
+              and cfm.get("induced_at") == cfm.get("consolidated_at"),
+              f"{cfm.get('consolidated_at')} / {cfm.get('induced_at')}")
+        check("前身可定位：概念侧 induced_from 与成员侧列互查一致",
+              set(cfm.get("induced_from") or []) == {"ind_1", "ind_2", "ind_3"}
+              and all(((cg.get(m) or {}).get("frontmatter") or {}
+                       ).get("consolidated_into") == cid
+                      for m in ("ind_1", "ind_2", "ind_3")))
+        # add() 是**全量重建 fm**——覆写后留痕必须仍在（回读节点继承，非索引快照）
+        cg.add("ind_1", IND_A, layer="contextual", importance=0.4,
+               verification_basis="other", actor="p31")
+        mfm2 = (cg.get("ind_1") or {}).get("frontmatter") or {}
+        check("覆写后成员侧巩固留痕继承（consolidated_into/at 不丢）",
+              mfm2.get("consolidated_into") == cid
+              and bool(mfm2.get("consolidated_at")),
+              str(mfm2.get("consolidated_into")))
         check("induce 留痕 _maintain.jsonl",
               any(r.get("action") == "induce"
                   for r in consolidate._read_maintain(ROOT)))

package/md_cg/test_p38_contextualize.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 """层归位（P38 · G4 设计态验收）。
 
-对照 `docs/认知图_G4-G8缺口裁定单_v0.1.md` §二：批次流水账（`note_`/`milestone_`/
+对照 `docs/mdcg/认知图_G4-G8缺口裁定单_v0.1.md` §二：批次流水账（`note_`/`milestone_`/
 `retest6_`）与感知产物（`imgpart_`/`vpipe_`）混在 knowledge 层，语义上属**情境**，
 需归位到 `contextual` 且**保留可召回**。
 

package/md_cg/test_p39_vision_evidence.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 """视觉证据回填（P39 · G5 设计态验收）。
 
-对照 `docs/认知图_G4-G8缺口裁定单_v0.1.md` §三：视觉节点证据面恒为 `{}`，
+对照 `docs/mdcg/认知图_G4-G8缺口裁定单_v0.1.md` §三：视觉节点证据面恒为 `{}`，
 根因是产出侧只取 `model_evidence`（白箱部件不带该键）——即**证据口径未定义**。
 本轮以**库外只读归档**（逐部件结构化结果）为证据源，按三档映射回填，脱敏、
 不读图像、不重跑视觉。

package/md_cg/test_p40_refine_worklist.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 """G6 · node_ 结构提炼抽检工单与扩批闸门（P40 设计态验收）。
 
-对照 `docs/认知图_G4-G8缺口裁定单_v0.1.md` §四 G6：`node_*`（P37 派生记忆）
+对照 `docs/mdcg/认知图_G4-G8缺口裁定单_v0.1.md` §四 G6：`node_*`（P37 派生记忆）
 自带 `ccg_exempt=true`，只声明「功能名 / 生效条件」，`子功能/执行/不适用条件` 全缺。
 条件 A 要求**先抽 20 条做提炼预演、人工核对提炼口径，绝不盲跑全量**。
 

package/md_cg/test_p41_evolve_patrol.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 """G7 · 自主演化巡检（把「有能力」变成「有驱动」）（P41 设计态验收）。
 
-对照 `docs/认知图_G4-G8缺口裁定单_v0.1.md` §五 G7：固化 / 重要性 / 去污染三类自我
+对照 `docs/mdcg/认知图_G4-G8缺口裁定单_v0.1.md` §五 G7：固化 / 重要性 / 去污染三类自我
 演化动作早已具备，但**没有任何驱动源**周期性问「现在有多少该固化 / 该重算的候选」，
 于是能力被饿死。本项给常驻循环挂上**只读**演化巡检 + **受控**自愈。
 

package/md_cg/test_p42_provenance.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 """G8 · 派生溯源（新增即建链 + 失败不阻断 + 悬空可检出）（P42 设计态验收）。
 
-对照 `docs/认知图_G4-G8缺口裁定单_v0.1.md` §六 G8：节点拆并/派生后**血缘丢失**，
+对照 `docs/mdcg/认知图_G4-G8缺口裁定单_v0.1.md` §六 G8：节点拆并/派生后**血缘丢失**，
 库根无 `_link.jsonl`、frontmatter 的派生字段全空，事后无从回答「这个节点从哪来」。
 本项只对**新增**节点常态化建链（历史不回填），且立三条硬约束。
 

package/md_cg/test_p43_pooling.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 """§七 · 召回分池与降权（P43 设计态验收）。
 
-对照 `docs/认知图_G4-G8缺口裁定单_v0.1.md` §七：索引/产物类节点（`code_`/`doc_`）
+对照 `docs/mdcg/认知图_G4-G8缺口裁定单_v0.1.md` §七：索引/产物类节点（`code_`/`doc_`）
 词面更易命中，在 `GLOBAL_CAP` 单条截断点**先把知识节点挤掉**。本项把截断额度
 **显式分池**（不是抬高额度），并立四条纪律。
 
@@ -41,7 +41,11 @@ PASS = FAIL = 0
 FAILS = []
 
 BODY = "召回截断 索引 分池 内容"
-QUERY = "召回截断"
+# 多词查询：索引类含全部查询词、知识类缺「分池」→ 相关度有**区分度**。
+# 原语料下 16 条分数全等（覆盖度口径），截断谁入榜只能由传入序决定——而传入序
+# 本身不确定（目录枚举 + 并行 prefetch），断言 `off=6` 实为顺序抽签的产物。
+QUERY = "召回截断 分池"
+KBODY = "召回截断 索引 内容"
 
 
 def ok(cond, label):
@@ -71,7 +75,12 @@ def _snapshot(root):
 
 
 def _mk(root):
-    """6 个索引类（code_/doc_）+ 10 个知识类，正文同源 → 词面完全等价竞争。"""
+    """6 个索引类（code_/doc_）+ 10 个知识类。
+
+    §七 的真实机制是「索引/产物类节点**词面命中率更高**」（正文短、查询词占比大），
+    故索引类正文短、知识类正文长（含背景说明），使索引类相似度**确实**高于知识类
+    ——挤占由相关度驱动，不依赖写入顺序（截断依据已改为相关度，见 `cut_by_relevance`）。
+    """
     cg = MdCGOS(root, actor="test")
     for i in range(4):
         cg.add(f"code_{i}", f"# 功能名：索引条目 {i}\n# 生效条件：条件 I\n\n{BODY} {i}\n",
@@ -80,7 +89,10 @@ def _mk(root):
         cg.add(f"doc_{i}", f"# 功能名：文档索引 {i}\n# 生效条件：条件 D\n\n{BODY} {i}\n",
                layer="knowledge", tags=["index"])
     for i in range(10):
-        cg.add(f"kp_{i}", f"# 功能名：知识 {i}\n# 生效条件：条件 K\n\n{BODY} {i}\n",
+        cg.add(f"kp_{i}",
+               f"# 功能名：知识 {i}\n# 生效条件：条件 K\n\n{KBODY} {i}\n"
+               f"备注：本条为知识类条目，含背景说明、推理链与引用出处，正文较长，"
+               f"查询词在全文中的占比因此显著低于索引类条目。\n",
                layer="knowledge")
     cg.add("n_rej", f"# 功能名：被否决\n# 生效条件：条件 R\n\n{BODY} 否\n",
            layer="rejected")
@@ -238,12 +250,27 @@ def main():
         # 但「乘数可复算」这一被测语义不变。
         base = {r[0]["id"]: r[1] for r in off}
         sc = {r[0]["id"]: r[1] for r in on}
-        ok(abs(sc["code_0"] - base.get("code_0", 0.0) * 0.6) < 1e-9,
-           f"(8) 索引类命中分 == 基础分 × 0.6（base={base.get('code_0', 0.0):.6f} → "
-           f"{sc.get('code_0', float('nan')):.6f}）")
-        common = [i for i in range(6) if f"kp_{i}" in base and f"kp_{i}" in sc]
-        ok(common and all(abs(sc[f"kp_{i}"] - base[f"kp_{i}"]) < 1e-9 for i in common),
-           f"(8) 知识类命中分不被削（权重 1.0；逐条比对 {len(common)} 条）")
+
+        def _pick_idx(d):
+            """挑一条「关闭态也有基础分」的索引类入榜条目。
+
+            截断依据改为相关度后，具体哪条索引入榜由分数序决定（不再是固定的
+            `code_0`——那正是按传入序截断时代的产物），故动态取。
+            """
+            return next((i for i in d if PL.pool_of(i) == "index" and i in base), None)
+
+        iid = _pick_idx(sc)
+        ok(iid is not None, "(8) 分池态含索引类条目（额度保底生效）")
+        ok(iid is not None and abs(sc[iid] - base[iid] * 0.6) < 1e-9,
+           f"(8) 索引类命中分 == 基础分 × 0.6（{iid}: base={base.get(iid, 0.0):.6f} → "
+           f"{sc.get(iid, float('nan')):.6f}）")
+        # 知识类权重 1.0 → 命中分应与关闭态同源分一致。不硬编码编号：关闭态额度
+        # 被索引类占满，只余 2 条知识类入榜，与分池态取的 6 条未必有同编号交集
+        # （全同分下由稳定序决定），故按「关闭态知识分基准」比对。
+        base_kp = [v for k, v in base.items() if k.startswith("kp_")]
+        sc_kp = [v for k, v in sc.items() if k.startswith("kp_")]
+        ok(base_kp and sc_kp and all(abs(v - base_kp[0]) < 1e-9 for v in sc_kp),
+           f"(8) 知识类命中分不被削（权重 1.0；base={base_kp[:1]} → on={sc_kp[:2]}）")
         ok(PL.weight_of("code_x", {}, True) == PL.WEIGHTS["index"]["weight"],
            "(8) weight_of 与表内系数一致")
         alt = {"knowledge": {"cap_ratio": 0.5, "weight": 1.0},
@@ -251,9 +278,10 @@ def main():
                "negative": {"cap_ratio": 0.1, "weight": 0.5}}
         on2, _m2 = cg.search(QUERY, k=20, record=False, pools=alt)
         sc2 = {r[0]["id"]: r[1] for r in on2}
-        ok(abs(sc2["code_0"] - base.get("code_0", 0.0) * 0.3) < 1e-9,
-           f"(8) 换表即换行为（base×0.3={base.get('code_0', 0.0) * 0.3:.6f} → "
-           f"{sc2.get('code_0', float('nan')):.6f}）")
+        iid2 = _pick_idx(sc2)
+        ok(iid2 is not None and abs(sc2[iid2] - base[iid2] * 0.3) < 1e-9,
+           f"(8) 换表即换行为（{iid2}: base×0.3={base.get(iid2, 0.0) * 0.3:.6f} → "
+           f"{sc2.get(iid2, float('nan')):.6f}）")
         ok(PL.caps(10, PL.resolve(alt)) == {"knowledge": 4, "index": 4, "negative": 2},
            f"(8) 换表额度同步可复算（实得 {PL.caps(10, PL.resolve(alt))}）")
 

package/md_cg/test_p44_md_whitebox.py

@@ -28,7 +28,7 @@ import tempfile
 
 _HERE = os.path.dirname(os.path.abspath(__file__))
 
-from .md_whitebox import build_db_from_md  # noqa: E402
+from .md_whitebox import build_db_from_md, corpus_gap  # noqa: E402
 
 SOURCE_DB = os.path.join(_HERE, "whitebox_kb", "wisdom", "wisdom-book-cloud.db")
 
@@ -129,6 +129,19 @@ def _report(rows):
 def main():
     ok = True
 
+    # 依赖自辩（2026-09-20 v14 缺陷 F）：源库与 md 语料均为 gitignored 本地
+    # 数据面——缺失时本模块自己打 SKIP 返回 0。旧形态下缺库会以未捕获的
+    # `sqlite3.OperationalError: unable to open database file` traceback 示人，
+    # 与兄弟目标「自建库后断言失败」构成同一根因的第三副面孔。
+    if not os.path.exists(SOURCE_DB):
+        print("SKIP test_p44_md_whitebox：依赖源库 %s（.gitignore 忽略，"
+              "需本地生成）" % SOURCE_DB)
+        return 0
+    _gap = corpus_gap()
+    if _gap:
+        print("SKIP test_p44_md_whitebox：%s" % _gap)
+        return 0
+
     # ---- 1) 结构等价 ----
     # force：从 md 语料**重新**还原，保证 access_count 等可变字段与源库快照
     # 同起点（复用旧库会带上此前问答累积的 access，造成假差异）。