@furongjun1999/dsh-memory 0.7.1 → 0.7.3

package/md_cg/mdcos.py

@@ -977,7 +977,9 @@ class MdCGOS(MdCG):
                 # 语义资格（MDCG_SEMANTIC=1）：fm.semantic 节点无条件入池
                 hits = [d for d in docs
                         if self._like(d[2], d[1], terms,
-                                      index_key_hits(d[0], terms, q))
+                                      index_key_hits(d[0], terms, q),
+                                      entry=d[0],
+                                      positive_body=self._positive_body)
                         or (semantic_on() and d[1].get("semantic"))]
                 out = try_stage(hits, TIER_BUCKET_LIKE)
                 if out:
@@ -1004,7 +1006,9 @@ class MdCGOS(MdCG):
             _dif = set(_rstat.get("reach_diffused_paths") or ())
             hits_r = [d for d in docs_r
                       if self._like(d[2], d[1], terms,
-                                    index_key_hits(d[0], terms, q))
+                                    index_key_hits(d[0], terms, q),
+                                    entry=d[0],
+                                    positive_body=self._positive_body)
                       or (semantic_on() and d[1].get("semantic"))
                       or d[0].get("path") in _dif]     # 图扩散补召回：无词面命中也放行进打分
             stat["pre_cap"] = len(hits_r)     # 与 T2 同序：截断**前**的候选数
@@ -1038,7 +1042,9 @@ class MdCGOS(MdCG):
         # 语义资格（MDCG_SEMANTIC=1）：fm.semantic 节点无条件入池
         hits = [d for d in docs_all
                 if self._like(d[2], d[1], terms,
-                              index_key_hits(d[0], terms, q))
+                              index_key_hits(d[0], terms, q),
+                              entry=d[0],
+                              positive_body=self._positive_body)
                 or (semantic_on() and d[1].get("semantic"))]
         stat["pre_cap"] = len(hits)
         stat["cap"] = GLOBAL_CAP
@@ -1088,7 +1094,9 @@ class MdCGOS(MdCG):
         # 语义摘要=检索面（设想核心），否则摘要层只在 LIKE 全空时生效
         hits = [d for d in docs
                 if self._like(d[2], d[1], terms,
-                              index_key_hits(d[0], terms, query))
+                              index_key_hits(d[0], terms, query),
+                              entry=d[0],
+                              positive_body=self._positive_body)
                 or (semantic_on() and d[1].get("semantic"))]
         if not hits:
             # 兜底池（LIKE 全空 = 无相关度信号）：截断依据=importance/created_at
@@ -1346,8 +1354,10 @@ class MdCGOS(MdCG):
         out = []
         for e, fm, c in self._read_many(entries, stat):
             tags = " ".join(str(t) for t in (fm.get("tags") or []))
-            # 负条件行不作召回键（反例命中应由 judge 走 REJECT，不该召回节点）
-            cov = _weighted_coverage(tw, f"{nodefile.positive_body(c)} {tags}")
+            # 负条件行不作召回键（反例命中应由 judge 走 REJECT，不该召回节点）。
+            # N273：走 `_positive_body` 钩子（readcache 启用时 path 键控缓存
+            # 版）——与 `_like` 侧同一条派生物缓存口径，不再是第二处直调。
+            cov = _weighted_coverage(tw, f"{self._positive_body(e, c)} {tags}")
             if cov <= 0.0:
                 continue
             e_dom = routing.route_key(None, e.get("tags"))
@@ -3005,7 +3015,7 @@ class MdCGOS(MdCG):
     def is_tombstoned(self, node_id: str):
         return any(r.get("id") == node_id for r in read_jsonl(self.deletions_log))
 
