@furongjun1999/dsh-memory 0.4.11 → 0.5.1

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 终排兜底精度）；
@@ -613,7 +619,7 @@ def _strip_empty_gate_fields(entry, enabled=None):
 
 # 生效条件：entry 与其 frontmatter 的 condition_space 取 cs（缺键/假值按 {}）；ctx 为假值或非 dict 时无条件返回 True；
 # ctx 与 cs 同时给出非空 observation_position 且 routing.normalize_domain 归一化后不同时返回 False；
-# ctx 与 cs 同时给出长度 2 的 time_window 且两区间不相交时返回 False（区间相交或任一侧缺值/不可转 float 一律返回 True）。
+# ctx 与 cs 同时给出长度 2 的 time_window 时两端经 trust.epoch_seconds 归一（毫秒自动 /1000）后比较，不相交返回 False（区间相交或任一侧缺值/不可转数值一律返回 True）。
 def _cond_prefilter_pass(entry, ctx) -> bool:
     """S2 条件空间前置门控：**不读正文**即可判定的硬槽（契约 §3 S2）。
 
@@ -640,14 +646,267 @@ def _cond_prefilter_pass(entry, ctx) -> bool:
     cw, nw = ctx.get("time_window"), (entry.get("time_window") or cs.get("time_window"))
     if (isinstance(cw, (list, tuple)) and len(cw) == 2
             and isinstance(nw, (list, tuple)) and len(nw) == 2):
-        try:
-            if float(cw[1]) < float(nw[0]) or float(nw[1]) < float(cw[0]):
-                return False
-        except (TypeError, ValueError):
-            return True
+        # 单位归一（唯一口径 trust.epoch_seconds）：历史毫秒节点的区间若不归一，
+        # 与秒级查询窗「必然不相交」→ 整片历史观测被误剔除（issue #23 同根因）。
+        c0, c1 = trust.epoch_seconds(cw[0]), trust.epoch_seconds(cw[1])
+        n0, n1 = trust.epoch_seconds(nw[0]), trust.epoch_seconds(nw[1])
+        if None in (c0, c1, n0, n1):
+            return True                  # 任一端不可转 → 信息不足，放行（宁多勿漏）
+        if c1 < n0 or n1 < c0:
+            return False
     return True
 
 
+# 生效条件：entries/terms/big_domain/context/min_results 给定；MDCG_RETRIEVAL_PIPELINE 未设="1" 时 entries 原样返回且 gates 为空 dict（默认路径零变更）；总开关开启时按既有开关语义执行收敛——S1 域收敛（MDCG_GATE_S1_DOMAIN 未设=开；域内∪未标域兜底池，域内不足 min_results 回退不收敛）、S1b 桶收敛（MDCG_GATE_S1B_BUCKET 显式=1；topk/min_sim 参数化，命中不足回退并记 would_keep）、S2 条件空间硬槽（MDCG_GATE_S2_COND 未设=开；清空回退）、S4 层级激活审计（MDCG_GATE_S4_LAYER 显式=1；只构造 gates["s4"] 审计，加成本体在 _score）；返回 (收敛后 entries, gates 审计字典)；
+# apply_retrieval_gates(entries, terms, big_domain, context, min_results) -> tuple:
+def apply_retrieval_gates(entries, terms, big_domain, context, min_results):
+    """S1/S1b/S2 候选收敛 + S4 审计——**两份 search 的唯一实现**。
+
+    issue #25（2026-09-23）：此段逻辑原先只存在于 MdCG.search 内，而生产
+    调用链（mcp_server → MdCGSecure → MdCGOS）走的是 MdCGOS.search 覆写——
+    门控在 生产路径上从未生效，专项测试（test_retr_s*.py）全测非生产路径，
+    绿灯是假信号。修复 = 抽出本共享函数，两份 search 原地调用。
+
+    开关语义（契约 §3，保持不变）：
+      · 总开关 MDCG_RETRIEVAL_PIPELINE=1；未设 → 本函数是恒等变换；
+      · S1 / S2：未设=开，"=0" 显式关（先于 S1b 存在的默认项）；
+      · S1b / S4：必须显式 "=1"（会新增收敛/新层加成，非对称开关）；
+      · S3 spread / S7 postings：仍属 MdCG.search 的候选生成段（新 tier），
+        MdCGOS 路径的对应物是 reach——本函数不涉及。
+    召回安全不变量：任一收敛「命中不足 min_results / 清空」即回退不收敛；
+    orphan/未标域恒留兜底池。
+    """
+    gates = {}
+    if os.environ.get("MDCG_RETRIEVAL_PIPELINE") != "1":
+        return entries, gates
+    # S4 层级激活优先级审计（加成本体在 _score：layer_boosts() 由打分面消费，
+    # 该面两份 search 共享 → S4 加成在生产路径其实一直生效，缺的只是这份审计）
+    _s4 = (os.environ.get("MDCG_GATE_S4_LAYER") == "1")
+    if _s4 and entries:
+        _bo = layer_boosts()
+        _lc = {}
+        for _e in entries:
+            _l = str(_e.get("layer") or "")
+            _lc[_l] = _lc.get(_l, 0) + 1
+        gates["s4"] = {"boosts": _bo, "layers": _lc}
+    if os.environ.get("MDCG_GATE_S1_DOMAIN", "1") != "0" and big_domain:
+        # 域内 ∪ 未标域（兜底池）：无域标签的历史节点绝不能因「域内够多」被丢
+        #（契约 §3 S1 不变量：ORPHAN/未标域必须可被召回）
+        same = [e for e in entries
+                if not e.get("big_domain") or e.get("big_domain") == big_domain]
+        # 召回安全：域内候选不足以支撑 min_results 时不收敛，留全量兜底
+        if len(same) >= max(1, min_results):
+            gates["s1"] = {"domain": big_domain, "in": len(same),
+                           "dropped": len(entries) - len(same)}
+            entries = same
+        else:
+            gates["s1"] = {"domain": big_domain, "in": len(same),
+                           "dropped": 0, "fallback": "insufficient"}
+    elif os.environ.get("MDCG_GATE_S1_DOMAIN", "1") != "0":
+        gates["s1"] = {"domain": None, "reason": "no_domain_signal"}
+    # ---- S1b 细口径桶收敛（设计见 docs/hive/检索收敛实测与S1b设计_v0.1.md）----
+    # 为何：真实库 91.1% 节点有非 orphan 桶、期望扫描仅 2.1%（细口径），但 T0/T1 桶路
+    # 只在调用方传 context 时可用；普通 search(q) 无 context 就只能全扫。S1b 让 query 侧
+    # 自己推断候选桶（只用索引，不读文件），把这份收敛拿回来。
+    # 召回安全：orphan/无桶节点恒留兜底；命中不足 min_results 即回退（不改 entries）。
+    # 开关与参数就地定义：S1b 只依赖总开关 + MDCG_GATE_S1B_BUCKET。
+    _s1b = (os.environ.get("MDCG_GATE_S1B_BUCKET") == "1")
+    try:
+        _s1b_topk = int(os.environ.get("MDCG_BUCKET_TOPK", "3"))
+    except ValueError:
+        _s1b_topk = 3
+    try:
+        _s1b_minsim = min(1.0, max(0.0, float(os.environ.get("MDCG_BUCKET_MIN_SIM", "0.34"))))
+    except ValueError:
+        _s1b_minsim = 0.34
+    if _s1b and entries:
+        if _s1b_topk <= 0:
+            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:
+                    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:
+                # 审计止血（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]],
+                                                 str(kv[0])))[:_s1b_topk]
+                _keep = {_b for _b, _ in _picked}
+                _kept = [e for e in entries
+                         if (e.get("bucket") in _keep)
+                         or not e.get("bucket")
+                         or e.get("bucket") == routing.ORPHAN]
+                gates["s1b"] = {"keys": [_b for _b, _ in _picked],
+                                "sims": [round(_v, 4) for _, _v in _picked],
+                                "in": len(entries), "out": len(_kept),
+                                "sizes": {_b: _sizes[_b] for _b, _ in _picked}}
+                if len(_kept) >= max(1, min_results):
+                    entries = _kept
+                else:
+                    # 回退：entries 保持不变 → 审计的 out 必须记「真实输出规模」，
+                    # 命中桶本可保留的数量另存 would_keep（独立复核 2026-09-19 指出口径误导）
+                    gates["s1b"]["would_keep"] = len(_kept)
+                    gates["s1b"]["out"] = len(entries)
+                    gates["s1b"]["fallback"] = "insufficient"
+    if os.environ.get("MDCG_GATE_S2_COND", "1") != "0" and isinstance(context, dict):
+        kept = [e for e in entries if _cond_prefilter_pass(e, context)]
+        gates["s2"] = {"in": len(entries), "out": len(kept),
+                       "dropped": len(entries) - len(kept)}
+        # 门控清空则回退（宁多勿漏）
+        if kept:
+            entries = kept
+        else:
+            gates["s2"]["fallback"] = "empty"
+    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}$")
+
+
 # 生效条件：构造须传入 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；
@@ -666,7 +925,7 @@ 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()
         sweep_stale_temps(self.root)
@@ -676,7 +935,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):
@@ -687,6 +946,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):
@@ -702,6 +972,38 @@ class MdCG:
         idx["buckets"] = self._count_buckets(idx["nodes"])
         return idx
 
+# 生效条件：遍历 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):
@@ -712,57 +1014,184 @@ 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 并返回 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
         return idx
 
-# 生效条件：self._dirty 非空时才（必要时新建 ShardedLog）逐条 append、清空 _dirty 并关闭分片句柄；self._dirty 为空时立即返回、不写任何记录；
+# 生效条件：self._dirty 非空时才在 FileLock(index_path) 下（必要时新建 ShardedLog）逐条 append、清空 _dirty 并关闭分片句柄；self._dirty 为空时立即返回、不写任何记录；
     def flush(self):
         if not self._dirty:
             return
-        if self._log is None:
-            self._log = ShardedLog(self.index_log_dir)
-        for nid, e in self._dirty.items():
-            self._log.append({"id": nid, "e": e})
-        self._dirty = {}
-        # 写完立即关分片句柄：Windows 上「被本进程打开的文件」无法删除，
-        # 若持有句柄，rebuild_index 的 ShardedLog.clear 会静默失败，已并进
-        # 快照的旧记录被永久重放（旧条目反而覆盖新快照）。append 内部已
-        # 每次 flush，句柄无需常驻；下一次 append 会按需重开。
-        self._log.close()
-
-# 生效条件：随认知图对象生命周期结束调用、可重复；先 flush() 落未达 autoflush 阈值的脏索引（否则尾部写入虽在盘上但不可见），再关闭并置空日志句柄（句柄为假值时跳过关闭）；
+        # 世代/互斥防线（批次9，M3.3 落地）：append 必须与 compact/rebuild 的
+        # 「read 日志 → clear 分片」临界区互斥（同一把 index_path 锁）——
+        # 否则 B 实例的 append 落在 A 实例 read_all 之后、clear 之前时，
+        # 记录随分片被删，节点「在盘但索引不可见」（9·12 病灶：3 实例并发，
+        # apply 留痕 7590 vs 盘面 ~1036 的成因链之一）。锁内 append 后，
+        # 后续 clear 必然已包含本批记录。
+        with FileLock(self.index_path):
+            if self._log is None:
+                self._log = ShardedLog(self.index_log_dir)
+            for nid, e in self._dirty.items():
+                self._log.append({"id": nid, "e": e})
+            self._dirty.clear()   # 保住 _DirtyDict 钩子（批次 23 D-4：不得换新 dict）
+            # 写完立即关分片句柄：Windows 上「被本进程打开的文件」无法删除，
+            # 若持有句柄，rebuild_index 的 ShardedLog.clear 会静默失败，已并进
+            # 快照的旧记录被永久重放（旧条目反而覆盖新快照）。append 内部已
+            # 每次 flush，句柄无需常驻；下一次 append 会按需重开。
+            self._log.close()
+
+# 生效条件：随认知图对象生命周期结束调用、可重复；先 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:
@@ -775,88 +1204,54 @@ 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"),
-                        "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、清空 _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 = {}
+        # 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}$）或含 ".."、或落盘 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,
@@ -905,6 +1300,16 @@ 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 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 的**既有**节点
@@ -940,13 +1345,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。
@@ -967,6 +1407,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 的根因）。调用方可显式传入覆盖。
@@ -980,6 +1422,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 同构的坑）。口径：
@@ -1137,9 +1594,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),
@@ -1243,6 +1725,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 真源的唯一正路）。
     #
@@ -1493,7 +1987,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:
@@ -1506,6 +2000,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 文本以空格拼接的字符串；
@@ -1668,7 +2168,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 已有标签而跳过）
@@ -1680,6 +2180,55 @@ 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}；
@@ -1687,7 +2236,7 @@ class MdCG:
         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())
@@ -1698,15 +2247,27 @@ 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())
         except OSError:
             return None, None
 
+    def _doc_norm_bigrams(self, entry, c):
+        """文档侧归一化 bigram（`_score` 热点，批次 21 issue #31 钩子化）。
+
+        内容不变则派生物不变——readcache 启用时覆写为缓存版（随读缓存
+        一并常驻，Rust `load_docs` 预计算 stripped/db_len 同款理论）；
+        基类默认即算即弃，行为与改动前逐位一致。
+        """
+        return bigrams(normalize_en(c))
+
     # ---------- 资格判定（与性能 tier 正交）----------
 
     @staticmethod
@@ -1868,6 +2429,11 @@ class MdCG:
               ValueError（fail-closed 只针对调用方误用）。
         """
         q = (query or "").strip()
