@furongjun1999/dsh-memory 0.7.2 → 0.7.4

package/md_cg/mdcos.py

@@ -37,7 +37,7 @@ from .mdcg import (MdCG, expand_query_terms, bigrams, normalize_en, STATE_ACCEPT
 from . import (nodefile, routing, chain, subgraph, forgetting, protect,
                identity, consistency, metacognition, crypto, sustain,
                self_state, predict, evolution, weights, pooling,
-               writelimit, reach, trust, roleviews, autonomy_modes)
+               writelimit, reach, trust, roleviews, autonomy_modes, lifecycle)
 from .fsutil import (FileLock, atomic_write, append_jsonl, read_jsonl,
                      read_jsonl_tail, count_jsonl, publish)
 from .security import (Principal, TenantRegistry, AccessDenied,
@@ -425,6 +425,26 @@ def _note_visible(cg, e) -> bool:
     return _security.visible_to(cg, e)
 
 
+# 生效条件：cg 索引的 nodes 中该 nid 有条目且 lifecycle.is_archived(该条目) 为真时返回 True；条目缺失时把 None 交给 state_of ⇒ 返回 False（fail-open，与判据单点同语义）。
+def _retired_by_id(cg, nid) -> bool:
+    """退役判据在「**按 id 取**的节点」上的单点包装（会话续接包台账段用）。
+
+    台账两段（goals / tasks）拿到的是 `_goal_entry` / `tasks._entry` 的**对外条目**
+    （只有 id，没有索引条目本身），故此处按 id 回查索引再交判据单点
+    `lifecycle.is_archived`——判据仍只此一份，不另立第二套口径。
+    """
+    e = ((getattr(cg, "index", None) or {}).get("nodes") or {}).get(nid)
+    return lifecycle.is_archived(e)
+
+
+#: 会话续接包台账段（goals / tasks）的取数窗：取全量再过滤退役再截断
+#: （`list_goals` 本就全表扫；`tasks.session_tasks` 内部本就先建全量列表再切片，
+#: 故不增遍历成本），避免「窗口内的 archived 被剔后不足额」。
+_LEDGER_WINDOW = 10 ** 6
+#: 台账段每段最终回出的条数（与改动前的 limit=5 逐位一致）。
+_PACK_ROWS = 5
+
+
 # 生效条件：以任意 root 构造时按其拼接 audit_log/hippocampus/trash 等路径并 makedirs 创建 hippocampus 与 trash_dir（exist_ok=True），autoflush 透传父类、actor 存入 self.actor；
 class MdCGOS(MdCG):
     """MdCG + 记忆 OS 七项能力。"""
@@ -747,7 +767,7 @@ class MdCGOS(MdCG):
                     payload_hash=_sig(content))
         return nid
 