-# 生效条件：当 node_id 传入时，若 deletions_log 中存在该 id 且 force=False 返回 tombstoned 拒绝；否则检查 trash_dir/{node_id}.md，os.path.exists 为 False 返回 not_in_trash；可打开则读取并以 add(override=True) + trash frontmatter 元数据全量透传（显式形参逐项传，其余键经 **extra 回写；lifecycle_state 仅在 active→该态合法迁移时透传）恢复、移除 trash 源、audit，返回 ok True/id/forced=bool(force)；
+# 生效条件：当 node_id 传入时，若 deletions_log 中存在该 id 且 force=False 返回 tombstoned 拒绝；否则检查 trash_dir/{node_id}.md，os.path.exists 为 False 返回 not_in_trash；文件含坏字节（非 UTF-8）无法解析时返回 error=corrupt 且 trash 源原样保留（不删不移）；可打开则读取并以 add(override=True) + trash frontmatter 元数据全量透传（显式形参逐项传，其余键经 **extra 回写；lifecycle_state 仅在 active→该态合法迁移时透传）恢复、移除 trash 源、audit，返回 ok True/id/forced=bool(force)；
     def restore(self, node_id: str, force: bool = False):
         """恢复：若在删除清单中且未 force → 拒绝（恢复时删除检查）。"""
         tomb = [r for r in read_jsonl(self.deletions_log) if r.get("id") == node_id]
@@ -3015,8 +3025,14 @@ class MdCGOS(MdCG):
         src = os.path.join(self.trash_dir, f"{node_id}.md")
         if not os.path.exists(src):
             return {"ok": False, "error": "not_in_trash"}
-        with open(src, encoding="utf-8") as f:
-            fm, content = nodefile.loads(f.read())
+        try:
+            with open(src, encoding="utf-8") as f:
+                fm, content = nodefile.loads(f.read())
+        except UnicodeDecodeError:
+            # trash 源损坏：返回结构化失败，源文件原样保留（不删不移）
+            return {"ok": False, "error": "corrupt",
+                    "reason": "trash 文件非 UTF-8（损坏），恢复中止；"
+                              "源文件原样保留"}
         layer = fm.get("layer", "knowledge")
         # 恢复 = 原样放回：add 是**全量重建 fm**，只传个位数字段会把 edges/
         # depends_on/验证态/生命周期/created_at/语义摘要/证据计数等元数据永久