+        # 批次 15 统一口径（unify.py）：任意语言 query → 标准原子序列
+        # （统一翻译为中文→归一化到标准中文集→检索）；纯中文原样、
+        # MDCG_UNIFY_QUERY=0 可关、失败静默原样
+        from .semantic.unify import unify_query
+        q = unify_query(q)
         if not q:
             return [], {"tier": None, "reason": "empty_query", "scanned": 0}
         pool_cfg = pooling.resolve(pooling.from_env(pools))
@@ -1880,9 +2446,17 @@ class MdCG:
         # 把 rejected/unresolved 视作可参与召回的特殊「候选池」
         # ——命中它们的结果会改变 meta 的 covered_neg（被负记忆覆盖的查询）
         # 默认排除掉负记忆层的节点进入正排打分，仅作为「覆盖标记」用
-        entries = [e for e in self.index["nodes"].values()
-                   if (not layer or e["layer"] == layer)
-                   and (not session or e.get("session") == session)
+        # 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)
                    # 分支实验场：默认（branch=None）分支节点全部隐身；
                    # branch=<id> 时主支 + 本分支可见、其他分支仍隐身
                    and e.get("branch_id") in (None, branch)
@@ -1890,7 +2464,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）。
@@ -1898,8 +2473,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 各司其职、互不替代：
@@ -1931,27 +2510,20 @@ class MdCG:
         # 默认（MDCG_RETRIEVAL_PIPELINE 未设）全关 → 行为与改动前等价。
         big_domain = routing.big_domain_classify(terms)
         big_scores = routing.big_domain_score_breakdown(terms)
-        gates = {}
         # S3 子开关**必须显式 =1**（与 S1/S2 的「未设=开」不同，是有意的非对称）：
         # S3 会新增候选并引入新的 tier（TIER_SPREAD），在总开关开启时若默认随开，
         # 会让「启用 S1/S2」的用户静默多出一层结果——独立复核（2026-09-19）要求显式启用。
         # 参数：hops（默认 2）、decay（默认 0.5）、gain（默认 0.2）。
         _s3 = (os.environ.get("MDCG_RETRIEVAL_PIPELINE") == "1"
                and os.environ.get("MDCG_GATE_S3_SPREAD") == "1")
-        # S4 层级激活优先级：同样必须显式 =1（新层加成会改变排序，属显式启用项）
-        _s4 = (os.environ.get("MDCG_RETRIEVAL_PIPELINE") == "1"
-               and os.environ.get("MDCG_GATE_S4_LAYER") == "1")
         # S7 倒排候选层（只作候选生成器；召回与全表扫描一致）；见 md_cg/postings.py
         _s7 = (os.environ.get("MDCG_RETRIEVAL_PIPELINE") == "1"
                and os.environ.get("MDCG_GATE_S7_POSTINGS") == "1")
         _s7_narrowed = False
-        if _s4 and entries:
-            _bo = layer_boosts()
-            _lc = {}
-            for _e in entries:
-                _l = str(_e.get("layer") or "")
-                _lc[_l] = _lc.get(_l, 0) + 1
-            gates["s4"] = {"boosts": _bo, "layers": _lc}
+        # S1/S1b/S2 收敛 + S4 审计走共享函数（issue #25：原先内联于此，被
+        # MdCGOS.search 覆写悬空——生产路径从未生效；行为与内联版逐字节一致）
+        entries, gates = apply_retrieval_gates(
+            entries, terms, big_domain, context, min_results)
         try:
             _s3_hops = max(1, int(os.environ.get("MDCG_SPREAD_HOPS", "2")))
         except ValueError:
@@ -1964,91 +2536,6 @@ class MdCG:
             _s3_gain = min(1.0, max(0.0, float(os.environ.get("MDCG_SPREAD_GAIN", "0.2"))))
         except ValueError:
             _s3_gain = 0.2
-        if os.environ.get("MDCG_RETRIEVAL_PIPELINE") == "1" and entries:
-            if os.environ.get("MDCG_GATE_S1_DOMAIN", "1") != "0" and big_domain:
-                # 域内 ∪ 未标域（兜底池）：无域标签的历史节点绝不能因「域内够多」被丢
-                #（契约 §3 S1 不变量：ORPHAN/未标域必须可被召回）
-                same = [e for e in entries
-                        if not e.get("big_domain") or e.get("big_domain") == big_domain]
-                # 召回安全：域内候选不足以支撑 min_results 时不收敛，留全量兜底
-                if len(same) >= max(1, min_results):
-                    gates["s1"] = {"domain": big_domain, "in": len(same),
-                                   "dropped": len(entries) - len(same)}
-                    entries = same
-                else:
-                    gates["s1"] = {"domain": big_domain, "in": len(same),
-                                   "dropped": 0, "fallback": "insufficient"}
-            elif os.environ.get("MDCG_GATE_S1_DOMAIN", "1") != "0":
-                gates["s1"] = {"domain": None, "reason": "no_domain_signal"}
-            # ---- S1b 细口径桶收敛（设计见 docs/hive/检索收敛实测与S1b设计_v0.1.md）----
-            # 为何：真实库 91.1% 节点有非 orphan 桶、期望扫描仅 2.1%（细口径），但 T0/T1 桶路
-            # 只在调用方传 context 时可用；普通 search(q) 无 context 就只能全扫。S1b 让 query 侧
-            # 自己推断候选桶（只用索引，不读文件），把这份收敛拿回来。
-            # 召回安全：orphan/无桶节点恒留兜底；命中不足 min_results 即回退（不改 entries）。
-            # 开关与参数就地定义（位于“总开关块”内，不在 S4 块内）：S1b 只依赖总开关 + MDCG_GATE_S1B_BUCKET。
-            _s1b = (os.environ.get("MDCG_GATE_S1B_BUCKET") == "1")
-            try:
-                _s1b_topk = int(os.environ.get("MDCG_BUCKET_TOPK", "3"))
-            except ValueError:
-                _s1b_topk = 3
-            try:
-                _s1b_minsim = min(1.0, max(0.0, float(os.environ.get("MDCG_BUCKET_MIN_SIM", "0.34"))))
-            except ValueError:
-                _s1b_minsim = 0.34
-            if _s1b and entries:
-                if _s1b_topk <= 0:
-                    gates["s1b"] = {"keys": [], "reason": "disabled_by_topk"}
-                else:
-                    _sizes = {}
-                    for _e in entries:
-                        _b = _e.get("bucket")
-                        if _b and _b != routing.ORPHAN:
-                            _sizes[_b] = _sizes.get(_b, 0) + 1
-                    _best = {}
-                    for _b in _sizes:
-                        _kk = routing.bucket_key_readable(_b)
-                        if not _kk:
-                            continue
-                        _sim = 0.0
-                        for _t in terms:
-                            _sv = routing.domain_similarity(_t, _kk)
-                            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)}
-                    else:
-                        _picked = sorted(_best.items(),
-                                         key=lambda kv: (-kv[1], -_sizes[kv[0]],
-                                                         str(kv[0])))[:_s1b_topk]
-                        _keep = {_b for _b, _ in _picked}
-                        _kept = [e for e in entries
-                                 if (e.get("bucket") in _keep)
-                                 or not e.get("bucket")
-                                 or e.get("bucket") == routing.ORPHAN]
-                        gates["s1b"] = {"keys": [_b for _b, _ in _picked],
-                                        "sims": [round(_v, 4) for _, _v in _picked],
-                                        "in": len(entries), "out": len(_kept),
-                                        "sizes": {_b: _sizes[_b] for _b, _ in _picked}}
-                        if len(_kept) >= max(1, min_results):
-                            entries = _kept
-                        else:
-                            # 回退：entries 保持不变 → 审计的 out 必须记「真实输出规模」，
-                            # 命中桶本可保留的数量另存 would_keep（独立复核 2026-09-19 指出口径误导）
-                            gates["s1b"]["would_keep"] = len(_kept)
-                            gates["s1b"]["out"] = len(entries)
-                            gates["s1b"]["fallback"] = "insufficient"
-            if os.environ.get("MDCG_GATE_S2_COND", "1") != "0" and isinstance(context, dict):
-                kept = [e for e in entries if _cond_prefilter_pass(e, context)]
-                gates["s2"] = {"in": len(entries), "out": len(kept),
-                               "dropped": len(entries) - len(kept)}
-                # 门控清空则回退（宁多勿漏）
-                if kept:
-                    entries = kept
-                else:
-                    gates["s2"]["fallback"] = "empty"
         if not entries:
             _m = {"tier": None, "reason": "no_candidates", "scanned": 0}
             if gates:                      # 默认关时 gates 为空 → 不落键（口径与改动前一致）