-# 生效条件：在已用 root 构造的实例上遍历 index["nodes"]，恒剔除 layer 为 rejected/unresolved/goals 的节点，session 为真值而 e["session"] 不等于它时剔除，e["branch_id"] 不在 (None, branch) 时剔除（branch=None 时只留 branch_id 为 None 者），validity 为真值而 trust.is_expired(e) 为真时剔除（**只排已过期，not_yet 保留**），layer 为真值而 layer 不等时剔除，roles 不为 None 时仅留 role 落在 roles 内的节点；view 为真值时 role 维度裁决权移交 roleviews.matches（receipt=工作角色白名单须绕过默认剔除才可达，非法 view ValueError），view 为假值且 include_work 为假时剔除 WORK_ROLES 角色，时间算子启用时按 time_axis 轴过滤（效力轴不可判定 fail-open、观察轴不可判定 fail-closed 并入 self._time_filter_stat），其余收集进 out 返回。
+# 生效条件：在已用 root 构造的实例上遍历 index["nodes"]，恒剔除 layer 为 rejected/unresolved/goals 的节点，恒剔除 lifecycle.is_archived(e) 为真的节点（退役不参与默认检索；缺 lifecycle 键=active 照常，converged/demoted 仍参与），session 为真值而 e["session"] 不等于它时剔除，e["branch_id"] 不在 (None, branch) 时剔除（branch=None 时只留 branch_id 为 None 者），validity 为真值而 trust.is_expired(e) 为真时剔除（**只排已过期，not_yet 保留**），layer 为真值而 layer 不等时剔除，roles 不为 None 时仅留 role 落在 roles 内的节点；view 为真值时 role 维度裁决权移交 roleviews.matches（receipt=工作角色白名单须绕过默认剔除才可达，非法 view ValueError），view 为假值且 include_work 为假时剔除 WORK_ROLES 角色，时间算子启用时按 time_axis 轴过滤（效力轴不可判定 fail-open、观察轴不可判定 fail-closed 并入 self._time_filter_stat），其余收集进 out 返回。
     def _candidates(self, layer=None, roles=None, include_work=False,
                     session=None, branch=None, validity=None,
                     start_time=None, end_time=None, start_operator=None,
@@ -782,6 +802,19 @@ class MdCGOS(MdCG):
             if e.get("layer") in NEG_ROUTE_LAYERS:
                 continue  # 负记忆走覆盖标记；目标只做定向，都不进正排
                           # （真源 mdcg.NEG_ROUTE_LAYERS，本处直接导入，不留第二份字面量）
+            if lifecycle.is_archived(e):
+                continue  # lifecycle.py:42 标称兑现：archived 不参与默认检索。
+                          # 本处是 **cg 检索面单点**——`MdCGSecure._candidates`
+                          # 经 super() 在此之上叠加读可见性，故全部**检索类**
+                          # cg 读 op（search / search_rrf / recall / route…）经此
+                          # 一处。cg 的读 op 并非全走候选池：`op=session` 的续接包
+                          # 自持取数面，另在 `_session_notes` / `session_recall`
+                          # 接同一判据（见 lifecycle.is_archived 的消费面清单）。
+                          # 判据单点在 lifecycle.is_archived（fail-open：缺键=
+                          # active 照常；只剔 archived——converged/demoted 是
+                          # **降权轴**，仍参与默认检索）。
+                          # 直读面（cg.get / op=audit / 库层 set_state 恢复路径）**不**
+                          # 经本函数：退役不删除、可显式恢复。见 lifecycle.is_archived
             # '"*"' = 显式跨会话（读遍所有会话）；缺省 None 同义（见 stg.timeline）
             if session and session != "*" and e.get("session") != session:
                 continue
@@ -977,7 +1010,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 +1039,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 +1075,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 +1127,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 +1387,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"))
@@ -3143,11 +3186,18 @@ class MdCGOS(MdCG):
         return {"ok": True, "id": nid, "session": session, "layer": layer,
                 "basis": basis, "tokens": est_tokens(content)}
 
-# 生效条件：当 session 传入且为真时仅保留 tags 含 f"session:{session}" 的项；保留 tags 含 SESSION_TAG 或任一以 "session:" 开头的索引节点，且该索引条目经可见性单点 _readable 判为可见，_read 的 content 为 None 则跳过；按 created_at 降序后返回前 max(1, int(limit or 5)) 条，limit 为假值（含 0/None）按 5 处理；
+# 生效条件：当 session 传入且为真时仅保留 tags 含 f"session:{session}" 的项；恒剔除 lifecycle.is_archived(e) 为真的条目（退役不参与默认注入，判据单点在 lifecycle.py）；保留 tags 含 SESSION_TAG 或任一以 "session:" 开头的索引节点，且该索引条目经可见性单点 _readable 判为可见，_read 的 content 为 None 则跳过；按 created_at 降序后返回前 max(1, int(limit or 5)) 条，limit 为假值（含 0/None）按 5 处理；
     def _session_notes(self, session=None, limit=5):
         """按时间倒序取会话要点（索引过滤 + 可见性闸 + 惰性回读摘要）。只读，不写盘。"""
         out = []
         for nid, e in list((self.index.get("nodes") or {}).items()):
+            if lifecycle.is_archived(e):
+                continue               # 退役剔除（判据单点 lifecycle.is_archived，
+                                       # 与 cg 检索面 `_candidates`、stg 面
+                                       # `_scan_one` 同一份）：会话续接包是「把节点
+                                       # **内容摘要**回给调用方」的注入面，archived
+                                       # 不再参与默认注入（与 §5.2 退役纪律同口径）；
+                                       # fail-open：缺键/非法值=active 照常。
             tags = list(e.get("tags") or [])
             if self.SESSION_TAG not in tags and not any(
                     str(t).startswith("session:") for t in tags):
@@ -3181,7 +3231,7 @@ class MdCGOS(MdCG):
         out.sort(key=lambda n: (-n["created_at"], str(n.get("id") or "")))
         return out[:max(1, int(limit or 5))]
 
-# 生效条件：limit 经 max(1,min(int(limit or 5),50))、budget_tokens 经 max(200,int(budget_tokens or 1200)) 归一后逐段取数（include_state 为真才取 self_state），每段异常只把段名追加进 degraded，再由 while 循环按预算交替裁 recent/notes 尾部、任务段最后才裁并置 tasks_truncated。
+# 生效条件：limit 经 max(1,min(int(limit or 5),50))、budget_tokens 经 max(200,int(budget_tokens or 1200)) 归一后逐段取数（include_state 为真才取 self_state；会话要点段、未解问题段与台账两段（goals/tasks）恒剔除 lifecycle.is_archived 条目——退役不参与默认注入；台账段取全量窗过滤后再截断 `_PACK_ROWS` 条，`tasks.active_total/done_total` 取剔除后的全窗计数），每段异常只把段名追加进 degraded，再由 while 循环按预算交替裁 recent/notes 尾部、任务段最后才裁并置 tasks_truncated。
     def session_recall(self, session=None, limit=5, recent_limit=10,
                        budget_tokens=1200, include_state=True):
         """按需恢复：一次调用返回「可续接的上下文包」（替代 hook 自动注入）。
@@ -3193,6 +3243,15 @@ class MdCGOS(MdCG):
         任务段（2026-09-16 新增）是「忘记已实现的工程」的直接解药：新会话开机即见
         「还在做的」与「刚做完的」，不必先想到去查。任务属结构层、跨会话稳定，
         故**不按 session 过滤**——工程台账跟着工程走，不跟着会话走。
+
+        **退役口径（本包统一）**：本 op 是**注入面**（内容直接回给调用方/进上下文），
+        故四个取数段（notes / goals / tasks［active/done 两清单］/ unresolved；合计
+        五个清单）一律剔除
+        `lifecycle_state=archived`（判据单点 `lifecycle.is_archived`）——「退役不参与
+        默认注入」。`recent` 段是**事件窗口**（非节点）、`self_state` 是只读快照卡，
+        两者不含节点条目，不涉及退役。**管理查询面不受限**：`cg(op=goal, action=list)`
+        与 `cg(op=task, action=list)` 直读台账、archived 期间照常可达（两处不冲突：
+        同一份台账，注入面剔除、管理面直读）。
         """
         limit = max(1, min(int(limit or 5), 50))
         budget = max(200, int(budget_tokens or 1200))
@@ -3208,26 +3267,41 @@ class MdCGOS(MdCG):
         except Exception:                                  # noqa: BLE001
             pack["degraded"].append("notes")
         # ② 活跃目标（检索定向的默认来源）
+        # 退役剔除（判据单点 lifecycle.is_archived，经 `_retired_by_id` 按 id 取）：
+        # 续接包是**注入面**，archived 不参与默认注入（同 ① 与 ④）。取数窗取
+        # **全量**（limit=None）再过滤再截断——否则窗口内的 archived 被剔后不足额，
+        # 本该补位的在役目标补不上（`list_goals` 本就是全表扫，无额外成本）。
+        # 管理查询面 `cg(op=goal, action=list)` **不受限**（不经本函数、直读台账）。
         try:
             pack["goals"] = [{"id": g["id"], "goal": g["goal"],
                               "priority": g["priority"]}
-                             for g in self.active_goals(limit=5)]
+                             for g in self.active_goals(limit=None)
+                             if not _retired_by_id(self, g.get("id"))
+                             ][:_PACK_ROWS]
         except Exception:                                  # noqa: BLE001
             pack["degraded"].append("goals")
         # ②.5 任务台账（structural 层）——见 docstring：不按 session 过滤