@@ -4410,9 +4426,15 @@ class MdCGOS(MdCG):
     def check_consistency(self, content, layer=None, condition_space=None,
                           non_applicable_conditions=None, tags=None,
                           exclude=None, limit=consistency.MAX_SCAN,
-                          depth=consistency.MAX_DEPTH, auto_flywheel=False):
+                          depth=consistency.MAX_DEPTH, auto_flywheel=False,
+                          log_write=True):
         """不落盘地预检一条待写内容是否与既有节点/纪律冲突（三级决策）。
 
+        log_write（路线 C，2026-10-05，透传 consistency.check 同名参数）：
+        缺省 True＝原行为（落 `_consistency.jsonl` 台账）；**只读消费面**
+        （auditview 证据审计）传 False——判定照常返回、台账不写（「不落盘
+        预检」承诺的补全：既有 log 是无条件写，只读面消费会变成隐式写）。
+
         对齐《智能的公理化基石》§十一（情绪=信息差二阶变化，独立不参与信任）、
         条件论「反题」（预测与事实冲突）、:273（递归受深度/节点/循环/增益门槛约束）。
 
@@ -4430,7 +4452,7 @@ class MdCGOS(MdCG):
                                        if not _is_null_condition(x)],
             tags=tags,
             exclude=exclude, limit=limit, depth=depth,
-            auto_flywheel=auto_flywheel)
+            auto_flywheel=auto_flywheel, log_write=log_write)
 
 # 生效条件：当 limit 传入时，以 limit（默认 100）调用 consistency.history 并返回其结果；本函数不改变 limit；
     def consistency_history(self, limit=100):
@@ -5097,8 +5119,8 @@ class MdCGSecure(MdCGOS):
     def _neg_coverage(self, terms):
         return [e for e in super()._neg_coverage(terms) if self._readable(e)]
 
-# 生效条件：node_id 在 self.index["nodes"] 中存在且 self._readable(e) 为假时返回 None，否则转 super().get(node_id)；索引缺该条目时**先做代际探活重载再判可见性**（N196：索引缺条目 ≡ 本进程陈旧，不得据以跳过读隔离），重载后仍无条目才回落 super().get 的 not_found 语义；super().get 返回真值节点后用**同一次读取所得的 frontmatter**（sensitivity/session）再判一次可见性，为假即返回 None（N213：命中陈旧条目的路径不得以旧快照当判据、以新盘面当正文）；
-    def get(self, node_id: str):
+# 生效条件：probe 为真（缺省，行为与改动前逐位一致）时，索引缺该条目才做代际探活重载（N196）且 super().get 照旧探活；probe=False 时两处探活一并跳过（N276：调用方已在本批读之前探过一次，批量循环内的逐节点读不再各自重探）；其余判据与 probe 无关：node_id 在 self.index["nodes"] 中存在且 self._readable(e) 为假时返回 None，否则转 super().get(node_id, probe=probe)；索引缺该条目时**先做代际探活重载再判可见性**（N196：索引缺条目 ≡ 本进程陈旧，不得据以跳过读隔离），重载后仍无条目才回落 super().get 的 not_found 语义；super().get 返回真值节点后用**同一次读取所得的 frontmatter**（sensitivity/session）再判一次可见性，为假即返回 None（N213：命中陈旧条目的路径不得以旧快照当判据、以新盘面当正文）；
+    def get(self, node_id: str, probe: bool = True):
         e = self.index["nodes"].get(node_id)
         if e is None:
             # N196（2026-09-28）：索引缺条目**不**等于「节点不存在」——本进程
@@ -5108,11 +5130,14 @@ class MdCGSecure(MdCGOS):
             # 第二次读才归 None，因为那时条目已随重载进入索引）。先探活重载
             # 再判可见性；真不存在时 e 仍为 None，super().get 照旧返回 None。
             # 成本只在**未命中**路径（一次 stat），命中路径零变化。
-            self._maybe_reload_index()
+            # N276：probe=False（批内单探针）时本探活同跳——语义窗口见
+            # forgetting.redundancy 同注（本批读期间他进程写入不探知）。
+            if probe:
+                self._maybe_reload_index()
             e = self.index["nodes"].get(node_id)
         if e is not None and not self._readable(e):
             return None                     # 读隔离：不可见即不存在
-        node = super().get(node_id)
+        node = super().get(node_id, probe=probe)
         if node is None:
             return None
         # N213（2026-09-28）：命中陈旧条目的路径此前**零探活**——可见性判据取自

package/md_cg/mreview/locate.py

@@ -312,7 +312,7 @@ def load_node(node_id, root, *, index=None) -> dict:
     try:
         with open(fp, encoding="utf-8") as f:
             text = f.read()
-    except OSError:
+    except (OSError, UnicodeDecodeError):
         return {"node_id": node_id, "meta": dict(meta), "fm": {}, "content": None,
                 "text": None, "path": fp}
     fm, content = NF.loads(text)

package/md_cg/nodefile.py

@@ -123,6 +123,22 @@ REPRODUCIBLE_BASIS = ("compiler", "test", "measurement", "formal_proof", "data")
 #: 来源一致性档：文科断言可用（来源表述一致即可）
 CONSISTENCY_BASIS = ("textbook", "public_kb")
 
+# ---- 多主体世界模型对齐（2026-10-05）：检验强度字段真源 ----------------------------
+# 「检验强度」分级（过程追踪过程 tracing 方法，见对齐评估 v0.1 §2 L1）：一条断言
+# 的**证据能带走多少裁决权重**——hoop（必要证据：不满足即证伪）/ smoking_gun
+# （决定性：单独即可确立）/ doubly_decisive（同时排除竞争假设）。与
+# `verification_basis`（来源**类型**）正交：一个说「凭什么类别的证据」，一个说
+# 「证据的裁决力有多强」。缺省 None＝未声明（**不落 fm 键**，存量零迁移、读取侧
+# `.get()` 回落）；显式传入时校验闭集（与 VERIFICATION_BASIS 同风格）。
+CHECK_STRENGTHS = ("hoop", "smoking_gun", "doubly_decisive")
+CHECK_STRENGTH_FIELD = "check_strength"
+
+#: 幽灵引用标记字段（A2，多主体世界模型对齐 v0.1 §2 L1「转引不得升级」）：
+#: 写入链检测到的**无可解析出处**的回指短语清单（短语层），落 fm 供后续
+#: 裁决/检索看见。**正文属性**：每次写入按当次检测重算、不继承（与
+#: check_strength 的声明继承语义相反——正文变了检测就该变）。
+UNCERTAIN_REFS_FIELD = "uncertain_refs"
+
 # ---- 裁定 D（2026-09-19）：可验证记忆单元的**字段名真源** --------------------------
 # 「子功能」的契约角色是**依赖 dependency**（见 CCG_CONTRACT_ROLES），其落字段即
 # `depends_on`——名字与角色对齐（不叫 sub_features，避免同一概念两种写法）。
@@ -386,6 +402,48 @@ def ccg_mark_present(content: str, mark: str) -> bool:
     return False
 
 
+# 生效条件：content 为真时逐行扫描——命中 marks 中任一要素的 CCG 标题行（判据单点 _ccg_heading_rest，`^#\s*<要素>` 冒号可有可无）即整段剥除：行内带值（`# 生效条件：v`／前缀式）只剥该行，裸标题连同其后首个非空、非标题行（该字段的值行，取值口径同 ccg_field_value）一并剥除；其余原行原样保留（含缩进）以 "\n" 连接返回；content 假值按空串返回。
+def _strip_ccg_segments(content, marks=CCG_MARKS):
+    """剥除 CCG 声明**整段字段**后的文本——剥除算法单点。
+
+    单点动因（N238 同族）：六要素允许无冒号形态（`# 不适用条件` + 换行 + 值行），
+    **值行才是内容本体**；只剥标题行会把该字段的正文留在正文里——同一条内容写成
+    带冒号时剥净、写成无冒号时残留，两种写法给出两种结论（该缺陷在
+    `consistency._body_text` 已按 N238 收口，本函数把**剥除算法本身**也收成一份，
+    防下游再各写一份循环而漂移）。调用方：`positive_body`（只剥不适用条件）与
+    `consistency._body_text`（剥全部六要素）。
+
+    判据一律走单点（`_ccg_heading_rest`，与写入闸门 data/policy.json 同一行语义）：
+    缩进标题与二级标题不构成「已声明」，与 `ccg_mark_present` 同边界。
+    """
+    lines = (content or "").split("\n")
+    out = []
+    i, n = 0, len(lines)
+    while i < n:
+        rest = None
+        for mark in marks:
+            rest = _ccg_heading_rest(lines[i], mark)
+            if rest is not None:
+                break
+        if rest is None:
+            out.append(lines[i])
+            i += 1
+            continue
+        i += 1
+        if rest.strip():
+            continue            # 行内已带值（冒号式 `# 字段：v` / 前缀式）→ 只剥该行
+        while i < n:            # 裸标题：其后首个非空、非标题行是值行，同剥
+            t = lines[i].strip()
+            if not t:
+                i += 1
+                continue
+            if t.startswith("#"):
+                break           # 下一个标题 ⇒ 本字段值为空，不消费
+            i += 1
+            break
+    return "\n".join(out)
+
+
 # 生效条件：content 中出现 "# {mark}：" 或 "# {mark}:"（中/英文冒号）或仅 "# {mark}" 标题行即把该 mark 计入 present 与 required_present；complete 为 required_present 覆盖全部 CCG_REQUIRED、all_present 为 present 覆盖全部 CCG_MARKS，ratio = len(required_present)/len(CCG_REQUIRED)，四键连同两个清单一起返回。
 def ccg_completeness(content: str) -> dict:
     """CCG 要素齐全度——白箱可审计性的量化指标。