@@ -2058,21 +2545,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:
@@ -2082,12 +2575,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,
@@ -2134,11 +2642,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 审计**，
@@ -2384,9 +2908,11 @@ class MdCG:
         _boost = layer_boosts() if _s4_on else None
         scored = []
         for e, fm, c in docs:
-            # 归一化 content 后取 bigram（与 query 侧 normalize_en 对称）
-            c_norm = normalize_en(c)
-            nb = bigrams(c_norm)
+            # 归一化 content 后取 bigram（与 query 侧 normalize_en 对称）；
+            # 走可覆写钩子（批次 21，issue #31）：内容不变则派生物不变——
+            # readcache 启用时覆写为缓存版（Rust load_docs 预计算同款），
+            # 基类默认即算即弃，行为与改动前逐位一致
+            nb = self._doc_norm_bigrams(e, c)
             sim = lexical_sim(qb, nb, mode)
             tag_bonus = 0.05 if any(str(t) in q or q in str(t)
                                     for t in (fm.get("tags") or [])) else 0.0
@@ -2513,11 +3039,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"]}
@@ -2700,14 +3231,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 层 →
@@ -2719,6 +3253,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,
@@ -2766,6 +3309,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（证据被削弱 ⇒ 存疑，待复核）
@@ -2868,7 +3418,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, "")
@@ -2885,7 +3435,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())