@furongjun1999/dsh-memory 0.5.0 → 0.6.0

package/md_cg/test_readcache_precise_inval.py

@@ -0,0 +1,270 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""读缓存脏集精确失效守卫（缺陷迭代第 14 轮，high：写读交替整池重装）。
+
+缺陷形态（缺陷报告实测，10k 临时库串行 3rep 中位）：
+  readcache._cached 的代际哨兵取**全局单调** write_gen（整池共用一个值），
+  _DirtyDict 每次变更 +1——任意一次单节点写使**全部**缓存条目同时 miss，
+  下一条查询全池重装（open+parse 全部 N 个节点）：稳态 41.3ms/loads=0 →
+  每 rep add 1 节点后同查询 1732.4ms/loads=10001（41.9× 退化），10k/20k/30k
+  写后首查 1732/3515/5230ms 线性于 N。生产暴露面：mcp_server 读路径
+  （op=read→search/recall）与写路径（op=write→writepipe._executor→cg.add，
+  链尾 _commit_visibility→flush）同一常驻实例——写读交替负载 O(每写×全池)。
+
+修复口径：_DirtyDict 簿记**脏 path 代际**（path_gen[path]=标脏时 write_gen），
+读缓存按「该 path 最近标脏代际 ≤ 缓存代际」判新鲜——单节点写只失效该节点；
+tombstone（_dirty[nid]=None，无 path 可辨）/其余变更形态走 broad_gen 保守
+整池失效（与旧整代际口径等价的安全兜底）；clear()（flush/rebuild）只推进
+write_gen 不再整池失效——flush 只落索引派生物（分片日志），节点文件的内容
+变更在各写路径 `_dirty[nid]=entry`（带 path）时已精确失效；且生产写路径
+每次写后 flush（writepipe._commit_visibility），clear 若整池失效会让精确
+失效在生产写读交替负载下恒不生效。
+
+本守卫九项（调用计数/复杂度断言形态，非时间阈值）：
+  G1 写读交替不整池重装：热缓存后 add 1 节点 → 同查询 loads ≤ 2
+     （旧整代际实现 ≈ 池+1 全量 → 红）；
+  G2 生产写提交边界（add+flush）后同查询 loads ≤ 2（旧实现 flush 的
+     clear() 再叠一次整池 miss → 红）；
+  G3 写后不陈旧（正确性保持，P3/V5 同口径）：覆写既有节点 → 检索命中
+     新内容、_read 缓存视图见新值；
+  G4 写别的节点不误伤：add B 后 A 的缓存条目 identity 不变（不重读）；
+  G5 删除保守整池失效：_unstage（tombstone）后同查询 loads ≥ 剩余池规模
+     （无 path 可辨 → broad 兜底，与旧整代词语义等价，不陈旧）；
+  G6 _DirtyDict 簿记直断：带 path 标脏 → path_gen 推进且 broad_gen 不动；
+     tombstone → broad_gen 推进；flush 形态 clear() 不动 path_gen/broad_gen、
+     clear(broad=True)（rebuild 收尾）推进 broad_gen；write_gen 单调不回退
+     （P7b 口径保留）；
+  G7 派生物缓存（_doc_norm_bigrams）同口径精确失效：add 1 节点后旧条目
+     identity 不变（不重算）；
+  G8 「直写文件 + rebuild_index 收尾」写方（ccgc/crosscheck/backfill 族）
+     的缓存可见性：rebuild 的 clear(broad=True) 整池兜底——缓存视图见
+     新内容且整池重装（回归面：全量套件 test_ccgc V4c/V5d 曾因 rebuild
+     不失效而陈旧红）。
+
+运行：python -m md_cg.test_readcache_precise_inval
+"""
+import os
+import shutil
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from md_cg import nodefile                       # noqa: E402
+from md_cg.mdcos import MdCGOS                   # noqa: E402
+
+PASS = 0
+FAIL = 0
+FAILS = []
+
+N = 40
+QUERY = "蜂群调度"
+
+
+def check(name, cond, detail=""):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  OK   {name}")
+    else:
+        FAIL += 1
+        FAILS.append(name)
+        print(f"  FAIL {name}  {detail}")
+
+
+def build_lib(root):
+    cg = MdCGOS(root)
+    for i in range(N):
+        cg.add("mem_%03d" % i,
+               "# 功能名：精确失效样本 %d\n# 正文：%s 节点 %d" % (i, QUERY, i),
+               layer="knowledge")
+    cg.flush()
+    return cg
+
+
+def count_loads(fn):
+    """打桩 nodefile.loads 计数（节点文件解析唯一入口，_read 内调用）。"""
+    n = 0
+    real = nodefile.loads
+
+    def _spy(*a, **kw):
+        nonlocal n
+        n += 1
+        return real(*a, **kw)
+
+    nodefile.loads = _spy
+    try:
+        return fn(), n
+    finally:
+        nodefile.loads = real
+
+
+def main():
+    root = tempfile.mkdtemp(prefix="mdcg_rc_precise_")
+    try:
+        os.environ.pop("MDCG_READ_CACHE", None)   # 默认开（生产默认态）
+        cg = build_lib(root)
+        check("G0a 库就绪且读缓存默认装配",
+              len(cg.index["nodes"]) == N and hasattr(cg, "_read_cache"),
+              f"nodes={len(cg.index['nodes'])}")
+
+        # 预热：首查装缓存，二次查询零重解析（稳态前提）
+        cg.search(QUERY)
+        _, n_warm2 = count_loads(lambda: cg.search(QUERY))
+        check("G0b 稳态二次查询零重解析（loads==0）", n_warm2 == 0,
+              f"loads={n_warm2}")
+
+        # G1 写读交替不整池重装：add 1 节点 → 同查询只解析新节点
+        print("== G1 写读交替精确失效 ==")
+        cg.add("g1_new", "# 功能名：新增节点\n# 正文：%s 新增内容G1" % QUERY,
+               layer="knowledge")
+        r1, n1 = count_loads(lambda: cg.search(QUERY)[0])
+        check("G1a add 1 节点后同查询 loads ≤ 2（旧整代际 ≈ 池+1 全量）",
+              n1 <= 2, f"loads={n1} pool={N + 1}")
+        check("G1b 新节点可检索（不陈旧）",
+              any(x[0].get("id") == "g1_new" for x in r1),
+              f"ids={[x[0].get('id') for x in r1][:5]}")
+
+        # G4 写别的节点不误伤：A 的缓存条目 identity 不变
+        print("== G4 邻居条目不误伤 ==")
+        pa = cg.index["nodes"]["mem_000"]["path"]
+        snap = cg._read_cache.get(pa)
+        check("G4pre A 条目已在缓存", snap is not None)
+        cg.add("g4_other", "# 功能名：邻居写入\n# 正文：%s 邻居G4" % QUERY,
+               layer="knowledge")
+        count_loads(lambda: cg.search(QUERY))
+        cur = cg._read_cache.get(pa)
+        check("G4a 写其它节点后 A 缓存条目 identity 不变（不重读）",
+              cur is not None and cur is snap,
+              f"same={cur is snap}")
+
+        # G2 生产写提交边界：add + flush（writepipe._commit_visibility 等价形态）
+        print("== G2 写提交边界（add+flush）不整池重装 ==")
+        cg.add("g2_flush", "# 功能名：管线节点\n# 正文：%s 管线G2" % QUERY,
+               layer="knowledge")
+        cg.flush()
+        r2, n2 = count_loads(lambda: cg.search(QUERY)[0])
+        check("G2a add+flush 后同查询 loads ≤ 2（clear 不整池失效）",
+              n2 <= 2, f"loads={n2} pool={N + 3}")
+        check("G2b flush 后新节点可检索（不陈旧）",
+              any(x[0].get("id") == "g2_flush" for x in r2),
+              f"ids={[x[0].get('id') for x in r2][:5]}")
+
+        # G3 写后不陈旧（正确性保持）：覆写既有节点
+        print("== G3 覆写后不陈旧 ==")
+        cg.add("mem_000", "# 功能名：覆写样本\n# 正文：%s 更新后内容BBB 独有标记G3" % QUERY,
+               layer="knowledge")
+        entry = cg.index["nodes"]["mem_000"]
+        fm_v, c_v = cg._read(entry)               # 缓存视图（生产读形态）
+        check("G3a 覆写后 _read 缓存视图见新内容（不陈旧）",
+              c_v is not None and "BBB" in c_v, f"content={str(c_v)[:40]}")
+        r3, _ = count_loads(lambda: cg.search("更新后内容BBB 独有标记G3")[0])
+        got = next((x[0].get("content") for x in r3
+                    if x[0].get("id") == "mem_000"), None)
+        check("G3b 覆写后检索命中新内容",
+              got is not None and "BBB" in got, f"content={str(got)[:40]}")
+
+        # G7 派生物缓存同口径：add 1 节点后旧条目 identity 不变（不重算）
+        print("== G7 派生物缓存（_doc_norm_bigrams）不误伤 ==")
+        cg.search(QUERY)                          # 装齐派生物缓存
+        nbc = getattr(cg, "_norm_bigrams_cache", {})
+        snap_nb = {k: v[1] for k, v in nbc.items()}
+        check("G7pre 派生物缓存已装载", len(snap_nb) > 0,
+              f"entries={len(snap_nb)}")
+        cg.add("g7_new", "# 功能名：派生物样本\n# 正文：%s 派生物G7" % QUERY,
+               layer="knowledge")
+        cg.search(QUERY)
+        nbc2 = getattr(cg, "_norm_bigrams_cache", {})
+        same = all(nbc2[k][1] is snap_nb[k] for k in snap_nb if k in nbc2)
+        check("G7a 写 1 节点后旧派生物条目零重算（identity 不变）",
+              same and len(snap_nb) > 0, f"snap={len(snap_nb)}")
+
+        # G5 删除保守整池失效（tombstone 无 path 可辨 → broad 兜底）
+        print("== G5 删除保守整池失效 ==")
+        cg._unstage("mem_001")
+        left = len(cg.index["nodes"])
+        _, n5 = count_loads(lambda: cg.search(QUERY)[0])
+        check("G5a _unstage 后同查询整池重装（loads ≥ 剩余池规模）",
+              n5 >= left, f"loads={n5} left={left}")
+
+        # G6 _DirtyDict 簿记直断
+        print("== G6 _DirtyDict 脏集簿记 ==")
+        from md_cg.mdcg import _DirtyDict
+        d = _DirtyDict()
+        pg = getattr(d, "path_gen", None)
+        bg = getattr(d, "broad_gen", None)
+        check("G6a path_gen/broad_gen 簿记就位", pg is not None and bg is not None)
+        if pg is not None:
+            g0 = d.write_gen
+            d["n1"] = {"path": "knowledge/n1.md", "layer": "knowledge"}
+            g1 = d.write_gen
+            check("G6b 带 path 标脏 → path_gen 记录、broad_gen 不动",
+                  d.path_gen.get("knowledge/n1.md") == g1 > g0
+                  and d.broad_gen == 0)
+            d["n2"] = {"path": "knowledge/n2.md", "layer": "knowledge"}
+            check("G6c 写另一 path 不推进前一 path 的脏代际",
+                  d.path_gen.get("knowledge/n1.md") == g1
+                  and d.path_gen.get("knowledge/n2.md") == d.write_gen)
+            d["n3"] = None                          # tombstone：无 path 可辨
+            check("G6d tombstone → broad_gen 保守推进",
+                  d.broad_gen == d.write_gen > g1)
+            d.clear()                               # flush 收尾形态
+            check("G6e flush 形态 clear() 推进 write_gen 但不动 broad/path_gen",
+                  d.write_gen > d.broad_gen
+                  and d.path_gen.get("knowledge/n1.md") == g1)
+            d["n4"] = 1                             # 非 entry 形态值
+            check("G6f 无 path 可辨的值 → broad_gen 保守推进",
+                  d.broad_gen == d.write_gen)
+            d.clear(broad=True)                     # rebuild_index 收尾形态
+            check("G6h clear(broad=True) → broad_gen 推进（rebuild 兜底）",
+                  d.broad_gen == d.write_gen)
+        gens = []
+        d2 = _DirtyDict()
+        d2["a"] = {"path": "x"}
+        gens.append(d2.write_gen)
+        d2["b"] = None
+        gens.append(d2.write_gen)
+        d2.clear()
+        gens.append(d2.write_gen)
+        d2["c"] = {"path": "y"}
+        gens.append(d2.write_gen)
+        check("G6g write_gen 单调不回退（P7b 口径保留）",
+              gens == sorted(gens) and len(set(gens)) == 4, f"gens={gens}")
+
+        # G8 「直写文件 + rebuild_index 收尾」写方（ccgc/crosscheck/backfill
+        # 族）的缓存可见性：直写不经 _dirty 标脏，靠 rebuild 的
+        # clear(broad=True) 整池兜底——回归面：全量套件 test_ccgc V4c/V5d
+        # 曾因 rebuild 不失效而陈旧红。
+        print("== G8 直写+rebuild 收尾写方缓存可见性 ==")
+        cg.search(QUERY)                            # 热缓存
+        e8 = cg.index["nodes"]["mem_002"]
+        fm8, c8 = cg._read(e8)
+        cg._write_node("mem_002", cg._node_disk_path(e8), fm8,
+                       "# 功能名：直写样本\n# 正文：%s 直写后内容G8 独有标记" % QUERY)
+        cg.rebuild_index()
+        _, n8 = count_loads(lambda: cg.search(QUERY)[0])
+        check("G8b rebuild 后整池重装（broad 兜底，loads ≥ 池规模）",
+              n8 >= len(cg.index["nodes"]),
+              f"loads={n8} pool={len(cg.index['nodes'])}")
+        e8b = cg.index["nodes"]["mem_002"]
+        fm8b, c8b = cg._read(e8b)                   # 缓存视图
+        check("G8a 直写+rebuild 后缓存视图见新内容（不陈旧）",
+              c8b is not None and "直写后内容G8" in c8b,
+              f"content={str(c8b)[:40]}")
+
+        # 收尾清理
+        cg.close()
+    finally:
+        os.environ.pop("MDCG_READ_CACHE", None)
+        shutil.rmtree(root, ignore_errors=True)
+
+    print("\n" + "=" * 60)
+    print(f"结果：PASS {PASS} / FAIL {FAIL}")
+    if FAILS:
+        for f in FAILS:
+            print(f"  - {f}")
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_readcache_prodpath.py

@@ -7,8 +7,9 @@
   - install_read_cache 6.53x（126→19.3 ms）但只用于 benchmark；
   - path-only 无失效的朴素实现在「写入后检索」场景**陈旧读**（旧内容命中）。
 
-本守卫五项：
-  P1 默认关零变更（env 未设 → 行为与改动前逐位一致）；
+本守卫七项：
+  P1 默认开（env 未设 → 构造即装）+ MDCG_READ_CACHE=0 opt-out 零变更退出阀
+     （issue #31 后续：默认关曾让生产入口每查询全池 open+parse）；
   P2 开启后检索结果与关闭态一致（缓存不改变结果，只改变速度）；
   P3 写后失效（能红 path-only 无失效实现）：写入新内容 → 检索必须命中
      新内容、不得命中旧内容——哨兵（_dirty 代际）失效的核心断言；
@@ -81,13 +82,28 @@ def main():
     os.environ.pop("MDCG_READ_CACHE", None)
     cg = build_lib(root)
     try:
-        # P1 默认关零变更
-        print("== P1 默认关（env 未设）零变更 ==")
-        check("P1a 未启用时无 _read_cache 属性", not hasattr(cg, "_read_cache"))
+        # P1 默认开 + opt-out 退出阀（issue #31 后续：默认关曾让生产检索入口
+        # 每查询全池 open+parse，3300 池实测 ~602ms/查询——默认翻转为本形态）
+        print("== P1 默认开（env 未设）+ MDCG_READ_CACHE=0 退出阀 ==")
+        check("P1a 默认（env 未设）构造即装读缓存", hasattr(cg, "_read_cache"))
         r0, _ = cg.search("蜂群调度")
         check("P1b 检索正常（基线）", len(r0) >= 1, f"results={len(r0)}")
-
-        # P2/P3/P4 开启态
+        os.environ["MDCG_READ_CACHE"] = "0"
+        try:
+            root_o = os.path.join(root, "optout")
+            os.makedirs(root_o, exist_ok=True)
+            cg_o = MdCGSecure(root_o, principal=Principal(
+                actor="rc", clearance="secret", can_write=True,
+                role="designer", auth_mode="test"))
+            check("P1c MDCG_READ_CACHE=0 → 未装缓存（opt-out 零变更退出阀）",
+                  not hasattr(cg_o, "_read_cache"))
+            r_o, _ = cg_o.search("占位")     # 关态检索照常（空结果非崩溃即证）
+            del cg_o
+        finally:
+            os.environ.pop("MDCG_READ_CACHE", None)
+
+        # P2/P3/P4 开启态（默认已装配；显式 =1 与默认等价，install 再包一层
+        # 同语义缓存——历史形态保留，断言面不变）
         print("== P2/P3/P4 MDCG_READ_CACHE=1 ==")
         os.environ["MDCG_READ_CACHE"] = "1"
         import importlib
@@ -136,6 +152,38 @@ def main():
         n = rc.clear(cg)
         check("P5 clear 返回清空条目数", n > 0, f"cleared={n}")
 
+        # P7 写代际单调（批次 23，issue #31 D-4 / v20 复现场景，能红 len 代际）
+        print("== P7 flush 后同量写入不回退（D-4 陈旧读）==")
+        cg.add("x_d4", "# 功能名：占位\n# 正文：原始内容AAA 星云", layer="knowledge")
+        cg.add("a_d4", "# 功能名：a\n# 正文：填充甲", layer="knowledge")
+        cg.add("b_d4", "# 功能名：b\n# 正文：填充乙", layer="knowledge")
+        cg.flush()
+        cg.add("c_d4", "# 功能名：c\n# 正文：填充丙", layer="knowledge")
+        cg.add("d_d4", "# 功能名：d\n# 正文：填充丁", layer="knowledge")
+        cg.search("原始内容AAA")                       # 装 x=OLD（此时 dirty len=2）
+        cg.add("x_d4", "# 功能名：占位\n# 正文：更新后内容BBB 星云",
+               layer="knowledge")                      # 覆写 x=NEW
+        cg.flush()                                     # dirty 清零（len 代际在此回退）
+        cg.add("e_d4", "# 功能名：e\n# 正文：填充戊", layer="knowledge")
+        cg.add("f_d4", "# 功能名：f\n# 正文：填充己", layer="knowledge")  # len 巧合回到 2
+        r_new, _ = cg.search("更新后内容BBB 星云")      # 写 NEW 后检索必须见 NEW
+        got = next((it[0].get("content") for it in r_new
+                    if it[0].get("id") == "x_d4"), None)
+        check("P7a flush 回退场景：检索新内容返回 NEW（len 代际实现必返 OLD）",
+              got is not None and "BBB" in got,
+              f"content={str(got)[:40]}")
+
+        # P7b 哨兵单调性直断：_DirtyDict 变更序列 write_gen 永不回退
+        d = __import__("md_cg.mdcg", fromlist=["_DirtyDict"])._DirtyDict()
+        gens = []
+        d["a"] = 1; gens.append(d.write_gen)
+        d["b"] = 2; gens.append(d.write_gen)
+        d.clear(); gens.append(d.write_gen)
+        d["c"] = 3; gens.append(d.write_gen)
+        check("P7b write_gen 单调不回退（clear 后再写仍前进）",
+              gens == sorted(gens) and len(set(gens)) == 4,
+              f"gens={gens}")
+
         # 还原
         os.environ.pop("MDCG_READ_CACHE", None)
     finally:

package/md_cg/test_reconcile_v0.py

@@ -0,0 +1,294 @@
+# -*- coding: utf-8 -*-
+"""test_reconcile_v0.py · 启动对账 reconcile v0 守卫（v0.3 T9 落地，落地清单 P0-3）
+
+现场：两段式写对账（`twophase.reconcile`）只清「有 intent 无 outcome」的写入账；
+索引（派生态）vs 盘面真源（节点 .md）之间没有全量 diff——非合作写者直写文件
+（缺索引条目）、外部删文件（多索引条目/幽灵）、直改正文（哈希漂移）三类背离
+零告警零修复，派生态与真源静默撕裂（T9 自稳定缺口）。
+
+修复（本守卫的红绿锚点）：`md_cg/reconcile.py` 新增 `reconcile_state(cg)`——
+  · 三类 diff：多索引条目（摘除，`_unstage` 同口径）/ 缺索引条目（`_node_entry`
+    重建补入）/ 哈希·路径漂移（以盘面为真源重建，增量 upsert 不触发全量
+    rebuild）；
+  · T9 边界：真源自身损坏（读失败 / 非 UTF-8 字节 / frontmatter 无闭合）只
+    stderr 告警 + `_reconcile.jsonl` 留痕，**不自动改写**——不据损坏文件建
+    条目，也不因读不出摘除既有条目（瞬态读失败被当「文件没了」= N134 同型
+    放大损伤）；
+  · 开关 `MDCG_RECONCILE=0` 关闭（缺省开）；干净库零输出零写盘、二次扫描
+    幂等全零；
+  · 承接面：`mcp_server.main()` 两段式对账之后新增 `cg.reconcile_state()`
+    （失败不阻塞启动）。
+先例修复（本守卫顺带锚定）：`mdcg._scan_nodes` 原只捕 OSError——一个非 UTF-8
+坏文件会炸穿整库装载/重建（init 先于对账，守卫若不补，损坏库永远跑不到对账）；
+补 `(OSError, UnicodeDecodeError)` 跳过，与 T9 边界同口径。
+
+**指纹双形态**（历史事实，非本守卫发明）：add 写路径入索引的 content_hash 按
+封存原文（无尾换行正文 ≠ rebuild 路径 loads 读回的带尾换行形态，实测两形态
+并存）——diff 两侧双形态都认，否则无尾换行节点每次启动都误报漂移（假阳性
+洪水）。[1b] 断言双形态下零误报，防未来有人「统一」掉一半。
+
+隔离纪律：临时 tempfile.mkdtemp 库 + 哑 Principal（designer），不触真实
+root/令牌库/数据目录；MDCG_RECONCILE 进出还原；测毕 rmtree。
+自检 floor：断言总数低于 FLOOR 视为失败——防「探针面失效 → 假绿」。
+"""
+from __future__ import annotations
+
+import contextlib
+import io
+import os
+import shutil
+import sys
+import tempfile
+
+try:
+    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+except AttributeError:
+    pass
+
+from . import nodefile, reconcile
+from .mdcg import MdCG
+from .security import Principal
+
+FLOOR = 26           # 断言总数下限（防假绿）
+PASS, FAIL = 0, 0
+
+
+def check(name, cond, detail=""):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  [ok] {name}")
+    else:
+        FAIL += 1
+        print(f"  [FAIL] {name}  {detail}")
+
+
+def _run(cg, apply=True):
+    """跑一次对账并抓 stderr → (report, stderr 文本)。"""
+    err = io.StringIO()
+    with contextlib.redirect_stderr(err):
+        rep = reconcile.reconcile_state(cg, apply=apply)
+    return rep, err.getvalue()
+
+
+def _disk_hash_of(cg, nid):
+    e = cg.index["nodes"][nid]
+    with open(os.path.join(cg.root, e["path"]), encoding="utf-8") as f:
+        return nodefile.content_hash(nodefile.loads(f.read())[1])
+
+
+def main():
+    saved_sw = os.environ.get(reconcile.ENV_SWITCH)
+    tmp = tempfile.mkdtemp(prefix="mdcg_recon_v0_")
+    try:
+        pr = Principal(actor="recon_guard", clearance="secret",
+                       can_write=True, can_admin=True, role="designer")
+        cg = MdCG(os.path.join(tmp, "cg"))
+        # a1 刻意**无尾换行**（add 指纹形态）；a2 带尾换行（rebuild 指纹形态）
+        cg.add("a1", "hello recon body", layer="knowledge")
+        cg.add("a2", "world recon body\n", layer="knowledge")
+        cg.flush()
+
+        # ---- [1] 干净库：三类全零 + 双形态零误报 + 零输出零写盘 ----
+        print("[1] 干净库零误报（含指纹双形态）")
+        rep, err = _run(cg)
+        check("1a 三类 diff 全零（多/缺/漂移）",
+              not rep["ghost_entries"] and not rep["missing_entries"]
+              and not rep["hash_drift"], f"rep={rep}")
+        check("1b 无尾换行节点零误报（add 形态指纹被双形态接受集收容）",
+              "a1" in cg.index["nodes"] and not rep["hash_drift"],
+              f"drift={rep['hash_drift']}")
+        check("1c rebuild 后（rebuild 形态指纹）再次对账仍零漂移",
+              (cg.rebuild_index() or {}).get("nodes", {}).get("a1") is not None
+              and _run(cg)[0]["hash_drift"] == [],
+              f"drift={_run(cg)[0]['hash_drift']}")
+        check("1d 干净库零 stderr 输出（diff 非空才发声）",
+              err == "", f"stderr={err[:120]!r}")
+        check("1e 干净库零写盘（无留痕文件）",
+              not os.path.isfile(reconcile.trace_path(cg)),
+              f"trace={reconcile.trace_path(cg)}")
+
+        # ---- [2] 多索引条目（幽灵）：外部直删 a2 文件 ----
+        print("[2] 多索引条目：外部删文件 → 检出+摘除收敛+告警留痕")
+        os.remove(os.path.join(cg.root, cg.index["nodes"]["a2"]["path"]))
+        rep, err = _run(cg)
+        check("2a diff 检出 ghost=[a2]", rep["ghost_entries"] == ["a2"],
+              f"ghost={rep['ghost_entries']}")
+        check("2b 自动修复：条目摘除且 tombstone 落账（unstaged=1）",
+              "a2" not in cg.index["nodes"]
+              and rep["repaired"]["unstaged"] == 1, f"rep={rep}")
+        check("2c stderr 告警点名", "幽灵条目" in err, f"stderr={err[:160]!r}")
+        check("2d 留痕落盘（_reconcile.jsonl）",
+              os.path.isfile(reconcile.trace_path(cg)),
+              f"trace={reconcile.trace_path(cg)}")
+        rep2, err2 = _run(cg)
+        check("2e 幂等：二次扫描三类全零且零输出",
+              not (rep2["ghost_entries"] or rep2["missing_entries"]
+                   or rep2["hash_drift"]) and err2 == "",
+              f"rep={rep2} stderr={err2[:80]!r}")
+
+        # ---- [3] 缺索引条目：非合作写者直写文件 ----
+        print("[3] 缺索引条目：直写 .md 不经索引 → 检出+补入收敛")
+        fm = {"id": "x1", "layer": "knowledge", "importance": 0.4,
+              "created_at": 123.0}
+        with open(os.path.join(cg.root, "knowledge", "x1.md"), "w",
+                  encoding="utf-8") as f:
+            f.write(nodefile.dumps(fm, "ghost writer body"))
+        rep, err = _run(cg)
+        g = cg.get("x1")
+        check("3a diff 检出 missing=[x1]", rep["missing_entries"] == ["x1"],
+              f"missing={rep['missing_entries']}")
+        check("3b 自动修复：条目以 _node_entry 补入（staged=1）且 get 可读",
+              rep["repaired"]["staged"] == 1 and g is not None
+              and "ghost writer body" in (g or {}).get("content", ""),
+              f"rep={rep} get={(g or {}).get('content', '')[:40]!r}")
+        check("3c 补入条目 content_hash 与盘面重算一致",
+              cg.index["nodes"]["x1"]["content_hash"] == _disk_hash_of(cg, "x1"),
+              f"idx={cg.index['nodes']['x1']['content_hash']} "
+              f"disk={_disk_hash_of(cg, 'x1')}")
+
+        # ---- [4] 内容漂移：外部直改 a1 正文 ----
+        print("[4] 哈希漂移：直改正文 → 检出+以盘面重建收敛")
+        p1 = os.path.join(cg.root, cg.index["nodes"]["a1"]["path"])
+        with open(p1, encoding="utf-8") as f:
+            txt = f.read()
+        with open(p1, "w", encoding="utf-8") as f:
+            f.write(txt.replace("hello recon body", "DRIFTED recon body"))
+        rep, err = _run(cg)
+        g1 = cg.get("a1")
+        check("4a diff 检出 drift=[a1]", rep["hash_drift"] == ["a1"],
+              f"drift={rep['hash_drift']}")
+        check("4b 自动修复：检索面读到盘面新正文（盘面为真源）",
+              g1 is not None and "DRIFTED recon body" in (g1 or {}).get(
+                  "content", ""),
+              f"get={(g1 or {}).get('content', '')[:40]!r}")
+        check("4c 修复后索引指纹 == 盘面重算指纹",
+              cg.index["nodes"]["a1"]["content_hash"]
+              == _disk_hash_of(cg, "a1"),
+              f"idx={cg.index['nodes']['a1']['content_hash']}")
+
+        # ---- [5] 真源损坏：只告警不改写（T9 边界）----
+        print("[5] 真源损坏两面：无闭合 frontmatter + 非 UTF-8 字节")
+        cg.add("a3", "body three", layer="knowledge")
+        cg.add("a4", "body four\n", layer="knowledge")
+        cg.flush()
+        with open(os.path.join(cg.root, "knowledge", "bad1.md"), "w",
+                  encoding="utf-8") as f:
+            f.write("---\n" + 'id: bad1\n')          # 无闭合 → 结构非法
+        p4 = os.path.join(cg.root, cg.index["nodes"]["a4"]["path"])
+        with open(p4, "wb") as f:
+            f.write(b"---\xff\xfe\x00binary garbage")  # 非 UTF-8 字节
+        rep, err = _run(cg)
+        kinds = sorted(p["kind"] for p in rep["unwritable_source"])
+        check("5a 损坏检出两面（decode_error + frontmatter_unterminated）",
+              kinds == ["decode_error", "frontmatter_unterminated"],
+              f"kinds={kinds}")
+        check("5b 损坏文件不建条目（bad1 不入索引——不据损坏真源写派生态）",
+              "bad1" not in cg.index["nodes"]
+              and "bad1" not in rep["missing_entries"],
+              f"missing={rep['missing_entries']}")
+        check("5c 读不出的既有条目不摘除（a4 保留——瞬态/损坏 ≠ 文件没了）",
+              "a4" in cg.index["nodes"]
+              and "a4" not in rep["ghost_entries"]
+              and "a4" in rep.get("kept_unreadable", []),
+              f"ghost={rep['ghost_entries']} kept={rep.get('kept_unreadable')}")
+        check("5d stderr 告警含 T9 边界口径（只告警不改写）",
+              "真源损坏" in err and "不改写" in err.replace("（", "("),
+              f"stderr={err[:200]!r}")
+        with open(reconcile.trace_path(cg), encoding="utf-8") as f:
+            trace_txt = f.read()
+        check("5e 留痕记录损坏清单（trace 含 problems）",
+              "decode_error" in trace_txt
+              and "frontmatter_unterminated" in trace_txt,
+              f"trace={trace_txt[:200]!r}")
+
+        # ---- [6] 开关：MDCG_RECONCILE=0 关闭 ----
+        print("[6] 关闭开关 MDCG_RECONCILE=0（缺省开）")
+        open(os.path.join(cg.root, "knowledge", "x9.md"), "w",
+             encoding="utf-8").write(
+            nodefile.dumps({"id": "x9", "layer": "knowledge"}, "off switch body"))
+        os.environ[reconcile.ENV_SWITCH] = "0"
+        rep_off, _e = _run(cg)
+        check("6a 开关关：skipped=True 不触盘", rep_off.get("skipped") is True,
+              f"rep={rep_off}")
+        check("6b 开关关：diff 在场也不修（x9 不入索引）",
+              "x9" not in cg.index["nodes"], f"nodes={list(cg.index['nodes'])}")
+        os.environ.pop(reconcile.ENV_SWITCH, None)
+        rep_on, _e = _run(cg)
+        check("6c 缺省开：开关还原后 x9 补入收敛",
+              rep_on["missing_entries"] == ["x9"]
+              and cg.get("x9") is not None,
+              f"missing={rep_on['missing_entries']}")
+
+        # ---- [7] dry-run：只 diff 不修 ----
+        print("[7] dry-run（apply=False）只报告不改写")
+        p1 = os.path.join(cg.root, cg.index["nodes"]["a1"]["path"])
+        with open(p1, encoding="utf-8") as f:
+            _txt = f.read()                      # 先读后写（"w" 打开即截断）
+        with open(p1, "w", encoding="utf-8") as f:
+            f.write(_txt.replace("DRIFTED recon body", "DRIFT2 recon body"))
+        rep_dry, _e = _run(cg, apply=False)
+        check("7a dry-run 检出漂移但不修（applied=False，索引条目仍旧指纹——"
+              "get 直读盘面本就见新正文，dry-run 不修的是索引面）",
+              rep_dry["hash_drift"] == ["a1"] and rep_dry["applied"] is False
+              and cg.index["nodes"]["a1"]["content_hash"]
+              != _disk_hash_of(cg, "a1"),
+              f"rep={rep_dry}")
+        rep_fix, _e = _run(cg)
+        check("7b 正式对账收敛漂移（检索面见 DRIFT2）",
+              "DRIFT2 recon body" in (cg.get("a1") or {}).get("content", ""),
+              f"get={(cg.get('a1') or {}).get('content', '')[:40]!r}")
+
+        # ---- [8] 损坏在场重开：装载不炸（_scan_nodes 守卫）+ 收敛保持 ----
+        print("[8] 损坏真源在场重开库（装载路径守卫）")
+        root = cg.root
+        cg.close()
+        cg2 = MdCG(root)
+        check("8a 非 UTF-8 坏文件在场，重开装载不炸（_scan_nodes 跳过）",
+              isinstance(cg2.index.get("nodes"), dict),
+              "重开抛 UnicodeDecodeError 即假绿")
+        check("8b 重开后补入条目可见（x1）、摘除不复活（a2）",
+              cg2.get("x1") is not None and "a2" not in cg2.index["nodes"],
+              f"x1={cg2.get('x1') is not None} a2={'a2' in cg2.index['nodes']}")
+        cg2.close()
+
+        # ---- [9] 承接面源断言：mcp_server main 启动序列接线 ----
+        print("[9] 承接面源断言")
+        here = os.path.dirname(os.path.abspath(__file__))
+        with open(os.path.join(here, "mcp_server.py"), encoding="utf-8") as fh:
+            msrc = fh.read()
+        _anchor = msrc.find("cg.reconcile_writes()")
+        win = msrc[_anchor:msrc.find("_start_sustain", _anchor)]
+        check("9a mcp_server.main() 两段式对账之后新增 reconcile_state 接线",
+              "cg.reconcile_state()" in win, "main() 缺启动对账 v0 承接")
+        check("9b 接线以 try/except 包裹（对账失败不阻塞启动）",
+              "except Exception" in win and "不阻塞启动" in win,
+              "缺容错承接")
+        with open(os.path.join(here, "mdcg.py"), encoding="utf-8") as fh:
+            dsrc = fh.read()
+        check("9c MdCG.reconcile_state 委托在位（延迟导入 reconcile）",
+              "def reconcile_state" in dsrc
+              and "reconcile.reconcile_state" in dsrc, "缺委托方法")
+        with open(os.path.join(here, "mdcg.py"), encoding="utf-8") as fh:
+            check("9d _scan_nodes 捕 (OSError, UnicodeDecodeError)（装载路径 "
+                  "T9 守卫）",
+                  "except (OSError, UnicodeDecodeError):" in dsrc,
+                  "装载路径缺解码守卫")
+
+        # ---- [10] 守卫自检 ----
+        print("[10] 守卫自检")
+        check(f"10a 断言总数 ≥ {FLOOR}（防探针面失效假绿）",
+              PASS + FAIL >= FLOOR, f"total={PASS + FAIL}")
+    finally:
+        if saved_sw is None:
+            os.environ.pop(reconcile.ENV_SWITCH, None)
+        else:
+            os.environ[reconcile.ENV_SWITCH] = saved_sw
+        shutil.rmtree(tmp, ignore_errors=True)
+
+    print(f"\n=== reconcile v0 tests: {PASS} passed, {FAIL} failed ===")
+    sys.exit(1 if FAIL else 0)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_retr_s1.py

@@ -326,8 +326,12 @@ def main():
                              and "observation_position" not in r[0])
                             for r in _r7),
           str([sorted(r[0].keys()) for r in _r7])[:160])
-    check("默认关：索引条目本身未被就地改写",
-          cg7.index["nodes"]["q1"].get("big_domain") == "工程")
+    # V21-5（批次 34）：就地剥离为定案正确语义——残留是一次性污染，自愈后
+    # 索引条目不再带门控键（批次 31 的「不改写」形态 = no-op 回写，被 V21
+    # 报告定案为缺陷；本断言随语义修正翻转）
+    check("默认关：索引条目门控键已就地剥离（V21-5 自愈）",
+          "big_domain" not in cg7.index["nodes"]["q1"]
+          and "observation_position" not in cg7.index["nodes"]["q1"])
     _restore(old)
 
     print("\ntest_retr_s1: %d 通过 / %d 失败" % (passed, failed))