@@ -441,39 +499,45 @@ def is_placeholder_text(value) -> bool:
     return any(m in s for m in PLACEHOLDER_MARKERS)
 
 
-# 生效条件：content 中含 "# 不适用条件："（全角冒号）或 "# 不适用条件:"（半角冒号）即返回 True，两者都不出现返回 False。
+# 生效条件：content 中存在 NEG_FIELD（"不适用条件"）的 CCG 标题行（判据单点 ccg_mark_present，`^#\s*不适用条件`，冒号可有可无，与写入闸门同一行语义）时返回 True，否则 False。
 def has_non_applicable(content: str) -> bool:
     """是否声明了不适用条件——REJECT 路径成立的必要条件。
 
     没有不适用条件的节点在白箱下不能 REJECT（无法证明「不适用」），
     只能 ACCEPT 或 BLINDSPOT。这是第 1 篇第 10 章从 28%→88% 的关键。
+
+    A3（N238 同族残面）：判据单点 = `ccg_mark_present`——本函数原先只认
+    「`# 不适用条件：`／`# 不适用条件:`」两种**带冒号**的字面量，无冒号形态
+    （`# 不适用条件` + 换行 + 值行）被判成「没声明」：同一条正文写不写冒号
+    给出两种结论，而「冒号可有可无」已由单点定案（test_ccg_form_parity ①-⑦）。
+    消费面：索引条目 `has_neg_conditions`（mdcg `_entry` / rebuild / `_stage`），
+    进而 `export`/`insight`/`sustain`/`predict` 的统计与边界读数。
     """
