@furongjun1999/dsh-memory 0.5.0 → 0.6.0

package/md_cg/mdcg.py

@@ -248,6 +248,12 @@ def en_zh_terms(text: str) -> list:
         独立归一化原子+Jaccard 路（REPRODUCE.md 双语双路裁定，md_cg
         char-bigram 管线跑英文实测比独立方案差 25% vs 52%），本集成为
         opt-in 实验能力与 soul hub 序列化出口，不在默认链路生效；
+        ⚠ 注意与**统一归一层**的区别（2026-09-24 澄清）：`semantic/unify.py`
+        的 `unify_query` 是另一个开关且**默认开启**（MDCG_UNIFY_QUERY，
+        2026-09-23 口径转正），它在检索入口把英文 query 归一成中文原子——
+        于是默认态下英文 query 经**词法路**即可命中中文节点，而本函数
+        （召回词扩展侧）仍是默认关。两者不能互相推断，改动其一须核对
+        test_en_pipeline / test_semantic_canonical 的双态断言；
       - 仅当 query 含英文字母时触发，纯中文 query 零开销零变化；
       - 代词语素剔除（我/你/他…超泛词防污染），动词/名词单字语素保留
         （「吃/雨」在中文正文检索价值高，_score 终排兜底精度）；
@@ -718,25 +724,46 @@ def apply_retrieval_gates(entries, terms, big_domain, context, min_results):
             gates["s1b"] = {"keys": [], "reason": "disabled_by_topk"}
         else:
             _sizes = {}
+            _zh_alias = {}           # issue #33：桶 → 中文别名集（英文键的跨语言面）
             for _e in entries:
                 _b = _e.get("bucket")
                 if _b and _b != routing.ORPHAN:
                     _sizes[_b] = _sizes.get(_b, 0) + 1
+                    _al = _zh_alias.setdefault(_b, set())
+                    for _w in (_e.get("bucket_zh") or []):
+                        _al.add(str(_w))
             _best = {}
             for _b in _sizes:
                 _kk = routing.bucket_key_readable(_b)
                 if not _kk:
                     continue
+                # 比较面 = 可读键 ∪ 中文别名（别名只来自节点自身内容，零翻译依赖；
+                # 无别名的存量库行为与旧版逐位一致——别名集为空即旧口径）
+                _faces = [_kk] + sorted(_zh_alias.get(_b, ()))
                 _sim = 0.0
                 for _t in terms:
-                    _sv = routing.domain_similarity(_t, _kk)
-                    if _sv > _sim:
-                        _sim = _sv
+                    for _f in _faces:
+                        _sv = routing.domain_similarity(_t, _f)
+                        if _sv > _sim:
+                            _sim = _sv
                 if _sim >= _s1b_minsim:
                     _best[_b] = _sim
             if not _best:
-                gates["s1b"] = {"keys": [], "reason": "no_key_match",
-                               "in": len(entries), "buckets": len(_sizes)}
+                # 审计止血（issue #33 建议 3）：区分「真的无匹配」与「跨语言盲区」——
+                # query 带中文信号、而全部桶的比较面（键+别名）都无中文 → 前者是
+                # 语义不相关（正常回退），后者是修复盲区的运维可见形态。
+                _q_zh = any(routing._ZH_RE.search(str(_t)) for _t in terms)
+                _faces_all_zh = any(
+                    routing._ZH_RE.search(_f)
+                    for _b in _sizes
+                    for _f in ([routing.bucket_key_readable(_b)]
+                               + sorted(_zh_alias.get(_b, ()))))
+                gates["s1b"] = {
+                    "keys": [],
+                    "reason": ("cross_lang_no_match"
+                               if (_q_zh and _sizes and not _faces_all_zh)
+                               else "no_key_match"),
+                    "in": len(entries), "buckets": len(_sizes)}
             else:
                 _picked = sorted(_best.items(),
                                  key=lambda kv: (-kv[1], -_sizes[kv[0]],
@@ -770,9 +797,128 @@ def apply_retrieval_gates(entries, terms, big_domain, context, min_results):
     return entries, gates
 
 
+# 生效条件：无独立生效条件（模块级哨兵字典类）；任何变更操作（setitem/delitem/clear/pop/popitem/setdefault/update）都会使 write_gen 自增 1，读取 write_gen 不变更；setitem 的值为含非空 path 字符串的 dict 时把该 path 记入 path_gen（值为当时的 write_gen）且不动 broad_gen，值为其它形态（含 None tombstone）或经 delitem/pop/popitem/setdefault/update 变更时把 broad_gen 置为当时的 write_gen，clear() 缺省（flush 收尾）只使 write_gen 自增、不改写 path_gen/broad_gen，clear(broad=True)（rebuild_index 收尾）同时把 broad_gen 置为当时的 write_gen。
+class _DirtyDict(dict):
+    """写代际哨兵字典（批次 23，issue #31 D-4 / v20 报告）：任何变更使
+    `write_gen` **单调自增、永不回退**。
+
+    为什么不用 `len(self._dirty)` 作写代际：flush 后 `_dirty` 清零，新写入
+    会使长度**回到旧值**——代际巧合回退会让读缓存误命中陈旧内容（v20
+    `v20_d4_repro.py` stale=True 实测）。单调计数器下「任何写都使代际前进」，
+    读缓存的失效判定不再依赖长度巧合。
+
+    消费方纪律：flush/rebuild 清空必须走 `.clear()`（保住子类钩子），
+    **不得** `self._dirty = {}` 直接换新 dict——那会退化为普通 dict，
+    write_gen 恒 0、读缓存失效面随之失效。
+
+    脏集精确失效簿记（缺陷迭代第 14 轮，high：写读交替整池重装）：
+    全局单一 write_gen 作读缓存哨兵会让**任意一次单节点写使全部缓存条目
+    同时 miss**（10k 池写读交替实测 3rep 中位 1677.6ms vs 稳态 43.7ms，
+    38.4× 退化、线性于 N）。所有节点文件写路径在落盘后必以
+    `_dirty[nid] = entry`（entry 带 path）标脏——本类据此把失效粒度从
+    整代际细化到 path：`path_gen[path]` 记该 path 最近标脏时的 write_gen，
+    读缓存按「path 最近标脏代际 ≤ 缓存代际」判新鲜（见 readcache.install）。
+    tombstone（值 None，_unstage 删除记录）与其余无 path 可辨的变更形态
+    记 `broad_gen`（保守整池失效，与旧整代际口径等价的安全兜底）。
+    `clear()`（flush 收尾）**只推进 write_gen**：flush 只落索引
+    派生物（_index_log 分片/快照），不改节点文件——文件内容变更已在各
+    写路径 `_dirty[nid]=entry` 时按 path 精确失效；且生产写路径每次写后
+    `writepipe._commit_visibility→flush`（每次写必 clear），clear 若再整池
+    失效会让精确失效在生产写读交替负载下恒不生效。`clear(broad=True)`
+    （rebuild_index 收尾）额外推进 broad_gen 整池失效：rebuild 以盘面
+    扫描为准，ccgc/crosscheck/backfill 等「直写文件 + rebuild 收尾」的
+    写方不经 `_dirty` 标脏，其文件改写对读缓存的可见性靠这一兜底。
+    """
+
+    def __init__(self, *a, **k):
+        super().__init__(*a, **k)
+        self.write_gen = 0
+        self.path_gen = {}      # path → 该 path 最近一次标脏时的 write_gen
+        self.broad_gen = 0      # 最近一次无 path 可辨变更的 write_gen（整池兜底）
+
+    def _bump(self):
+        self.write_gen += 1
+
+    def _note(self, v):
+        """标脏登记：值带 path → 精确记路径代际；否则保守记整池代际。"""
+        p = v.get("path") if isinstance(v, dict) else None
+        if isinstance(p, str) and p:
+            self.path_gen[p] = self.write_gen
+        else:
+            self.broad_gen = self.write_gen
+
+    def __setitem__(self, k, v):
+        self._bump()
+        self._note(v)
+        super().__setitem__(k, v)
+
+    def __delitem__(self, k):
+        self._bump()
+        self.broad_gen = self.write_gen
+        super().__delitem__(k)
+
+    def clear(self, broad: bool = False):
+        """清空脏集。
+
+        broad=False（flush 收尾）：只推进 write_gen，不整池失效——flush 只
+        落索引派生物（_index_log 分片），节点文件的内容变更已在各写路径
+        `_dirty[nid]=entry`（带 path）时按 path 精确失效；且生产写路径每次
+        写后 `writepipe._commit_visibility→flush`，整池失效会让精确失效在
+        生产写读交替负载下恒不生效。
+        broad=True（rebuild_index 收尾）：同时推进 broad_gen 整池失效——
+        rebuild 以**盘面扫描**为准重建索引，ccgc/crosscheck/backfill 等
+        「直写文件 + rebuild 收尾」的写方不经 `_dirty` 标脏，其文件改写对
+        读缓存的可见性全靠这一兜底（与 MdStore「写方落盘后显式 reload」
+        同构）。
+        """
+        self._bump()
+        if broad:
+            self.broad_gen = self.write_gen
+        super().clear()
+
+    def pop(self, k, *d):
+        self._bump()
+        self.broad_gen = self.write_gen
+        return super().pop(k, *d)
+
+    def popitem(self):
+        self._bump()
+        self.broad_gen = self.write_gen
+        return super().popitem()
+
+    def setdefault(self, k, d=None):
+        self._bump()
+        self.broad_gen = self.write_gen
+        return super().setdefault(k, d)
+
+    def update(self, *a, **k):
+        self._bump()
+        self.broad_gen = self.write_gen
+        super().update(*a, **k)
+
+
+# P0-1（批次 24）/ V21-3（批次 34，外部报告）：node_id 白名单——id 拼进落盘
+# 路径，穿越（..）与绝对路径/路径分隔符一律拒绝。**不含冒号**：NTFS 上文件名
+# 中的 `:` 是备用数据流（ADS）分隔符（`a:b.md` 实际写 a 的 b.md 流，主文件名
+# 错位）——Windows 目标平台硬约束。V21-3 放行**中文**（\u4e00-\u9fff）与**逗号**：
+# tasks.slugify 设计「不翻译、中文原样保留」（task_任务-名-一 形态）、
+# test_reach 用 comma,node——库自身命名链路必须自洽（V21 报告定案 5 官方红
+# 同源）。中文/逗号无路径语义，P0-1 防线（..禁令+realpath 纵深闸）不变。
+_NODE_ID_RE = re.compile(r"^[A-Za-z0-9_.@\u4e00-\u9fff,-]{1,128}$")
+
+# P3（2026-09-26，DSH 在役库实测 None.md 缺陷）：空语义值的**字符串化污染形态**
+# 整串禁写——批次 24 前 add 无校验，`f"{node_id}.md"` 直拼，`add(None)` 直落
+# `None.md`（旧版直接源头）；批次 24 白名单堵住 None 本体后，字符串 "None"
+# （Python `str(None)`）/"null"（TS `String(null)`）形状合法仍放行（临时库实弹
+# 复现：add("None") → knowledge/orphan/None.md，经 _scan_nodes 收录进检索与
+# route 候选参与打分）。只拒**整串精确等值**（大小写敏感），不扩子串——
+# "NoneBot_1"/"nullify_test" 等合法 id 不受影响。
+_NODE_ID_FORBIDDEN = frozenset({"None", "null"})
+
+
 # 生效条件：构造须传入 root，经 os.path.abspath 后以 exist_ok=True 创建该目录及 LAYERS 各层子目录；autoflush 无论取值（默认 64）都原样赋给实例。
 class MdCG:
-# 生效条件：root 传参即被 os.path.abspath 绝对化并 makedirs(exist_ok=True) 建立 root 与模块级 LAYERS 各层目录，autoflush（默认 64，含 0 等假值）原样存入 self.autoflush，随后 _load_index() 载入索引、sweep_stale_temps(self.root) 清扫，并把 self 登记进模块级 _LIVE_CGS；
+# 生效条件：root 传参即被 os.path.abspath 绝对化并 makedirs(exist_ok=True) 建立 root 与模块级 LAYERS 各层目录，autoflush（默认 64，含 0 等假值）原样存入 self.autoflush，随后 _load_index() 载入索引并以 _index_signature() 记录 _index.json 签名到 self._index_sig（跨进程读面代际感知的基线，P1b-2）、sweep_stale_temps(self.root) 清扫，并把 self 登记进模块级 _LIVE_CGS；
     def __init__(self, root: str, autoflush: int = 64):
         self.root = os.path.abspath(root)
         os.makedirs(self.root, exist_ok=True)
@@ -788,9 +934,16 @@ class MdCG:
         # 近期事件滚动窗口（白箱第 5 篇第 3 章「近期事件」）
         self.recent_log = os.path.join(self.root, "_recent.jsonl")
         self.autoflush = autoflush
-        self._dirty = {}
+        self._dirty = _DirtyDict()
         self._log = None
         self.index = self._load_index()
+        # P1b-2（2026-09-26，DSH 在役复验）：索引只在本行装载一次，此后
+        # read/get/search 全走内存态——其它进程（review_cli autoflush=1）
+        # 写盘对常驻进程不可见（探针 dsh_restart_recheck_20260926：写后
+        # _index.json 已含探针、同进程 read 仍 null）。记录装载时的文件
+        # 签名作为基线，读路径入口经 _maybe_reload_index 按签名变化增量
+        # 重载；无变化路径只有一次 stat（微秒级）。
+        self._index_sig = self._index_signature()
         sweep_stale_temps(self.root)
         # 进程退出兜底登记（见模块级 _LIVE_CGS）：一次性脚本漏收尾时索引仍能落盘。
         _LIVE_CGS.add(self)
@@ -798,7 +951,7 @@ class MdCG:
 
     # ---------- 索引（派生物，可重建） ----------
 
-# 生效条件：os.path.exists(self.index_path) 为真、json.load 成功且其 "schema" 等于模块级 SCHEMA 时以该快照为基底，否则以 self._scan_nodes() 结果与空 buckets 新建；随后重放 ShardedLog.read_all(self.index_log_dir)：记录无 id 跳过、e 为 None 则 pop 该 nid（tombstone）、e 非 None 则覆盖，最终 buckets 由 _count_buckets 重算；
+# 生效条件：os.path.exists(self.index_path) 为真、json.load 成功且其 "schema" 等于模块级 SCHEMA、且其 "_fingerprint"（目录树 mtime 指纹）等于当前 self._dir_fingerprint() 时以该快照为基底；快照缺失/损坏/无指纹/指纹不符（盘面在快照写入后有增删——其它存活实例未 flush 的写入或外部改盘）均回退 self._scan_nodes() 全库扫描为基底；随后重放 ShardedLog.read_all(self.index_log_dir)：记录无 id 跳过、e 为 None 则 pop 该 nid（tombstone）、e 非 None 则覆盖，最终 buckets 由 _count_buckets 重算；
     def _load_index(self):
         idx = None
         if os.path.exists(self.index_path):
@@ -809,6 +962,17 @@ class MdCG:
                     idx = d
             except (ValueError, OSError):
                 idx = None
+        if idx is not None:
+            # 指纹校验（issue #33）：快照只在「盘面与写入时一致」时可信。
+            # close 自动落盘常态化后，快照路径不再扫盘面——若不校验，
+            # 其它存活实例未 flush 的写入（文件已落盘、索引增量还在其
+            # _dirty）会从索引不可见。指纹不符 → 回退全库扫描（即原
+            # 「无快照」路径的兜底行为，成本不劣于改动前）。旧快照无
+            # _fingerprint 键 → 同样回退一次（迁移窗口），下次 close
+            # 落新快照后恢复快照路径。
+            fp = idx.get("_fingerprint")
+            if fp is None or fp != self._dir_fingerprint():
+                idx = None
         if idx is None:
             idx = {"schema": SCHEMA, "nodes": self._scan_nodes(), "buckets": {}}
         for rec in ShardedLog.read_all(self.index_log_dir):
@@ -824,6 +988,94 @@ class MdCG:
         idx["buckets"] = self._count_buckets(idx["nodes"])
         return idx
 
+# 生效条件：以 os.stat(self.index_path) 返回 (st_mtime_ns, st_size) 二元组；文件不存在或 stat 抛 OSError 时返回 None（stat 异常静默——签名探测绝不阻塞读）；
+    def _index_signature(self):
+        """_index.json 文件签名（P1b-2 跨进程读面代际的廉价哨兵）。
+
+        只 stat 一次（微秒级、无 open 无解析）；(mtime_ns, size) 二元组在
+        NTFS 100ns / ext4 ns 粒度下足以识别「他进程写快照」。None = 快照
+        不存在（空库或写方尚未 compact），与他进程首次落快照的 None→非 None
+        变化同样可判。
+        """
+        try:
+            st = os.stat(self.index_path)
+            return (st.st_mtime_ns, st.st_size)
+        except OSError:
+            return None
+
+# 生效条件：stat 对比 _index_signature() 与 self._index_sig，相等（含双侧 None）即返回 False 不做任何事；不等则调 _load_index() 重载，OSError/ValueError 时静默放弃并返回 False（重载失败不阻塞读，沿用旧内存态）；成功后把 self._dirty 重放回新索引（None=tombstone pop、否则覆盖，与 _load_index 的日志重放同语义——本实例未 flush 的写入不得因重载从检索面消失）并重算 buckets，替换 self.index、刷新 self._index_sig、返回 True；
+    def _maybe_reload_index(self):
+        """读路径入口的索引代际感知（P1b-2）：签名变化才重载。
+
+        语义边界（读码定案）：
+        · flush() 只追加 _index_log 分片、不改 _index.json（见 flush 注释）
+          → 签名不变 → 自身写入/落账**永不**触发重载（无自重载循环）；
+        · compact_index / rebuild_index 写 _index.json 后已主动刷新签名，
+          同理不触发；
+        · 他进程只有写出新快照（compact/rebuild，典型在 close）才改变签名
+          → 此时重载并重放分片日志（_load_index 既有行为），写入可见；
+          仅追加日志、尚无新快照的存活写方不在本探测面内（显式触发可用
+          maintain action=reload，但日志记录只有在快照重写时才会并入）；
+        · 本实例 _dirty 未 flush 的条目在重载后**重放回内存索引**——
+          _stage 双写 index+_dirty 的「检索看得到未落盘写入」语义保持。
+        """
+        sig = self._index_signature()
+        if sig == self._index_sig:
+            return False
+        try:
+            idx = self._load_index()
+        except (OSError, ValueError):
+            return False                # 重载失败不阻塞读：沿用旧内存态
+        for nid, e in self._dirty.items():
+            if e is None:
+                idx["nodes"].pop(nid, None)
+            else:
+                idx["nodes"][nid] = e
+        idx["buckets"] = self._count_buckets(idx["nodes"])
+        self.index = idx
+        self._index_sig = sig
+        # 旧索引代里的派生缓存一并失效：query 结果缓存（hotcache，默认关）
+        # 缓存的是旧候选池上的结果；解析读缓存（readcache，默认开）按 path
+        # 缓存解析产物——他进程重写同 path 节点时旧产物陈旧。重载是稀疏
+        # 事件（签名变化才有），此处清缓存不构成热路径开销。
+        from . import hotcache as _hc
+        _hc.invalidate(self)
+        from . import readcache as _rc
+        _rc.clear(self)
+        return True
+
+# 生效条件：遍历 LAYERS 各层目录树（os.walk，不读文件内容），对每个可达目录记录其相对 root 的正斜杠路径到 os.stat().st_mtime_ns 的映射；stat 抛 OSError 的目录跳过；返回该映射。
+    def _dir_fingerprint(self):
+        """盘面目录树 mtime 指纹——检测「快照写入后盘面有增删」的廉价哨兵。
+
+        只 walk 目录 + 每目录一次 stat（不 open/不解析任何 .md），成本
+        与目录数成正比、与节点数无关（平铺库 ~LAYERS 次 stat）。目录
+        mtime 在直接子项增删时变化（NTFS 100ns / ext4 ns 粒度）。
+        边界：同目录**内容级**改写（不动文件名）不触发——合作写路径
+        （add/update）都同步走索引增量日志，不依赖本指纹；外部直改
+        文件内容属非合作写者协议（见 readcache 同款声明）。
+        """
+        fp = {}
+        for layer in LAYERS:
+            base = os.path.join(self.root, layer)
+            for dirpath, _dirs, _files in os.walk(base):
+                try:
+                    fp[os.path.relpath(dirpath, self.root).replace("\\", "/")] = \
+                        os.stat(dirpath).st_mtime_ns
+                except OSError:
+                    continue
+        return fp
+
+# 生效条件：遍历 LAYERS 各层目录树（os.walk，不读文件内容），统计文件名以 ".md" 结尾的文件总数并返回。
+    def _count_md_files(self):
+        """盘面 .md 文件计数（不 open/不解析）——compact 写快照前的账本对账。"""
+        n = 0
+        for layer in LAYERS:
+            base = os.path.join(self.root, layer)
+            for _dp, _dirs, files in os.walk(base):
+                n += sum(1 for fn in files if fn.endswith(".md"))
+        return n
+
     @staticmethod
 # 生效条件：nodes 须为带 values() 的映射且各元素支持 .get("bucket")；仅当 bucket 取值为真值时才计入返回计数，缺键或假值均跳过。
     def _count_buckets(nodes):
@@ -834,30 +1086,59 @@ class MdCG:
                 buckets[b] = buckets.get(b, 0) + 1
         return buckets
 
-# 生效条件：os.path.exists(self.index_path) 为真、JSON 可解析且 "schema" 等于 SCHEMA 时以该快照为基底，否则用空骨架 {"schema":SCHEMA,"nodes":{},"buckets":{}} 作基底（不重扫目录），再对 index_log_dir 逐条重放（无 id 跳过、e 为 None 则 pop、否则覆盖），落盘并清空日志后替换 self.index 并返回 idx；
+# 生效条件：os.path.exists(self.index_path) 为真、JSON 可解析且 "schema" 等于 SCHEMA 时以该快照为基底；快照不存在用空骨架 {"schema":SCHEMA,"nodes":{},"buckets":{}}（不重扫目录）；快照损坏（ValueError/OSError）或 schema 不符时降级以 self._scan_nodes() 全库扫描结果为基底（宁重扫勿清池）；基底确定后对 index_log_dir 逐条重放（无 id 跳过、e 为 None 则 pop、否则覆盖），落盘并清空日志后替换 self.index、刷新 _index.json 签名（P1b-2 自写不自载）并返回 idx；
     def compact_index(self):
         with FileLock(self.index_path):
             idx = {"schema": SCHEMA, "nodes": {}, "buckets": {}}
+            scan_fallback = False
             if os.path.exists(self.index_path):
                 try:
                     with open(self.index_path, encoding="utf-8") as f:
                         d = json.load(f)
                     if d.get("schema") == SCHEMA:
                         idx = d
+                    else:
+                        scan_fallback = True      # schema 不符：视同损坏
                 except (ValueError, OSError):
-                    pass
-            for rec in ShardedLog.read_all(self.index_log_dir):
-                nid, e = rec.get("id"), rec.get("e")
-                if not nid:
-                    continue
-                if e is None:              # 删除记录（tombstone），见 _load_index
-                    idx["nodes"].pop(nid, None)
-                else:
-                    idx["nodes"][nid] = e
+                    scan_fallback = True          # 损坏：不得拿空骨架覆盖
+            if scan_fallback:
+                # 快照损坏/schema 不符 → 降级全库扫描重建基底（宁重扫勿清池）。
+                # close 自动 compact（issue #33）上生产路径后此防御必须：
+                # 空骨架 + 增量日志会写出丢失全部历史节点的快照，而
+                # _load_index 见快照即不扫目录——池子从此不可见。
+                idx = {"schema": SCHEMA, "nodes": self._scan_nodes(),
+                       "buckets": {}}
+
+            def _apply_log(nodes):
+                for rec in ShardedLog.read_all(self.index_log_dir):
+                    nid, e = rec.get("id"), rec.get("e")
+                    if not nid:
+                        continue
+                    if e is None:              # 删除记录（tombstone），见 _load_index
+                        nodes.pop(nid, None)
+                    else:
+                        nodes[nid] = e
+                return nodes
+
+            _apply_log(idx["nodes"])
+            if not scan_fallback and self._count_md_files() != len(idx["nodes"]):
+                # 计数对账（issue #33）：快照+日志账本与盘面不符——其它存活
+                # 实例未 flush 的写入（文件已落盘、索引增量还在其 _dirty）
+                # 或外部增删文件。宁重扫勿写缺账快照：缺账快照会被重开
+                # 路径的指纹校验放行，节点从此「在盘上但不可见」。
+                # 与 _load_index 的指纹兜底双保险：此处保快照**完整**，
+                # 指纹保快照**新鲜**。
+                idx = {"schema": SCHEMA,
+                       "nodes": _apply_log(self._scan_nodes()),
+                       "buckets": {}}
             idx["buckets"] = self._count_buckets(idx["nodes"])
+            idx["_fingerprint"] = self._dir_fingerprint()
             atomic_write(self.index_path, json.dumps(idx, ensure_ascii=False))
             ShardedLog.clear(self.index_log_dir)
         self.index = idx
+        # P1b-2：自己写了快照 → 主动刷新签名，防止后续读路径把自己的
+        # compact 误判为「他进程写入」而做一次无谓重载（自写自载循环）。
+        self._index_sig = self._index_signature()
         return idx
 
 # 生效条件：self._dirty 非空时才在 FileLock(index_path) 下（必要时新建 ShardedLog）逐条 append、清空 _dirty 并关闭分片句柄；self._dirty 为空时立即返回、不写任何记录；
@@ -875,23 +1156,117 @@ class MdCG:
                 self._log = ShardedLog(self.index_log_dir)
             for nid, e in self._dirty.items():
                 self._log.append({"id": nid, "e": e})
-            self._dirty = {}
+            self._dirty.clear()   # 保住 _DirtyDict 钩子（批次 23 D-4：不得换新 dict）
             # 写完立即关分片句柄：Windows 上「被本进程打开的文件」无法删除，
             # 若持有句柄，rebuild_index 的 ShardedLog.clear 会静默失败，已并进
             # 快照的旧记录被永久重放（旧条目反而覆盖新快照）。append 内部已
             # 每次 flush，句柄无需常驻；下一次 append 会按需重开。
             self._log.close()
 
-# 生效条件：随认知图对象生命周期结束调用、可重复；先 flush() 落未达 autoflush 阈值的脏索引（否则尾部写入虽在盘上但不可见），再关闭并置空日志句柄（句柄为假值时跳过关闭）；
+# 生效条件：随认知图对象生命周期结束调用、可重复；先 flush() 落未达 autoflush 阈值的脏索引（否则尾部写入虽在盘上但不可见），随后自动落快照（issue #33：快照存在 → compact_index 增量并入并清日志；快照不存在且 index["nodes"] 非空 → rebuild_index 全量建快照；空库不写快照；OSError/ValueError 静默吞掉——失败时增量日志仍在、重开可重放，close 是兜底路径不该再抛），最后关闭并置空日志句柄（句柄为假值时跳过关闭）；
     def close(self):
         # 先落脏索引再关句柄：否则未达 autoflush 阈值的尾部写入会永久丢失，
         # 已有 _index.json 的根重开时不会重扫目录，节点将「在盘上但不可见」。
         self.flush()
+        # 自动落快照（issue #33）：原 close 只 flush——「add→close」的库
+        # 永远没有快照（compact_index 曾是唯一增量写快照点且生产零调用），
+        # 每次重开都 _scan_nodes 全库逐文件解析（1500 池实测 ~104ms/次）
+        # + 无条件重放全部增量日志（在扫描基底上纯冗余）。close 是一次性
+        # 脚本（review_cli 等）与 MCP server 退出的统一优雅收尾点：
+        # · 有快照 → compact（快照+日志=全量账本，增量并入+清日志）；
+        # · 无快照但有节点 → rebuild 全量建快照（历史节点可能无日志记录，
+        #   重放拼不出全量，必须扫一次盘面——本次一次，此后重开零扫描）；
+        # · 空库不写（不产生空快照文件，保持原行为）。
+        # 失败静默：与 atexit 兜底吞异常同风格；compact 失败时增量日志
+        # 仍在，重开照常重放，语义退回改动前而不会丢数据。
+        try:
+            if os.path.exists(self.index_path):
+                self.compact_index()
+            elif self.index["nodes"]:
+                self.rebuild_index()
+        except (OSError, ValueError):
+            pass
         if self._log:
             self._log.close()
             self._log = None
 
-# 生效条件：遍历模块级 LAYERS 各层目录下所有 .md 文件，读取抛 OSError 的跳过；nid 取 fm.get("id")，为假值时回落去掉 .md 的文件名；bucket 取父目录名、父目录等于层名时为 None；返回 nodes；
+# 生效条件：以节点文件绝对路径 p、其所在层目录名 layer、解析出的 fm 与 content 为入参，构造含 path（相对 root 正斜杠）/layer（fm 回落 layer）/role/content_kind/session/tags/bucket（父目录名，等于层名时 None）/bucket_zh/importance/created_at/verification_basis/has_neg_conditions/content_hash/temporal/spatial/time_window/lifecycle 与 trust 状态字段/branch_id/branched_from/evidence_count/big_domain/observation_position/subgraph/edges/protected/protection_reason/immutable/self_state/derived_from/derived_relation 各键的条目，经 _strip_empty_gate_fields 清洗后返回；
+    def _node_entry(self, p, layer, fm, content):
+        """单节点索引条目——_scan_nodes 与定向 upsert 共用的**唯一真源**。
+
+        issue #34：merge 裁决从 rebuild_index（O(N) 全库扫描）收尾改为
+        定向 upsert（O(1)）后，单文件条目构造必须与全量扫描**同源**，
+        否则 upsert 与 rebuild 两条路径的字段集漂移（重建前后索引形态
+        不一致）。提取本方法即为此——_scan_nodes 循环体与 merge 的
+        upsert 都调它，字段口径零漂移由构造保证。
+        """
+        rel = os.path.relpath(p, self.root).replace("\\", "/")
+        parent = os.path.basename(os.path.dirname(p))
+        return _strip_empty_gate_fields({
+            "path": rel, "layer": fm.get("layer", layer),
+            # role 必须回填：它写在节点 frontmatter 里（写入时 role or "user"），
+            # 但索引重建时若不复制，os.roles 会全部退化为 (none)，
+            # 来源归因打分随之失效（实测 48 条全丢）。
+            "role": fm.get("role"),
+            # content_kind 入快照：角色化读取视图（第四阶段 6.1）的
+            # 候选资格维度须免读文件可判（与 role 同款理由）。
+            # 纯增量键：批次 C 之前零消费方，view=None 零行为变更。
+            "content_kind": fm.get("content_kind"),
+            # 会话归属入快照（P45 归因维度）：写入路径 _stage 早已带出
+            # 该键，重建路径若漏掉，rebuild_index() 之后「按会话过滤」
+            # 即静默全空——快照与 _stage 必须同口径（与 role 同款理由）。
+            "session": fm.get("session"),
+            "tags": fm.get("tags", []),
+            "bucket": parent if parent != layer else None,
+            # issue #33：中文别名入快照（fm 派生，与写入路径同口径）——
+            # S1b 跨语言收敛免读文件可判。
+            "bucket_zh": fm.get("bucket_zh") or None,
+            "importance": fm.get("importance", 0.5),
+            "created_at": fm.get("created_at", 0),
+            "verification_basis": fm.get("verification_basis"),
+            "has_neg_conditions": nodefile.has_non_applicable(content),
+            # 内容指纹走 nodefile 的唯一实现（两段式对账依赖同一算法）
+            "content_hash": nodefile.content_hash(content),
+            # 时空字段入索引快照：STG 查询免读文件（大域/目录索引的延伸）
+            "temporal": fm.get("temporal"),
+            "spatial": fm.get("spatial"),
+            "time_window": (fm.get("condition_space") or {}).get("time_window"),
+            # 生命周期状态（② 显式状态机）：索引入快照 → 免读文件可查，
+            # 写入路径也因此无需读盘就能校验迁移合法性。重建口径与
+            # _stage 一致（旧库无该字段 → None → state_of 视为 active）。
+            lifecycle.STATE_FIELD: fm.get(lifecycle.STATE_FIELD),
+            # 可验证记忆单元（trust）：重建口径与 _stage 三件同源
+            # （验证态 / 依赖 / 双时间轴）——索引缺键即免读文件不可判。
+            trust.STATE_FIELD: fm.get(trust.STATE_FIELD),
+            trust.DEPS_FIELD: fm.get(trust.DEPS_FIELD),
+            trust.FROM_FIELD: fm.get(trust.FROM_FIELD),
+            trust.UNTIL_FIELD: fm.get(trust.UNTIL_FIELD),
+            # 规范时间轴键（2026-09-19 阶段一）：与 _stage 同口径，
+            # 重建索引后新旧口径一致（检索面 validity 须免读盘可判）。
+            trust.EFFECTIVE_FROM_FIELD: fm.get(trust.EFFECTIVE_FROM_FIELD),
+            trust.EFFECTIVE_UNTIL_FIELD: fm.get(trust.EFFECTIVE_UNTIL_FIELD),
+            # 记忆演化分支（④）：重建口径与 _stage 一致
+            "branch_id": fm.get("branch_id"),
+            "branched_from": fm.get("branched_from"),
+            "evidence_count": fm.get("evidence_count", 0),
+            # S1 大域先验：域标签入索引快照 → 候选收敛零读文件（与 add() 同口径）
+            "big_domain": fm.get("big_domain"),
+            # S2 条件门控所需的可判定硬槽（免读文件即可门控）
+            "observation_position": (fm.get("condition_space") or {}).get("observation_position"),
+            # 嵌套子图 / 关系边入索引快照：递归展开与链式遍历免读文件
+            "subgraph": fm.get("subgraph"),
+            "edges": fm.get("edges") or [],
+            "protected": fm.get("protected"),
+            "protection_reason": fm.get("protection_reason"),
+            "immutable": fm.get("immutable"),
+            # 自我状态卡标记：protect 据此豁免「不可覆盖」（仍不可遗忘）
+            "self_state": fm.get("self_state"),
+            # G8 派生溯源：frontmatter 声明入索引 → 悬空巡检零读文件
+            "derived_from": fm.get("derived_from") or [],
+            "derived_relation": fm.get("derived_relation"),
+                    })
+
+# 生效条件：遍历模块级 LAYERS 各层目录下所有 .md 文件，读取抛 OSError 的跳过；nid 取 fm.get("id")，为假值时回落去掉 .md 的文件名；条目经 self._node_entry(p, layer, fm, content) 构造；返回按 nid 排序的 nodes；
     def _scan_nodes(self):
         nodes = {}
         for layer in LAYERS:
@@ -904,92 +1279,56 @@ class MdCG:
                     try:
                         with open(p, encoding="utf-8") as f:
                             fm, content = nodefile.loads(f.read())
-                    except OSError:
+                    except (OSError, UnicodeDecodeError):
+                        # UnicodeDecodeError（批次 53 补）：非 UTF-8 字节的损坏
+                        # 真源此前会炸穿整库装载/重建（init → _load_index →
+                        # 指纹失配回落 _scan_nodes → 一个坏文件全库打不开）。
+                        # 与 reconcile v0 的 T9 边界同口径：真源损坏只跳过，
+                        # 不猜测不放大——启动对账（reconcile_state）会对其
+                        # 告警留痕。
                         continue
                     nid = fm.get("id") or fn[:-3]
-                    rel = os.path.relpath(p, self.root).replace("\\", "/")
-                    parent = os.path.basename(dirpath)
-                    nodes[nid] = _strip_empty_gate_fields({
-                        "path": rel, "layer": fm.get("layer", layer),
-                        # role 必须回填：它写在节点 frontmatter 里（写入时 role or "user"），
-                        # 但索引重建时若不复制，os.roles 会全部退化为 (none)，
-                        # 来源归因打分随之失效（实测 48 条全丢）。
-                        "role": fm.get("role"),
-                        # content_kind 入快照：角色化读取视图（第四阶段 6.1）的
-                        # 候选资格维度须免读文件可判（与 role 同款理由）。
-                        # 纯增量键：批次 C 之前零消费方，view=None 零行为变更。
-                        "content_kind": fm.get("content_kind"),
-                        # 会话归属入快照（P45 归因维度）：写入路径 _stage 早已带出
-                        # 该键，重建路径若漏掉，rebuild_index() 之后「按会话过滤」
-                        # 即静默全空——快照与 _stage 必须同口径（与 role 同款理由）。
-                        "session": fm.get("session"),
-                        "tags": fm.get("tags", []),
-                        "bucket": parent if parent != layer else None,
-                        "importance": fm.get("importance", 0.5),
-                        "created_at": fm.get("created_at", 0),
-                        "verification_basis": fm.get("verification_basis"),
-                        "has_neg_conditions": nodefile.has_non_applicable(content),
-                        # 内容指纹走 nodefile 的唯一实现（两段式对账依赖同一算法）
-                        "content_hash": nodefile.content_hash(content),
-                        # 时空字段入索引快照：STG 查询免读文件（大域/目录索引的延伸）
-                        "temporal": fm.get("temporal"),
-                        "spatial": fm.get("spatial"),
-                        "time_window": (fm.get("condition_space") or {}).get("time_window"),
-                        # 生命周期状态（② 显式状态机）：索引入快照 → 免读文件可查，
-                        # 写入路径也因此无需读盘就能校验迁移合法性。重建口径与
-                        # _stage 一致（旧库无该字段 → None → state_of 视为 active）。
-                        lifecycle.STATE_FIELD: fm.get(lifecycle.STATE_FIELD),
-                        # 可验证记忆单元（trust）：重建口径与 _stage 三件同源
-                        # （验证态 / 依赖 / 双时间轴）——索引缺键即免读文件不可判。
-                        trust.STATE_FIELD: fm.get(trust.STATE_FIELD),
-                        trust.DEPS_FIELD: fm.get(trust.DEPS_FIELD),
-                        trust.FROM_FIELD: fm.get(trust.FROM_FIELD),
-                        trust.UNTIL_FIELD: fm.get(trust.UNTIL_FIELD),
-                        # 规范时间轴键（2026-09-19 阶段一）：与 _stage 同口径，
-                        # 重建索引后新旧口径一致（检索面 validity 须免读盘可判）。
-                        trust.EFFECTIVE_FROM_FIELD: fm.get(trust.EFFECTIVE_FROM_FIELD),
-                        trust.EFFECTIVE_UNTIL_FIELD: fm.get(trust.EFFECTIVE_UNTIL_FIELD),
-                        # 记忆演化分支（④）：重建口径与 _stage 一致
-                        "branch_id": fm.get("branch_id"),
-                        "branched_from": fm.get("branched_from"),
-                        "evidence_count": fm.get("evidence_count", 0),
-                        # S1 大域先验：域标签入索引快照 → 候选收敛零读文件（与 add() 同口径）
-                        "big_domain": fm.get("big_domain"),
-                        # S2 条件门控所需的可判定硬槽（免读文件即可门控）
-                        "observation_position": (fm.get("condition_space") or {}).get("observation_position"),
-                        # 嵌套子图 / 关系边入索引快照：递归展开与链式遍历免读文件
-                        "subgraph": fm.get("subgraph"),
-                        "edges": fm.get("edges") or [],
-                        "protected": fm.get("protected"),
-                        "protection_reason": fm.get("protection_reason"),
-                        "immutable": fm.get("immutable"),
-                        # 自我状态卡标记：protect 据此豁免「不可覆盖」（仍不可遗忘）
-                        "self_state": fm.get("self_state"),
-                        # G8 派生溯源：frontmatter 声明入索引 → 悬空巡检零读文件
-                        "derived_from": fm.get("derived_from") or [],
-                        "derived_relation": fm.get("derived_relation"),
-                    })
+                    nodes[nid] = self._node_entry(p, layer, fm, content)
         # 索引序确定性：按 nid 排序返回。os.walk 的遍历序是**文件系统事实**
         # （NTFS 上常为字母序，但换 FS / 目录碎片化后不保证），若直接作为
         # index["nodes"] 的物理序，就会让「完全并列」的结果顺序依赖重建路径。
         # 排序后重建序恒定（增量路径另由 cut_by_relevance 的 nid 终键兜住）。
         return {k: nodes[k] for k in sorted(nodes)}
 
-# 生效条件：每次调用都以 self._scan_nodes() 的结果重建 nodes 与 buckets，在 FileLock 下 atomic_write 覆盖 index_path 并 ShardedLog.clear(index_log_dir)，随后替换 self.index、清空 _dirty 并返回 idx（无 .md 时也照样覆盖为空索引）；
+# 生效条件：每次调用都以 self._scan_nodes() 的结果重建 nodes 与 buckets 并附 _dir_fingerprint()，在 FileLock 下 atomic_write 覆盖 index_path 并 ShardedLog.clear(index_log_dir)，随后替换 self.index、刷新 _index.json 签名（P1b-2 自写不自载）、清空 _dirty 并返回 idx（无 .md 时也照样覆盖为空索引）；
     def rebuild_index(self):
         nodes = self._scan_nodes()
         idx = {"schema": SCHEMA, "nodes": nodes,
                "buckets": self._count_buckets(nodes)}
         with FileLock(self.index_path):
+            idx["_fingerprint"] = self._dir_fingerprint()
             atomic_write(self.index_path, json.dumps(idx, ensure_ascii=False))
             ShardedLog.clear(self.index_log_dir)
         self.index = idx
-        self._dirty = {}
+        # P1b-2：rebuild 同 compact——写完快照即刷新签名（自写不自载）。
+        self._index_sig = self._index_signature()
+        # broad=True：rebuild 以盘面扫描为准——ccgc/crosscheck/backfill 等
+        # 「直写文件 + rebuild 收尾」的写方不经 _dirty 标脏，其文件改写对
+        # 读缓存的可见性靠这一整池失效兜底（flush 的 clear 则不失效，见
+        # _DirtyDict.clear 文档串）。
+        self._dirty.clear(broad=True)  # 保住 _DirtyDict 钩子（批次 23 D-4）
         return idx
 
+    # P2-20（批次 30，外部审查报告）：索引中的 path 参与所有读/写落盘定位
+    # ——写穿越（P0-1 历史节点/索引污染）可经「读穿越」放大。单点校验：
+    # realpath 必须落在 root 内，越界抛 ValueError（宁可少读，不可越权）。
+    def _node_disk_path(self, e):
+        p = os.path.realpath(os.path.join(self.root, e.get("path") or ""))
+        rr = os.path.realpath(self.root)
+        if p != rr and not p.startswith(rr + os.sep):
+            raise ValueError(
+                f"节点路径越界（P2-20）：{e.get('path')!r} -> {p}"
+                "——拒绝读写")
+        return p
+
     # ---------- 写 ----------
 
-# 生效条件：node_id/content 必填，layer 不在 LAYERS 内、或 verification_basis 非 None 且不在 VERIFICATION_BASIS 内时抛 ValueError；consistency 为真且 _cons.check 判 REJECT 时，on_conflict="reject" 抛 ConsistencyError、on_conflict="defer" 返回 None，verdict 为 BLINDSPOT 且 on_conflict="defer" 同样返回 None，其余情形完成写盘/入索引后返回 node_id。
+# 生效条件：node_id/content 必填；node_id 不匹配 _NODE_ID_RE（^[A-Za-z0-9_.@-]{1,128}$）或含 ".."、或整串精确等值于 _NODE_ID_FORBIDDEN（"None"/"null"，空语义值字符串化污染形态，P3 None.md 缺陷禁写）、或落盘 realpath 越出 self.root 时抛 ValueError（P0-1 白名单+纵深闸）；layer 不在 LAYERS 内、或 verification_basis 非 None 且不在 VERIFICATION_BASIS 内时抛 ValueError；consistency 为真且 _cons.check 判 REJECT 时，on_conflict="reject" 抛 ConsistencyError、on_conflict="defer" 返回 None，verdict 为 BLINDSPOT 且 on_conflict="defer" 同样返回 None，其余情形完成写盘/入索引后返回 node_id。
     def add(self, node_id: str, content: str, layer: str = "knowledge",
             tags=None, condition_space=None, importance: float = 0.5,
             confidence: float = 0.6, edges=None, verification_basis: str = None,
@@ -1038,6 +1377,21 @@ class MdCG:
         """
         if layer not in LAYERS:
             raise ValueError(f"未知层：{layer}（允许：{LAYERS}）")
+        # P0-1（批次 24，外部审查报告）：node_id 是模型可控输入，直接拼
+        # 文件路径——`..` 穿越出 root、Windows 绝对路径（C:/x）在
+        # os.path.join 下直接丢弃前缀 = 任意 .md 覆盖。白名单先行
+        # （报告建议 1），realpath 断言在落盘前兜底（报告建议 2）。
+        nid_s = str(node_id or "")
+        if not nid_s or len(nid_s) > 128 or ".." in nid_s \
+                or not _NODE_ID_RE.match(nid_s):
+            raise ValueError(
+                f"非法 node_id：{node_id!r}（须匹配 {_NODE_ID_RE.pattern} "
+                f"且不含 '..'——node_id 会拼进落盘路径，穿越/绝对路径一律拒绝）")
+        if nid_s in _NODE_ID_FORBIDDEN:
+            raise ValueError(
+                f"非法 node_id：{node_id!r}（空语义值的字符串化污染形态 "
+                f"{sorted(_NODE_ID_FORBIDDEN)} 禁写——会落盘成 None.md 参与检索"
+                f"（DSH 在役库实测缺陷 P3）；fail-closed，如为合法业务 id 请改名）")
         if verification_basis is not None and verification_basis not in VERIFICATION_BASIS:
             raise ValueError(f"未知验证基底：{verification_basis}（允许：{VERIFICATION_BASIS}）")
         # 写保护：self/anchor 层、protected 标记、importance≥0.7 的**既有**节点
@@ -1073,13 +1427,48 @@ class MdCG:
                     extra["semantic_oov"] = _oov
             except Exception:
                 pass
+        # 桶路由键必须在**选目录之前**补齐：`routing.route_key()` 只认 tags 里的
+        # `domain:` 前缀（其次才是 condition_space.observation_position），**不读
+        # big_domain**；而 bucket 与落盘目录在这一段就定死了（索引的 bucket 同样由
+        # 父目录名派生）。实测：把补标签放在 fm 构造之后（原 W1 的位置）会导致
+        # big_domain 与 domain: 标签都在、但文件仍写进 knowledge/orphan/。
+        # 只对分桶层补标签（BUCKETED_LAYERS=("knowledge",)），避免污染其它层的 tags。
+        if (layer in BUCKETED_LAYERS
+                and os.environ.get("MDCG_RETRIEVAL_PIPELINE") == "1"
+                and not any(str(t).startswith("domain:")
+                            for t in (tags or []))):
+            _bd_pre = extra.get("big_domain") or None
+            if not _bd_pre:
+                try:
+                    _bd_pre = routing.classify_text(content)
+                except Exception:
+                    _bd_pre = None
+            if _bd_pre:
+                tags = list(tags or [])
+                tags.append("domain:" + str(_bd_pre))
         bucket = None
         d = os.path.join(self.root, layer)
+        bucket_zh = []
         if layer in BUCKETED_LAYERS:
             bucket = routing.bucket_dir(routing.route_key(condition_space, tags))
             d = os.path.join(d, bucket)
+            # issue #33：英文桶键配中文别名（节点自身 tags/正文中文词，零翻译依赖），
+            # 供 S1b 跨语言收敛；键含中文或无别名时空。写进 fm 保证 _scan_nodes
+            # 重建后口径一致（索引派生原则，见 _stage 注释）。
+            bucket_zh = routing.bucket_zh_aliases(
+                routing.bucket_key_readable(bucket), tags, content)
         os.makedirs(d, exist_ok=True)
         path = os.path.join(d, f"{node_id}.md")
+        # P0-1 纵深（批次 24）：realpath 断言兜底——白名单已挡穿越/绝对
+        # 路径，此闸防未来 node_id 规则放松或 d 被污染（任何写入路径的
+        # 最后一道闸：落盘位置必须在 root 内）。
+        _real_node = os.path.realpath(path)
+        _real_root = os.path.realpath(self.root)
+        if _real_node != _real_root \
+                and not _real_node.startswith(_real_root + os.sep):
+            raise ValueError(
+                f"node_id 落盘路径越界（realpath={_real_node}，root={_real_root}）"
+                "——拒绝写入（P0-1 纵深闸）")
         created_at = extra.pop("created_at", time.time())
         # 条件论「观测时间」栏：写入时必须记录观测时间窗。
         # 调用方未提供 time_window 时，以写入时刻为锚、默认窗口 OBSERVATION_WINDOW_SEC。
@@ -1100,6 +1489,8 @@ class MdCG:
             "evidence_count": 0, "positive_evidence": 0, "negative_evidence": 0,
         }
         fm.update(extra)
+        if bucket_zh:
+            fm["bucket_zh"] = bucket_zh
         # S1 大域先验：写入时固化「内容 → 大域」（契约 §3 S1）。
         # 为何在写入侧：检索侧要按域收敛，节点就必须带域；query 侧分类器已存在，
         # 缺的只是这一列节点元数据（审计偏差 4 的根因）。调用方可显式传入覆盖。
@@ -1113,6 +1504,21 @@ class MdCG:
                 _bd = None
             if _bd:
                 fm["big_domain"] = _bd
+        # CCG「不适用条件」写入口径：正文声明了 `# 不适用条件：` 而调用方没给列表时，
+        # 按 ccgc 的同一拆分口径（[；;]）结构化进 frontmatter。否则 has_non_applicable()
+        # （按正文文本判，health 的 neg_conditions_set 用它）与 non_applicable_conditions
+        # （judge_qualification 的 REJECT 路径用它）会长期脱钩——实测历史数据修好后
+        # 新写入节点立刻复现（1/73）。正文里字面 `…` 是写入期截断尾巴，按占位丢弃。
+        if not fm.get("non_applicable_conditions"):
+            _na_line = nodefile.ccg_field_value(content, "不适用条件")
+            if _na_line:
+                _na_vals = [s.strip() for s in re.split(r"[；;]", _na_line) if s.strip()]
+                _na_vals = [re.sub(r"[.．…\s，,；;、]+$", "", v).strip()
+                            for v in _na_vals]
+                _na_vals = [v for v in _na_vals
+                            if v and not nodefile.is_placeholder_text(v)]
+                if _na_vals:
+                    fm["non_applicable_conditions"] = _na_vals
         # 生命周期状态（② 显式状态机，真源 `lifecycle.py`）：add 是**全量重建
         # fm** 而非增量更新，故必须显式处理状态——否则已定型/已降权节点会被静默
         # 打回 active（与 ④ rewrite 必须重传 branch_id 同构的坑）。口径：
@@ -1270,9 +1676,34 @@ class MdCG:
         # 私有内容封装（默认恒等；MdCGSecure 覆盖为 AEAD 加密）。
         # 索引派生同样基于落盘内容，保证与 _scan_nodes 重建结果一致。
         sealed = self._write_node(node_id, path, fm, content)
+        # 覆写且路由键变化时清理旧桶同 id 文件：不清理则磁盘留双文件，
+        # rebuild_index() 后索引取哪个取决于 os.walk 枚举序——新内容可能被
+        # 旧文件静默顶掉（违背「原文即真源」）。旧索引条目即旧路径唯一线索；
+        # 双闸防误删：必须在 root 内（P2-20 同口径）且不等于本次新路径
+        # （同桶覆写是同一文件，删了等于自毁）。先写新后删旧，顺序不可倒。
+        if prev_entry and prev_entry.get("path"):
+            try:
+                _old_real = os.path.realpath(
+                    os.path.join(self.root, prev_entry["path"]))
+                if _old_real != _real_node \
+                        and _old_real.startswith(_real_root + os.sep) \
+                        and os.path.isfile(_old_real):
+                    os.remove(_old_real)
+            except OSError:
+                pass  # 删除失败不阻断主写路径（残留双文件退回旧行为，可重建兜底）
+            # 旧桶计数递减（与 _unstage 同口径），否则 buckets 计数漂移；
+            # 仅在桶变化时做——同桶覆写的 _stage 自增是既有口径，不在此对账。
+            _ob = prev_entry.get("bucket")
+            if _ob and _ob != bucket:
+                _left = self.index["buckets"].get(_ob, 1) - 1
+                if _left > 0:
+                    self.index["buckets"][_ob] = _left
+                else:
+                    self.index["buckets"].pop(_ob, None)
         self._stage(node_id, _strip_empty_gate_fields({
             "path": os.path.relpath(path, self.root).replace("\\", "/"),
             "layer": layer, "tags": tags, "bucket": bucket,
+            "bucket_zh": bucket_zh or None,
             "importance": importance, "created_at": fm["created_at"],
             "verification_basis": verification_basis,
             "has_neg_conditions": nodefile.has_non_applicable(sealed),
@@ -1376,6 +1807,18 @@ class MdCG:
         from . import twophase
         return twophase.pending(self, limit=limit)
 
+# 生效条件：每次调用都延迟导入 reconcile 并以原样 apply（含 False）转调 reconcile.reconcile_state(self, apply=apply) 并返回，自身不做参数回落；
+    def reconcile_state(self, apply: bool = True) -> dict:
+        """启动对账 reconcile v0（v0.3 T9 落地，落地清单 P0-3）：索引（派生
+        态）vs 盘面真源的三类 diff 对账（多/缺索引条目、内容哈希漂移）。
+
+        与 `reconcile_writes`（写账本清账）分工见 `md_cg/reconcile.py` 模块
+        文档串。`MDCG_RECONCILE=0` 关闭（缺省开，开关真源在 reconcile.enabled）；
+        `apply=False` 为 dry-run。真源自身损坏只告警留痕，不自动改写（T9 边界）。
+        """
+        from . import reconcile              # 延迟导入：与写路径解耦，避免模块环
+        return reconcile.reconcile_state(self, apply=apply)
+
     # ------------------------------------------------------------------
     # 边域窄原语（写路径收口：白箱工具写 md 真源的唯一正路）。
     #
@@ -1608,6 +2051,7 @@ class MdCG:
 # 生效条件：遍历 self.index["nodes"] 中 layer=="goals" 的节点，_goal_entry 取不到者跳过；status 为假值时不过滤、否则仅保留 status 相等者；按 (-priority, -created_at) 降序，limit 为真值时截断 out[:limit]，否则返回全量；
     def list_goals(self, status=None, limit=None):
         """列出目标，按 (priority, created_at) 降序。status 过滤 active/done/dropped。"""
+        self._maybe_reload_index()      # P1b-2：读面代际感知（goal=list/active 链）
         out = []
         for nid, e in self.index["nodes"].items():
             if e.get("layer") != "goals":
@@ -1626,7 +2070,7 @@ class MdCG:
         """当前活跃目标（默认最多 5 条）——检索定向的默认来源。"""
         return self.list_goals(status="active", limit=limit)
 
-# 生效条件：status 不属于模块级 GOAL_STATUSES 时抛 ValueError；self.get(node_id) 取不到节点或其 frontmatter 的 layer 不等于 "goals" 时返回 None；否则写回 goal_status 与 status_changed_at 并返回 {"id": node_id, "status": status}；
+# 生效条件：status 不属于模块级 GOAL_STATUSES 时抛 ValueError；self.get(node_id) 取不到节点或其 frontmatter 的 layer 不等于 "goals" 时返回 None；否则写回 goal_status 与 status_changed_at，置 self._dirty[node_id]（读缓存代际失效，entry 取 index["nodes"] 现值或 {"path","layer":"goals"} 兜底）并返回 {"id": node_id, "status": status}；
     def set_goal_status(self, node_id: str, status: str):
         """目标状态机：active → done/dropped（可回退）。"""
         if status not in GOAL_STATUSES:
@@ -1639,6 +2083,12 @@ class MdCG:
         fm["status_changed_at"] = time.time()
         self._write_node(node_id, os.path.join(self.root, node["path"]),
                          fm, node["content"])
+        # 标脏（读缓存代际哨兵前提：写路径必须推进 write_gen——直写不标脏
+        # 会让同实例 _goal_entry/检索读到旧 goal_status，p7「done 退出
+        # active」陈旧形态）。不走 _stage：节点已在索引，_stage 会虚增
+        # bucket 计数；这里只推代际，entry 同值幂等。
+        self._dirty[node_id] = self.index["nodes"].get(node_id) \
+            or {"path": node["path"], "layer": "goals"}
         return {"id": node_id, "status": status}
 
 # 生效条件：goal 为真值（非 None/空串/0）时返回 str(goal)；goal 为假值时返回 self.active_goals(limit=limit) 中非空 goal 文本以空格拼接的字符串；
@@ -1801,7 +2251,7 @@ class MdCG:
                 st["written"] += 1
                 continue
             fm["big_domain"] = dom
-            self._write_node(nid, os.path.join(self.root, e["path"]), fm, content)
+            self._write_node(nid, self._node_disk_path(e), fm, content)
             e["big_domain"] = dom
             # 必须走 _stage：索引持久化靠 _dirty → flush → _index_log 重放，
             # 只改内存 entry 会在重启后丢掉标签（S1 失效，且二次回填因 fm 已有标签而跳过）
@@ -1813,14 +2263,64 @@ class MdCG:
             self.flush()
         return st
 
+# 生效条件：遍历 index["nodes"]（limit 截断）；bucket 缺失/orphan/键含中文或可读键为空时计 not_needed 跳过；索引已有 bucket_zh 计 already；get() 不可读计 unreadable；别名=routing.bucket_zh_aliases(可读键, tags, content)（fm 已有则沿用）为空计 not_needed；dry_run 只计 written 不落盘，否则写 fm.bucket_zh + _write_node + _stage(e)（不动 content/其它字段），最终有写入即 flush，返回统计 dict。
+    def backfill_bucket_zh(self, dry_run: bool = False, limit: int = None) -> dict:
+        """为英文桶键的存量节点补中文别名（issue #33；幂等、零翻译依赖）。
+
+        别名与写入侧同源（`routing.bucket_zh_aliases`：节点自身 tags ∪ 正文
+        中文域词）；只补 `fm.bucket_zh` 与索引快照，不动 content/条件空间；
+        加密库走 get() → _write_node() 重封装安全路径（同 backfill_big_domain）。
+        无中文面可用的节点跳过——其在 S1b 的 cross_lang_no_match 审计里可见。
+        """
+        st = {"seen": 0, "already": 0, "written": 0, "not_needed": 0,
+              "unreadable": 0, "dry_run": bool(dry_run)}
+        for nid, e in list((self.index.get("nodes") or {}).items()):
+            if limit and st["written"] >= limit:
+                break
+            st["seen"] += 1
+            b = e.get("bucket")
+            if not b or b == routing.ORPHAN:
+                st["not_needed"] += 1
+                continue
+            kk = routing.bucket_key_readable(b)
+            if not kk or routing._ZH_RE.search(kk):
+                st["not_needed"] += 1       # 中文键无跨语言问题
+                continue
+            if e.get("bucket_zh"):
+                st["already"] += 1
+                continue
+            got = self.get(nid)
+            if not got or got.get("content") is None:
+                st["unreadable"] += 1
+                continue
+            fm, content = got["frontmatter"], got["content"]
+            aliases = fm.get("bucket_zh") or routing.bucket_zh_aliases(
+                kk, fm.get("tags") or e.get("tags"), content)
+            if not aliases:
+                st["not_needed"] += 1       # 无中文面（cross_lang 审计兜底）
+                continue
+            if dry_run:
+                st["written"] += 1
+                continue
+            fm["bucket_zh"] = aliases
+            self._write_node(nid, self._node_disk_path(e),
+                             fm, content)
+            e["bucket_zh"] = aliases
+            self._stage(nid, e)
+            st["written"] += 1
+        if not dry_run and st["written"]:
+            self.flush()
+        return st
+
     # ---------- 读 ----------
 
 # 生效条件：index["nodes"].get(node_id) 为假值时回落 self._dirty.get(node_id)，仍为假值返回 None；打开 root 下 e["path"] 抛 OSError 返回 None；_open_content 返回 None（无密钥/身份不符）返回 None；否则返回 {id, frontmatter, content, path}；
     def get(self, node_id: str):
+        self._maybe_reload_index()      # P1b-2：读面代际感知（他进程写快照后可见）
         e = self.index["nodes"].get(node_id) or self._dirty.get(node_id)
         if not e:
             return None
-        p = os.path.join(self.root, e["path"])
+        p = self._node_disk_path(e)
         try:
             with open(p, encoding="utf-8") as f:
                 fm, content = nodefile.loads(f.read())
@@ -1831,9 +2331,12 @@ class MdCG:
             return None                     # 有节点但无密钥 → 不可读即不存在
         return {"id": node_id, "frontmatter": fm, "content": content, "path": e["path"]}
 
-# 生效条件：打开 os.path.join(self.root, entry["path"]) 成功时返回 nodefile.loads 的 (fm, content)；抛 OSError 时返回 (None, None)（entry 的 "path" 按源码直接取键，无 .get 回落）；
+# 生效条件：经 _node_disk_path(entry) 定位（P2-20 越界抛 ValueError → 返回 (None, None)，不可读即不存在——索引被污染时不得绕过统一校验读 root 外文件，2026-09-25 缺陷 #4），打开成功时返回 nodefile.loads 的 (fm, content)；抛 OSError 时同样返回 (None, None)；
     def _read(self, entry):
-        p = os.path.join(self.root, entry["path"])
+        try:
+            p = self._node_disk_path(entry)
+        except ValueError:
+            return None, None
         try:
             with open(p, encoding="utf-8") as f:
                 return nodefile.loads(f.read())
@@ -2017,6 +2520,7 @@ class MdCG:
         q = unify_query(q)
         if not q:
             return [], {"tier": None, "reason": "empty_query", "scanned": 0}
+        self._maybe_reload_index()      # P1b-2：读面代际感知（空查询早退后、读索引前）
         pool_cfg = pooling.resolve(pooling.from_env(pools))
         now = time.time() if validity else None      # 统一取一次 now，保判定口径一致
 
@@ -2027,8 +2531,14 @@ class MdCG:
         # 把 rejected/unresolved 视作可参与召回的特殊「候选池」
         # ——命中它们的结果会改变 meta 的 covered_neg（被负记忆覆盖的查询）
         # 默认排除掉负记忆层的节点进入正排打分，仅作为「覆盖标记」用
-        entries = [e for e in self.index["nodes"].values()
-                   if (not layer or e["layer"] == layer)
+        # P2-2（批次 31）：单次遍历双收集——负记忆层引用与正排候选
+        # 同车收集，消除此前的第二遍全索引遍历。
+        neg_layer_entries = []
+        entries = []
+        for e in self.index["nodes"].values():
+            if include_neg and e["layer"] in ("rejected", "unresolved"):
+                neg_layer_entries.append(e)
+            if ((not layer or e["layer"] == layer)
                    # '"*"' = 显式跨会话（读遍所有会话）；缺省 None 同义
                    and (not session or session == "*"
                         or e.get("session") == session)
@@ -2039,7 +2549,8 @@ class MdCG:
                    # （非法视图 ValueError——fail-closed 只针对调用方误用）
                    and (view is None or roleviews.matches(e, view))
                    # 时效：只在显式启用时排除已过期（not_yet 保留）
-                   and not (validity and trust.is_expired(e, now=now))]
+                   and not (validity and trust.is_expired(e, now=now))):
+                entries.append(e)
 
         # 默认关：索引里可能残留门控字段（曾开启过 / 回填过）→ 返回前剥离，
         # 保证候选 entry 形状与「从未启用过本功能」逐字节一致（独立复核 2026-09-19）。
@@ -2047,8 +2558,12 @@ class MdCG:
         if (os.environ.get("MDCG_RETRIEVAL_PIPELINE") != "1" and entries
                 and any(("big_domain" in e) or ("observation_position" in e)
                         for e in entries)):
-            entries = [_strip_empty_gate_fields(dict(e), enabled=False)
-                       for e in entries]
+            # P2-3（批次 31）/ V21-5（批次 34，外部报告定案）：**就地剥离**——
+            # entries 里的 e 与 index["nodes"] 是同一对象，_strip_empty_gate_fields
+            # 内部 del 直接落在索引条目上，天然自愈。批次 31 原写法 dict(e) 拷贝
+            # 后按不存在的 "id" 键回写 = 永久 no-op（残留每查都在）。
+            for e in entries:
+                _strip_empty_gate_fields(e, enabled=False)
 
         # ---- 时间算子（阶段二 4.1）：候选**资格**过滤（在 S1/S2 收敛之前）----
         # 与 validity 各司其职、互不替代：
@@ -2115,21 +2630,27 @@ class MdCG:
         # 负记忆覆盖：查询词是否已被否决议过
         neg_coverage = []
         if include_neg:
-            for e in self.index["nodes"].values():
-                if e["layer"] in ("rejected", "unresolved"):
-                    got = self.get(e["path"].split("/")[-1][:-3])
-                    # 用 path 末段作为 id 反查（_index 用 path，get 用 id）
-                    # 上面写法是错的；改用直接路径读
-                    full_path = os.path.join(self.root, e["path"])
-                    if not os.path.exists(full_path):
-                        continue
-                    try:
-                        with open(full_path, encoding="utf-8") as f:
-                            fm, content = nodefile.loads(f.read())
-                    except OSError:
-                        continue
-                    if any(t in content for t in terms):
-                        neg_coverage.append(e)
+            # P2-2：遍历第一轮同车收集的引用，不再全索引二遍
+            for e in neg_layer_entries:
+                if e["layer"] not in ("rejected", "unresolved"):
+                    continue
+                # _index 用 path 存，直接按 path 读盘（批次 24 P2-1：删除
+                # 原先的死调用 `got = self.get(...)`——结果从未使用却完成
+                # 一次完整读盘+解析+解密，每次检索对每个负记忆节点双倍 IO）。
+                # 批次 33 修复：P2-2 双收集重构时本段被整体缩进进 continue
+                # 之后（不可达死代码）——neg_coverage 恒空 → s5 负记忆抑制
+                # 全失效（test_retr_s5 8/17，Windows/Linux 同红；Docker Linux
+                # 验证暴露后主机复跑定案为既有回归，非平台差异）。
+                full_path = self._node_disk_path(e)
+                if not os.path.exists(full_path):
+                    continue
+                try:
+                    with open(full_path, encoding="utf-8") as f:
+                        fm, content = nodefile.loads(f.read())
+                except OSError:
+                    continue
+                if any(t in content for t in terms):
+                    neg_coverage.append(e)
 
         stat = {"scanned": 0, "query": q, "gates": gates}
         if _tf_audit:
@@ -2139,12 +2660,27 @@ class MdCG:
             ctx = context if isinstance(context, dict) else {}
             route_bucket = routing.bucket_dir(
                 routing.route_key(ctx, ctx.get("tags")))
+            # 「无域信号」等价于「没声明条件」：此时**不施加桶约束**。否则 route_key
+            # 回落的 orphan 会被当成一个真桶，下面 T0/T1 阶段只读该桶，并因
+            # valid >= min_results 在 TIER_BUCKET_SCAN 直接 return —— **全量阶梯
+            # 永不执行**，凡被标了 domain:（落在 cond_* 目录）的节点对这条查询
+            # 整片不可见。
+            # 实测（带 context 但不含 domain / observation_position）：置 None 前
+            # tier=T1_bucket_scan/scanned=10/目标召回丢失；置 None 后
+            # tier=T2_global_like/scanned=75/召回命中。
+            # 与 mdcos._path_bucket 的「无域信号弃权」（X1）同构，也贴合 test_p0
+            # 的「桶路由平均 recall@10 ≥ 0.9（加 context 不丢召回）」不变量。
+            if route_bucket == routing.ORPHAN:
+                route_bucket = None
 
         # 阶段 1 大域打分已在候选构建前算好（S1 门控要用）；此处不再重复计算。
 
 # 生效条件：docs 经 self._score(docs, q, qb, pool_cfg) 后分数 >0 的条数达到闭包阈值 min_results 时返回 self._emit(scored, k, tier, stat, route_bucket, record, len(docs), judge, context, neg_coverage, big_domain, big_scores, pool_cfg)（tier 原样透传）；未达阈值返回 None；
-        def try_stage(docs, tier):
-            scored = self._score(docs, q, qb, pool_cfg)
+        def try_stage(docs, tier, scored=None):
+            # P2-4（批次 31）：支持传入已打分结果（reach 分支复用，
+            # 免对同一批文档二次 _score）。
+            if scored is None:
+                scored = self._score(docs, q, qb, pool_cfg)
             valid = sum(1 for _, s in scored if s > 0)
             if valid >= min_results:
                 return self._emit(scored, k, tier, stat, route_bucket, record,
@@ -2191,11 +2727,27 @@ class MdCG:
             stat["cap"] = GLOBAL_CAP
             # 与 T2 **无条件**同序调用（不可按 cap 短路：cut_by_relevance 还会写
             # 池账 pool_taken/cands/lost，短路会让 meta.pools.taken 缺失 → test_p43(13) 红）
-            hits_r, _rep = cut_by_relevance(hits_r, self._score(hits_r, q, qb, pool_cfg),
+            # P2-4（批次 31）：打分结果经 pre_scored 传给 try_stage，
+            # 不再对同一 hits_r 二次 _score（报告 P2-4）。
+            scored_r = self._score(hits_r, q, qb, pool_cfg)
+            hits_r, _rep = cut_by_relevance(hits_r, scored_r,
                                             GLOBAL_CAP, pools=pool_cfg,
                                             key_of=pooling.doc_key, stat=stat)
             pooling.record_audit(stat, _rep)
-            out = try_stage(hits_r, TIER_GLOBAL_LIKE)
+            # V21-6（批次 34，外部报告定案）：doc_key 返回 (node_id, entry)，
+            # 第二元是 dict 不可哈希——整键作字典键 = TypeError 死代码。
+            # 取 [0]（node_id）作键。缺陷迭代第 14 轮修（两处形态错误，
+            # MDCG_REACH=1 实测 KeyError: 1 崩，stash 取证 HEAD 原生在位）：
+            # ① scored 元素是 (card, score)，card 是 dict——对它调 doc_key
+            #   （形参须 (entry, fm, content) 三元组）= KeyError: 1；按
+            #   card["id"]（与 doc_key(doc)[0] 同源同值）建键表；
+            # ② 键表须存 (card, score) 原对再按 hits_r 序取回——自组
+            #   (doc, score) 对会让 _emit 排序键 x[0]["frontmatter"] 崩
+            #   （x[0] 须是 card dict）。
+            _smap = {c.get("id"): (c, s) for c, s in scored_r}
+            out = try_stage(hits_r, TIER_GLOBAL_LIKE,
+                            scored=[_smap[pooling.doc_key(d)[0]]
+                                    for d in hits_r])
             if out:
                 return out
             # 收敛阶段未产出结果 → 继续走下方全量 T2/T3；此时必须**改写 reach 审计**，
@@ -2572,11 +3124,16 @@ class MdCG:
             out.append((r[0], r[1], qual))
         # 把被负记忆覆盖的查询也作为结果条目返回（首条），方便调用方感知
         for nc in neg_coverage[:3]:
-            full_path = os.path.join(self.root, nc["path"])
-            try:
-                with open(full_path, encoding="utf-8") as f:
-                    fm, content = nodefile.loads(f.read())
-            except OSError:
+            # v9 留档残余项修复（缺陷迭代第 14 轮）：改走 self._read——裸
+            # open+loads 不在读缓存包装面（install 只包 cg._read），每条命中
+            # 负层的查询恒 ≤3 次盘读（60+8 池实测 Q2 增量恰 3）；并入读缓存
+            # 后增量归零，负层主面 IO 早已同款覆盖（_neg_coverage → _read）。
+            # _read 同款 _node_disk_path 边界闸（P2-20：索引被污染时不得绕过
+            # 统一校验读 root 外文件）、OSError→(None,None) 与旧 continue 同义；
+            # 负层写路径（add/add_rejected→_stage 标脏带 path）在脏集精确
+            # 失效面内——覆写后尾部条目即时见新内容，不陈旧。
+            fm, content = self._read(nc)
+            if content is None:
                 continue
             entry = {"id": nc["path"], "frontmatter": fm,
                      "content": content, "path": nc["path"]}
@@ -2759,14 +3316,17 @@ class MdCG:
         return {"id": node_id, "from": from_layer, "to": to_layer,
                 "path": rel, "reason": reason}
 
-# 生效条件：verdict 不在 {confirmed,weakened,falsified} 时抛 ValueError；node_id 取不到节点返回 None；verdict=="falsified" 时以 content[:200] 为假设写入 rejected 层、删除原文件并 _unstage，返回 {"action":"falsified","new_id":None,"evidence_count":None,"demoted":None}；confirmed/weakened 时 confidence 分别 +0.05 / -0.15（夹到 [0,0.99] 并 round 2）、evidence_count 与 positive_evidence/negative_evidence 各 +1、追加 evidence_log，且仅当 weakened 后 confidence < DEMOTE_CONFIDENCE 且 layer=="knowledge" 时调 _move_layer 到 contextual 并 set_state("demoted")，否则 _write_node 回写并同步索引 evidence_count；
-    def verify(self, node_id: str, evidence: str, verdict: str):
+# 生效条件：verdict 不在 {confirmed,weakened,falsified} 时抛 ValueError；node_id 取不到节点返回 None；verdict=="falsified" 时先经 protect.guard_forget（受保护节点需显式 override=True——旧版本自动快照+留痕；拒绝抛 ProtectionError 且无任何副作用），通过后以 content[:200] 为假设写入 rejected 层、删除原文件并 _unstage，返回 {"action":"falsified","new_id":None,"evidence_count":None,"demoted":None}；confirmed/weakened 时 confidence 分别 +0.05 / -0.15（夹到 [0,0.99] 并 round 2）、evidence_count 与 positive_evidence/negative_evidence 各 +1、追加 evidence_log，且仅当 weakened 后 confidence < DEMOTE_CONFIDENCE 且 layer=="knowledge" 时调 _move_layer 到 contextual 并 set_state("demoted")，否则 _write_node 回写并同步索引 evidence_count；
+    def verify(self, node_id: str, evidence: str, verdict: str,
+               override: bool = False):
         """验证单元（白箱第 3 篇第 13 章）：对节点做一次外部验证裁决。
 
         verdict ∈ {"confirmed", "weakened", "falsified"}
         - confirmed：positive_evidence+1，confidence 上调 +0.05
         - weakened：negative_evidence+1，confidence 下调 -0.15（反例权重更大）
-        - falsified：节点移入 rejected/（幂等：相同 hypothesis 不重复）
+        - falsified：节点移入 rejected/（幂等：相同 hypothesis 不重复）；
+          受保护节点（self/anchor 层、protected 标记、importance≥0.7）
+          不可一键证伪删除——需显式 override=True（先快照+留痕）
 
         每次裁决累加 evidence_count（白箱第 5 篇第 4 章）。
         weakened 后 confidence 跌破 DEMOTE_CONFIDENCE 且原属 knowledge 层 →
@@ -2778,6 +3338,15 @@ class MdCG:
         if not node:
             return None
         if verdict == "falsified":
+            # 写保护（N130，2026-09-25）：证伪 = 对原节点的一次**硬删除**
+            # （os.remove，无快照、不进 trash），与 forget/降级同受「不可遗忘」
+            # 保护——self/anchor 层、protected 标记、importance≥0.7 不得被一次
+            # verify 调用一键删除。对照 forget 路径（mdcos.py forget）同一闸口：
+            # 受保护节点需显式 override=True（旧版本先快照进 _protected_history
+            # 并留痕 _protected_audit.jsonl），拒绝抛 ProtectionError、原节点
+            # 原样保留。守卫必须在 add_rejected 之前——拒绝路径零副作用。
+            protect.guard_forget(self, node_id, override=override,
+                                 actor=getattr(self, "actor", None))
             # 移入 rejected：负记忆化
             self.add_rejected(hypothesis=node["content"][:200],
                               reason=evidence,
@@ -2825,6 +3394,13 @@ class MdCG:
             e = self.index["nodes"].get(node_id)
             if e is not None:
                 e["evidence_count"] = fm["evidence_count"]
+                # 落盘必须对索引增量日志（_dirty→flush→_index_log 重放）与
+                # 读缓存代际可见：本分支写盘后若节点已在目标验证态，尾部
+                # set_verification 走 noop 提前返回（trust.py stamp），不会
+                # 经 _sync_index 标脏——不显式置 _dirty 会造成重开后索引
+                # evidence_count 与盘面漂移、同实例 _read 命中旧 frontmatter
+                #（口径同边域同步 _sync_edge_entry / goal 状态写回）。
+                self._dirty[node_id] = e
         # 验证态流转（可验证记忆单元）：外部证据裁决**就是**验证态迁移。
         #   confirmed → verified（首次转正；已在 verified 则幂等 no-op）
         #   weakened  → doubted（证据被削弱 ⇒ 存疑，待复核）
@@ -2927,7 +3503,7 @@ class MdCG:
                 continue
             fm["access_count"] = int(fm.get("access_count") or 0) + c
             fm["last_access"] = max(float(fm.get("last_access") or 0), last.get(nid, 0))
-            self._write_node(nid, os.path.join(self.root, e["path"]), fm, content)
+            self._write_node(nid, self._node_disk_path(e), fm, content)
             n += 1
         with FileLock(self.access_log):
             atomic_write(self.access_log, "")
@@ -2944,7 +3520,7 @@ class MdCG:
         layer_stats = {}
         neg_stats = {}
         for e in self.index["nodes"].values():
-            full_path = os.path.join(self.root, e["path"])
+            full_path = self._node_disk_path(e)
             try:
                 with open(full_path, encoding="utf-8") as f:
                     fm, content = nodefile.loads(f.read())