+        # 退役剔除（同上，台账段是同一注入面的子段）：列表剔 archived、`*_total`
+        # 随之取**剔除后**的全窗计数（列表是它的前 `_PACK_ROWS` 条，两者同源自洽）；
+        # 管理查询面 `cg(op=task, action=list)` 仍直读台账、**不受限**。
         try:
             from . import tasks as _tasks
-            ts = _tasks.session_tasks(self, active_limit=5, done_limit=5)
+            ts = _tasks.session_tasks(self, active_limit=_LEDGER_WINDOW,
+                                      done_limit=_LEDGER_WINDOW)
+            _act = [t for t in ts["active"]
+                    if not _retired_by_id(self, t.get("id"))]
+            _done = [t for t in ts["done"]
+                     if not _retired_by_id(self, t.get("id"))]
             pack["tasks"] = {
                 "active": [{"id": t["id"], "name": t["name"], "status": t["status"],
                             "plan": (t.get("plan") or "")[:300],
                             "updated_at": t.get("updated_at")}
-                           for t in ts["active"]],
+                           for t in _act[:_PACK_ROWS]],
                 "done": [{"id": t["id"], "name": t["name"], "status": t["status"],
                           "result": (t.get("result") or "")[:300],
                           "updated_at": t.get("updated_at")}
-                         for t in ts["done"]],
-                "active_total": ts["active_total"], "done_total": ts["done_total"]}
+                         for t in _done[:_PACK_ROWS]],
+                "active_total": len(_act), "done_total": len(_done)}
         except Exception:                                  # noqa: BLE001
             pack["degraded"].append("tasks")
         # ③ 近期事件（原始滚动窗口）
@@ -3243,6 +3317,11 @@ class MdCGOS(MdCG):
             for nid, e in list((self.index.get("nodes") or {}).items()):
                 if e.get("layer") != "unresolved":
                     continue
+                if lifecycle.is_archived(e):
+                    continue           # 退役剔除（同 ① 会话要点：本条是续接包里
+                                       # 「未解问题正文片段回给调用方」的第二处注入
+                                       # 子面，判据仍是 lifecycle.is_archived 单点；
+                                       # fail-open 同上）
                 # N211（2026-09-28，本族第二出口，原树内并号 N209 按 v24 裁定改判）：与 ① 会话要点同根——此处也
                 # 是「只按 layer 过滤 → 回读正文 → 抽出 `# 问题：`」的直读出口，
                 # 无 _readable。实测：restricted 档未解问题的正文经 session_recall
@@ -4416,9 +4495,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（递归受深度/节点/循环/增益门槛约束）。
 
@@ -4436,7 +4521,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):
@@ -5103,8 +5188,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）：索引缺条目**不**等于「节点不存在」——本进程
@@ -5114,11 +5199,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/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/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)