-    return "# 不适用条件：" in content or "# 不适用条件:" in content
+    return ccg_mark_present(content, NEG_FIELD)
 
 
 #: 负条件字段名——它是**反例声明**，不是召回键
 NEG_FIELD = "不适用条件"
 
 
-# 生效条件：content 为 None 时按 "" 处理；逐行 strip 后，仅当该行以 "#" 开头且 lstrip("#").strip() 又以 NEG_FIELD 开头时丢弃该行，其余行原样保留（保留原缩进），返回保留行的 "\n".join。
+# 生效条件：content 为 None 时按 "" 处理；逐行剥除 NEG_FIELD 的整段 CCG 声明（剥除算法单点 _strip_ccg_segments——行内带值只剥该行，裸标题连同其后首个非空、非标题的值行一并剥除），其余行原样保留（含原缩进），返回保留行的 "\n".join。
 def positive_body(content: str) -> str:
-    """剥离 `# 不适用条件：` 行后的正文——负条件不作召回键。
+    """剥离 `# 不适用条件` 声明段后的正文——负条件不作召回键。
 
     不适用条件声明的是「什么时候**不**适用」，其触发词是反例。一旦把它当召回
     键，查询命中反例时节点反而被召回——**恰好在它不该适用的地方被召回**，属实
     质性错误。反例的正确去向是 `judge_qualification` 的 REJECT 路径（读
     `frontmatter.non_applicable_conditions`），而不是召回。
 
-    只剥离真正的 CCG 行（以 `#` 开头且字段名匹配），避免误伤正文里恰好以
-    「不适用条件」开头的普通句子。
+    只剥离真正的 CCG 行（判据单点 `_ccg_heading_rest`：`# <字段>` 标题前缀、
+    冒号可有可无），避免误伤正文里恰好以「不适用条件」开头的普通句子。
+
+    A3（N238 同族残面）：剥的必须是**整段字段**——无冒号形态（`# 不适用条件` +
+    换行 + 值行）原先只剥标题行，值行（内容本体）残留 ⇒ 反例词面照样进召回键
+    （`MdCG._like` 实测命中），与带冒号写法的行为相反。剥除算法收在单点
+    `_strip_ccg_segments`（与 `consistency._body_text` 共用一份循环）。
     """
-    keep = []
-    for ln in (content or "").split("\n"):
-        s = ln.strip()
-        if s.startswith("#") and s.lstrip("#").strip().startswith(NEG_FIELD):
-            continue
-        keep.append(ln)
-    return "\n".join(keep)
+    return _strip_ccg_segments(content, (NEG_FIELD,))
 
 
 # ---- 条件空间 → 生效条件声明 -------------------------------------------------

package/md_cg/readcache.py

@@ -25,7 +25,9 @@
   2. 缓存**解析产物** `(fm, content)`（benchmark 版只缓存原文，parse 仍逐次），
      **并缓存文档侧检索派生物** `_doc_norm_bigrams`（归一化 bigram——批次 21
      实测本机热点 88% 在此而非 I/O：内容不变则派生物不变，随读缓存常驻；
-     Rust `load_docs` 预计算 stripped/db_len 同款理论）；
+     Rust `load_docs` 预计算 stripped/db_len 同款理论）与 `_positive_body`
+     （剥除不适用条件后的召回键正文——N273，8000 池实测 ~102ms/查询，
+     与 bigram 同一 path 键控 + 脏集失效口径，两者恒同步）；
   3. 进程内一致性边界（与 MdStore 相同的诚实边界）：跨进程/外部直接改写
      md 文件不保证可见——认知图的多进程形态（每智能体一进程）各持快照。
   4. **读失败不固化（C-3 / FI-M02 / N134，2026-09-29）**：只接纳「成功」与
@@ -67,7 +69,7 @@ def direct_read(cg, entry):
     return fn(entry)
 
 
-# 生效条件：cg 提供 _read_status（MdCG/MdCGSecure 恒有）时按其**三态标签**包装：第三元素为 None（成功 / 终态真缺）者照脏集精确失效口径入缓存，第三元素非 None（瞬时读失败，fsutil.READ_FAIL_TRANSIENT）者**一律不入缓存**（C-3：不得把可重试的读失败以「新鲜」身份固化）；cg 无 _read_status（非 MdCG 载体）时回落包装 cg._read，且空结果一律不接纳（无判别面时的保守侧：宁可重读，不可固化可能是瞬时的缺失）；cg._doc_norm_bigrams 存在时同款包装其派生物（_score 热点：文档侧归一化 bigram 只依赖 content，随读缓存一并常驻）；包装后 cg._read 与 cg._doc_norm_bigrams 走缓存、cg._read_cache/_norm_bigrams_cache 为缓存字典、cg._read_uncached 为**穿透缓存的原始二态 _read**（direct_read 的真源，返回形状与 install 前逐位一致）；返回缓存字典。
+# 生效条件：cg 提供 _read_status（MdCG/MdCGSecure 恒有）时按其**三态标签**包装：第三元素为 None（成功 / 终态真缺）者照脏集精确失效口径入缓存，第三元素非 None（瞬时读失败，fsutil.READ_FAIL_TRANSIENT）者**一律不入缓存**（C-3：不得把可重试的读失败以「新鲜」身份固化）；cg 无 _read_status（非 MdCG 载体）时回落包装 cg._read，且空结果一律不接纳（无判别面时的保守侧：宁可重读，不可固化可能是瞬时的缺失）；cg._doc_norm_bigrams 存在时同款包装其派生物（_score 热点：文档侧归一化 bigram 只依赖 content，随读缓存一并常驻）；cg._positive_body 存在时同款包装其派生物（_like 热点：剥除不适用条件后的正文只依赖 content，N273 与前者同一 path 键控 + 脏集失效口径）；包装后 cg._read 与 cg._doc_norm_bigrams/cg._positive_body 走缓存、cg._read_cache/_norm_bigrams_cache/_positive_body_cache 为缓存字典、cg._read_uncached 为**穿透缓存的原始二态 _read**（direct_read 的真源，返回形状与 install 前逐位一致）；返回缓存字典。
 def install(cg):
     """把 `cg._read`（与派生物钩子）包成**脏集精确失效**的常驻缓存。
 
@@ -189,14 +191,37 @@ def install(cg):
 
         cg._doc_norm_bigrams = _cached_nb
         cg._norm_bigrams_cache = nb_cache
+
+    # N273（第 32 轮性能面）：`_positive_body` 派生物同款缓存层——同 `entry`
+    # path 键、同 `_fresh` 脏集判据、同装载/失效时机（与 `_doc_norm_bigrams`
+    # 一字不差的同形结构，故两者命中率与失效行为恒同步）。修前 `_like` 每
+    # 查询对每个候选节点直调 `nodefile.positive_body`（逐行扫 CCG 声明段），
+    # 8000 池实测每次查询 ~102ms（占热态查询 ~47%）——它却是与 bigram 同
+    # 性质的纯函数（只依赖 content），缓存不对称在此收口。
+    pb_cache = {}
+    if hasattr(cg, "_positive_body"):
+        orig_pb = cg._positive_body
+
+        def _cached_pb(entry, content):
+            p = entry["path"]
+            gen = getattr(cg._dirty, "write_gen", len(cg._dirty))
+            hit = pb_cache.get(p)
+            if hit is not None and _fresh(p, hit):
+                return hit[1]
+            val = orig_pb(entry, content)
+            pb_cache[p] = (gen, val)
+            return val
+
+        cg._positive_body = _cached_pb
+        cg._positive_body_cache = pb_cache
     return cache
 
 
-# 生效条件：cg._read_cache 与 cg._norm_bigrams_cache 均清空（写侧显式兜底；哨兵之外的强制手段），返回清空的条目总数；无缓存时返回 0。
+# 生效条件：cg._read_cache、cg._norm_bigrams_cache 与 cg._positive_body_cache 均清空（写侧显式兜底；哨兵之外的强制手段），返回清空的条目总数；无缓存时返回 0。
 def clear(cg) -> int:
     """强制清空（外部批量改写文件后可手动调；正常写路径无需——哨兵自动失效）。"""
     n = 0
-    for attr in ("_read_cache", "_norm_bigrams_cache"):
+    for attr in ("_read_cache", "_norm_bigrams_cache", "_positive_body_cache"):
         c = getattr(cg, attr, None)
         if c:
             n += len(c)

package/md_cg/rollback.py

@@ -155,7 +155,7 @@ def collect_impact(cg, node_id):
     }
 
 
-# 生效条件：rel 指向的文件不存在时抛 RollbackError(code="preimage_missing")；存在则读取并以 cg._open_content(node_id, fm, raw) 对称解封，返回 (fm, content)——content 为 None（无密钥/身份不符）时抛 RollbackError(code="preimage_unreadable")；
+# 生效条件：rel 指向的文件不存在时抛 RollbackError(code="preimage_missing")；存在则读取并以 cg._open_content(node_id, fm, raw) 对称解封，返回 (fm, content)——content 为 None（无密钥/身份不符）时抛 RollbackError(code="preimage_unreadable")；文件含坏字节（非 UTF-8）无法解析时同样抛 RollbackError(code="preimage_unreadable")（fail-closed，不裸抛 UnicodeDecodeError）；
 def read_preimage(cg, node_id, rel):
     """读执行时点前像文件（**与 snapshot_preimage 对称**：写走 _write_node 封装、
     读走 _open_content 解封）——返回 (fm, content)。
@@ -163,14 +163,23 @@ def read_preimage(cg, node_id, rel):
     注意：快照文件以节点文件同款 nodefile 序列化落盘；加密库中其内容为密封
     形态，必须经解封钩子读，直接 nodefile.loads 会把密文当明文再次封装
     （双重封装）。非加密库两钩子恒等（探针实测逐字节一致）。
+
+    文件含坏字节（非 UTF-8）无法解析时抛 RollbackError(code="preimage_unreadable")
+    ——fail-closed，不裸抛 UnicodeDecodeError。
     """
     p = os.path.join(cg.root, str(rel).replace("/", os.sep))
     if not os.path.isfile(p):
         raise RollbackError("preimage_missing",
                             "前像文件不存在：%s——变更单可能未执行（无前像）"
                             "或快照被移走；fail-closed 不猜一个前像。" % rel)
-    with open(p, encoding="utf-8") as f:
-        fm, raw = nodefile.loads(f.read())
+    try:
+        with open(p, encoding="utf-8") as f:
+            fm, raw = nodefile.loads(f.read())
+    except UnicodeDecodeError as exc:
+        # 坏字节/非 UTF-8：fail-closed——绝不让 UnicodeDecodeError 裸抛逃逸
+        raise RollbackError("preimage_unreadable",
+                            "前像文件坏字节 / 非 UTF-8 无法解析：%s（%s）——"
+                            "fail-closed 不回滚。" % (rel, exc))
     content = cg._open_content(node_id, fm, raw)
     if content is None:
         raise RollbackError("preimage_unreadable",

package/md_cg/routing.py

@@ -314,7 +314,7 @@ def bucket_health(counts: dict, total_nodes: int = None) -> dict:
         # 巨桶/期望扫描两条在 nb==1 时只是同一事实的两种写法，合并为一条如实读数。
         # expected_scan 的**数值**仍在返回 dict 里（下游读的是数：test_p0 :92、
         # bench_axis_domain :159），只有文案不再把「未分区」说成「巨桶退化」。
-        problems.append(f"单桶：全库仅 1 个分桶（{n} 个节点同桶），"
+        problems.append(f"单桶：仅 1 个分桶（{n} 个已分桶节点同桶），"
                         "条件路由本就不可用（从未分区，非分区退化）")
     elif expected_scan > 0.30:
         problems.append(f"路由无效：期望扫描 {expected_scan:.1%}（接近全量）")
@@ -417,5 +417,14 @@ def classify_text(text, limit: int = 400):
 
     返回 None 表示「无有效域信号」——此时**不写** big_domain 字段，
     该节点留在 ORPHAN/兜底池（S1 收敛时必须能被兜底召回，见契约 §3 S1 不变量）。
+
+    issue #53-A：密文（`<!-- mdcg-enc:v1:…`）恒无域信号——无密钥的读面会把
+    密文**原样**交到这里，base64 噪声会碰巧命中词表（实测唯一命中形态＝「经济」：
+    词表里唯一的拉丁词 GDP 被 base64 三连子串撞上），且假标签会被 backfill 的
+    already 幂等分支永久固化。判据收在此**唯一致敏点**：节点侧全部调用方
+    （add 写入面、backfill 回填面）自动同覆盖，无需各自设防。
     """
+    from . import crypto        # 延迟导入：routing 是底层模块，避免加载序耦合
+    if crypto.is_encrypted(text):
+        return None
     return big_domain_classify(domain_terms(text, limit))

package/md_cg/selfreport.py

@@ -126,10 +126,19 @@ def read_all() -> dict:
     return out
 
 
-# 生效条件：pids 为可迭代的 pid 集合（通常是「当前进程表中仍在的 md_cg 进程」）；删除自报目录中 pid 不在该集合内的 *.json 与遗留 *.tmp，返回删除条数；目录不存在或删除失败逐项吞掉，不抛。
-def purge(pids) -> int:
-    """清掉不属于「仍在的进程」的自报文件（防目录随重启次数膨胀）。"""
+# 生效条件：pids 为可迭代的 pid 集合（通常是「当前进程表中仍在的 md_cg 进程」），allow_empty 为破坏性动作的显式开关；keep 非空时删除自报目录中 pid 不在该集合内的 *.json 与遗留 *.tmp 并返回删除条数；keep 为**空集**且 allow_empty=False（默认）时一律不删并返回 0——空集既可能是「在役进程真的全部退出」也可能是「探测失败/未经校验」，两者不可分，故清空须显式开启；目录不存在或删除失败逐项吞掉，不抛。
+def purge(pids, *, allow_empty: bool = False) -> int:
+    """清掉不属于「仍在的进程」的自报文件（防目录随重启次数膨胀）。
+
+    N255（2026-10-05）：keep 为空集时**默认不删任何东西**（fail-closed）——空集既可能来自
+    「在役进程确已全部退出」，也可能来自**一次失败/未经校验的探测**。后者在本仓实证过：
+    `scripts/mdcg_stale_servers.py` 的 scan() 尾部曾无条件调用 `purge([])`（探测失败 →
+    pids 为空），把自报目录下全部 *.json 一次删光（沙盒 3 件预置全灭）。确要清空时，由
+    **探测已成功**的调用方显式传 `allow_empty=True`（见该脚本的 purge_reports()）。
+    """
     keep = {int(p) for p in (pids or ())}
+    if not keep and not allow_empty:
+        return 0
     n = 0
     try:
         names = os.listdir(SELF_REPORT_DIR)