@furongjun1999/dsh-memory 0.6.1 → 0.7.1

package/md_cg/mdcg.py

@@ -27,7 +27,7 @@ import secrets
 import threading
 
 from . import (nodefile, protect, routing, subgraph, chain, provenance, pooling,
-               lifecycle, reach, trust, roleviews, fsutil)
+               lifecycle, reach, trust, roleviews, fsutil, freshness)
 from .fsutil import (FileLock, ShardedLog, atomic_write, append_jsonl,
                      read_jsonl, sweep_stale_temps, note_bad_payload_rows)
 
@@ -280,12 +280,14 @@ 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 经**词法路**即可命中中文节点，而本函数
-        （召回词扩展侧）仍是默认关。两者不能互相推断，改动其一须核对
+        ⚠ 注意与**统一归一层**的区别（2026-09-24 澄清；2026-09-30 缺省翻关）：
+        `semantic/unify.py` 的 `unify_query` 是另一个开关，**缺省关**且**唯一开态
+        = 显式 "1"**（MDCG_UNIFY_QUERY，2026-09-30 使用者裁定由「默认 '1'」翻为
+        「未设即关」）——显式开启时它在检索入口把英文 query 归一成中文原子，
+        于是英文 query 经**词法路**即可命中中文节点；而本函数（召回词扩展侧）
+        是另一个独立开关（默认关，=1 才开）。两者不能互相推断，改动其一须核对
         test_en_pipeline / test_semantic_canonical 的双态断言；
+        unify 三态另有专件 `test_unify_default_off.py`（缺省态与两侧一致性）；
       - 仅当 query 含英文字母时触发，纯中文 query 零开销零变化；
       - 代词语素剔除（我/你/他…超泛词防污染），动词/名词单字语素保留
         （「吃/雨」在中文正文检索价值高，_score 终排兜底精度）；
@@ -605,6 +607,233 @@ def neg_condition_hits(neg_conditions, scene_text, own_topic_text="") -> list:
     return hits
 
 
+# ---- 拒绝域双语义：`boundary_hit`（§5.2，P0-4）-----------------------------
+# 背景（v0.4 §5.2）：同一个字段 `non_applicable_conditions` 上会挂**两条**语义——
+#   ① 负条件判据：命中当前情境 ⇒ 资格 REJECT（`judge_qualification` 的第 2 段，
+#      走单点 `neg_condition_hits`）；
+#   ② 正面检索键：问「什么条件下不适用」时，该节点应当**被召回、被展示**，
+#      标记 `boundary_hit`——这正是 §5.1 给「不适用条件」定的索引角色（拒绝域词）。
+# 两条语义必须**可分**：否则默认链路上会出现自否定（用户问边界，节点因边界被否）。
+# 记忆里那条返工教训（检索面 REJECT 46→0）即此类失真的先例。
+
+#: 拒绝域命中的**展示标记**（§5.2：可召回、可展示；与资格 REJECT 分开呈现）。
+BOUNDARY_MARKER = "boundary_hit"
+
+#: 「把不适用条件当检索键」的问句意图标记——§5.1 检索用法列的原话即
+#: 「什么条件下不适用」；其余为同义形态（中文检索面的问句变体）。
+BOUNDARY_QUERY_MARKERS = ("不适用条件", "不适用", "什么条件下不适用",
+                          "什么情况下不适用", "何时不适用", "边界条件", "拒绝域")
+
+#: 「把验证方式当检索键」的问句意图标记——§5.1 检索用法列的原话即
+#: 「是怎么验证的 / 用什么方法证明的」（P2-1 新增的第 5 行「后置条件词」）。
+POSTCONDITION_QUERY_MARKERS = ("验证方式", "怎么验证", "如何验证", "怎样验证",
+                               "怎么证明", "如何证明", "用什么方法证明",
+                               "验证手段", "怎么被验证", "有无验证")
+
+
+# 生效条件：query 为字符串（假值按空串）时，逐个取 POSTCONDITION_QUERY_MARKERS 判断是否为子串，任一命中即返回 True，全部不命中返回 False；只做字面可判的**意图识别**，不做分词/语义推断。
+def is_postcondition_query(query: str) -> bool:
+    """查询是否在问节点的**验证方式本身**（§5.1「验证方式 → 后置条件词」）。
+
+    与 `is_boundary_query` 同款形态（同一处 marker 表的兄弟判据，不另起机制）：
+    命中即按「验证手段」检索——召回那些**声明了验证方式**的节点。
+    """
+    q = str(query or "")
+    return any(m in q for m in POSTCONDITION_QUERY_MARKERS)
+
+
+# 生效条件：fm 与 content 任意（缺键按空处理）时，取 CCG `# 不适用条件：` 行（走 nodefile.ccg_element_terms 的取值+切分单点）与 fm.non_applicable_conditions 逐条经 nodefile.element_terms_from_text 切分后的词项，按「CCG 行在前、fm 列表在后」的顺序去重，返回保序词项列表。
+def rejection_index_terms(fm, content) -> list:
+    """「不适用条件」的**索引键**词项——**与资格判据同字段**（§5.2 双语义前提）。
+
+    两处来源合并（保序去重），都从严归一为词项：
+      ① CCG 正文行 `# 不适用条件：`（`nodefile.ccg_field_value` 取值单点）；
+      ② `frontmatter.non_applicable_conditions`——**资格 REJECT 判据
+         （`judge_qualification`）与 `boundary_hit` 读的就是这个字段**。
+    两条语义共用同一份词项，才可能在「同一字段上可分」（否则索引键与拒绝域
+    判据各读一处，检索面的边界命中与资格面的 REJECT 会对不上）。
+
+    ⚠ 本键**只用于召回/展示**（拒绝域词）：它进索引条目后由 `_like` 侧消费，
+    不参与 `judge_qualification` 的否决路径——否决路径仍读 frontmatter 原列表，
+    经 `neg_condition_hits` 单点判定，灵敏度一字不动。
+    """
+    out, seen = [], set()
+    line_terms = nodefile.ccg_element_terms(content, nodefile.REJECTION_FIELD)
+    fm_terms = nodefile.element_terms_from_text(
+        "；".join(str(x) for x in ((fm or {}).get("non_applicable_conditions") or [])))
+    for t in list(line_terms) + list(fm_terms):
+        if t and t not in seen:
+            seen.add(t)
+            out.append(t)
+    return out
+
+
+# 生效条件：entry 为索引条目（六要素后两行的索引键在其中）、terms 为查询词项列表（可为空）、query 为字符串时，按「postcondition_terms 被任一查询词项命中」或「验证方式问句（is_postcondition_query）且该节点声明了验证方式」判 post，按「边界问句（is_boundary_query）且该节点声明了拒绝域」判 reject，返回 {"hit": post 或 reject 的布尔, "post": bool, "reject": bool, "why": [命中的判据名]}；
+def index_key_hits(entry, terms, query) -> dict:
+    """六要素后两行索引键的**召回判据单点**（§5.4 全进默认检索 / §5.2 双语义）。
+
+    两条键的**不对称**是刻意的，也正是 §5.2 要求的「同一字段、两条语义可分」：
+
+      · **验证方式 → 后置条件词**：`postcondition_terms` 作为**正面**召回键
+        （节点自己声明「是怎么验证的」），既可以由查询词项命中（如查询含
+        `compiler`，节点 `# 验证方式：compiler test`），也可以由**验证方式问句**
+        （`is_postcondition_query`：§5.1 的「是怎么验证的 / 用什么方法证明的」）
+        召回「声明了验证方式」的节点；
+      · **不适用条件 → 拒绝域词**：**只在边界问句上**放开召回——普通问句下
+        拒绝域仍**不作召回键**（`nodefile.positive_body` 的既有立场：反例命中
+        只应由资格判定 REJECT，把它当召回键会「恰好在它不该适用的地方召回它」，
+        属实质性错误）。边界问句（`is_boundary_query`：§5.1 的「什么条件下不适用」）
+        问的就是边界本身，此时召回「声明了拒绝域」的节点正是设计要的行为，
+        且该回收面按 §5.2 标记 `boundary_hit`、与资格 REJECT **分开计数**。
+
+    取数一律来自**索引条目**（免读文件）；键缺失（旧库未重建）时判 False，
+    即行为退回改动前（零破坏）。
+    """
+    e = entry or {}
+    hits = {"hit": False, "post": False, "reject": False, "why": []}
+    q = str(query or "")
+    post = e.get(nodefile.POSTCONDITION_TERMS_KEY) or []
+    if post:
+        if any(t in " ".join(post) for t in (terms or [])):
+            hits["post"] = True
+            hits["why"].append("postcondition_terms:term")
+        elif is_postcondition_query(q):
+            hits["post"] = True
+            hits["why"].append("postcondition_terms:declared")
+    rej = e.get(nodefile.REJECTION_TERMS_KEY) or []
+    if rej and is_boundary_query(q):
+        hits["reject"] = True
+        hits["why"].append("rejection_terms:declared")
+    hits["hit"] = bool(hits["post"] or hits["reject"])
+    return hits
+
+
+# 生效条件：node_dict 为 {frontmatter, content}（缺键按空处理）、query 为字符串、context 为 dict 或 None 时，先取 nodefile 的拒绝域词项（ccg_element_terms 走 CCG 行解析单点 + frontmatter.non_applicable_conditions）与 P0-4 的 boundary_hit 判据；二者任一命中即 hit=True，返回 {"hit": bool, "terms": [命中原样条目], "marker": "boundary_hit" 或 None, "why": [命中来源名], "reason": str}；
+def boundary_mark(node_dict, query, context=None) -> dict:
+    """**边界命中标记的唯一单点**（§5.2 检索面的展示判据）。
+
+    两条来源，判据全部复用既有单点（不另写第二份）：
+
+      ① **情境落在拒绝域**：`boundary_hit`（P0-4 已落）——查询/情境命中该节点的
+         `non_applicable_conditions`（走 `neg_condition_hits` 单点）；
+      ② **边界问句 ∧ 该节点声明了拒绝域**：`is_boundary_query(query)` 为真且
+         `rejection_index_terms` 非空——这正是 §5.1 第 6 行的检索用法
+         「什么条件下不适用」：用户问的就是边界，回的就是「它声明了什么边界」。
+         ②的取数与**索引键**同源（`rejection_index_terms`），故索引侧与展示侧
+         不会各说各话。
+
+    `marker` 恒为 `BOUNDARY_MARKER`（"boundary_hit"）——它是**展示标记**，
+    与资格判定的 REJECT **分开呈现、分开计数**（§5.2）。
+    """
+    bh = boundary_hit(node_dict, query, context)
+    fm = (node_dict or {}).get("frontmatter") or {}
+    content = (node_dict or {}).get("content") or ""
+    why, terms = [], []
+    if bh.get("hit"):
+        why.append("scene_in_rejection_domain")
+        terms.extend(bh.get("terms") or [])
+    if is_boundary_query(query):
+        rej = rejection_index_terms(fm, content)
+        if rej:
+            why.append("boundary_query_and_declared")
+            for t in rej:
+                if t not in terms:
+                    terms.append(t)
+    hit = bool(why)
+    return {"hit": hit, "terms": terms,
+            "marker": BOUNDARY_MARKER if hit else None, "why": why,
+            "reason": ("边界命中（%s）：可召回可展示；不影响其正例资格"
+                       % "、".join(why) if hit else "未落在边界面上")}
+
+
+# 生效条件：query 为字符串（假值按空串）时，逐个取 BOUNDARY_QUERY_MARKERS 判断是否为子串，任一命中即返回 True，全部不命中返回 False；只做字面可判的**意图识别**，不做分词/语义推断。
+def is_boundary_query(query: str) -> bool:
+    """查询是否在问该节点的**拒绝域本身**（§5.1「不适用条件 → 拒绝域词」）。
+
+    这是双语义的分界：是 ⇒ 命中属**边界命中**（可召回可展示，不得因此 REJECT）；
+    否 ⇒ 命中仍是资格面的负条件（照旧 REJECT，灵敏度不变）。
+    """
+    q = str(query or "")
+    return any(m in q for m in BOUNDARY_QUERY_MARKERS)
+
+
+# 生效条件：node_dict 为 {frontmatter, content}（缺键按空处理）且 query 为字符串时，以 frontmatter.non_applicable_conditions 为拒绝域词面、以 json({"query":query, **context}) 为情境（与 judge_qualification 同一情境口径）、以 MdCG._self_topic_text(fm, content) 为自主题面，调单点 neg_condition_hits 取命中；返回 {"hit": bool, "terms": [命中原样条目（按首次出现序）], "marker": "boundary_hit" 或 None, "reason": str, "scene": str}。
+def boundary_hit(node_dict, query, context=None) -> dict:
+    """把「不适用条件」当**正面检索键**命中该节点的判据（**不产生 REJECT**）。
+
+    与资格判定的负条件腿**共用同一个单点**（`neg_condition_hits`）——两条语义
+    共享判据实现，只在**归类**上分开：本函数只回答「查询是否落在该节点的拒绝域上、
+    可否召回展示」，一律不动 qualification。
+
+    返回形状（P2 直接调用）::
+
+        {"hit": bool,            # 是否边界命中（可召回、可展示）
+         "terms": [str, ...],    # 命中的不适用条件条目（原样、按首次出现序）
+         "marker": str | None,   # 命中即 BOUNDARY_MARKER（"boundary_hit"），否则 None
+         "reason": str,          # 人类可读依据
+         "scene": str}           # 本判据用的情境串（与 judge_qualification 同口径）
+    """
+    fm = (node_dict or {}).get("frontmatter") or {}
+    content = (node_dict or {}).get("content") or ""
+    scene = {"query": query or ""}
+    if isinstance(context, dict):
+        scene.update(context)
+    scene_str = json.dumps(scene, ensure_ascii=False)
+    terms = fm.get("non_applicable_conditions") or []
+    hit = neg_condition_hits(terms, scene_str, MdCG._self_topic_text(fm, content))
+    return {"hit": bool(hit), "terms": hit,
+            "marker": BOUNDARY_MARKER if hit else None,
+            "reason": (("边界命中：查询落在该节点的拒绝域（不适用条件）上，"
+                        "可召回可展示；不影响其正例资格") if hit
+                       else "未落在该节点的拒绝域上"),
+            "scene": scene_str}
+
+
+# 生效条件：text 为字符串（假值按空串）、terms 为可迭代条目表时，逐条把其原样字面量与「去空白后的字符间容忍任意空白」形态从 text 中替换为空格；返回替换后的字符串（terms 为空即原样返回）。
+def strip_boundary_terms(text: str, terms) -> str:
+    """从查询串里摘掉命中的拒绝域条目（只用于**边界问句**的资格判定）。
+
+    为什么摘：用户问的就是「这些条件下不适用」——把这些词面留在资格判定的情境里，
+    等于让节点因为「被问到自己的拒绝域」而 REJECT（自否定）。摘掉后资格判定问的
+    是**除边界词面之外的**情境，命中的是用户的真实处境。
+    """
+    out = str(text or "")
+    for t in (terms or []):
+        s = str(t)
+        if not s:
+            continue
+        if s in out:
+            out = out.replace(s, " ")
+        ns = re.sub(r"\s+", "", s)
+        if ns and ns != s:                     # 条目内含空白 → 容忍任意空白形态
+            out = re.sub(r"\s*".join(re.escape(ch) for ch in ns), " ", out)
+    return out
+
+
+# 生效条件：records 为 judge_with_boundary 返回体或 None 的可迭代时，逐条累加其 qualification.state（归一后属 accept/reject/defer/blindspot 者）、boundary.hit 与 recallable，返回 {"total","accept","reject","defer","blindspot","boundary_hit","recallable","self_negation"}——self_negation 为「边界问句下既边界命中又被资格 REJECT」的条数（**应为 0**：非 0 即双语义串味、自否定残留）。
+def tally_boundary(records) -> dict:
+    """把逐条判定汇总成**分开计数**的读数（P2 检索面出数用）。"""
+    out = {"total": 0, "accept": 0, "reject": 0, "defer": 0, "blindspot": 0,
+           "boundary_hit": 0, "recallable": 0, "self_negation": 0}
+    for r in (records or []):
+        if not isinstance(r, dict):
+            continue
+        out["total"] += 1
+        qual = r.get("qualification") or {}
+        st = str(qual.get("state") or "").strip().lower()
+        if st in ("accept", "reject", "defer", "blindspot"):
+            out[st] += 1
+        bh = bool((r.get("boundary") or {}).get("hit"))
+        if bh:
+            out["boundary_hit"] += 1
+        if r.get("recallable"):
+            out["recallable"] += 1
+        # 自否定 = 边界问句（判据已摘词面重跑）却仍 REJECT——应为 0
+        if qual.get("boundary_suppressed") and st == "reject":
+            out["self_negation"] += 1
+    return out
+
+
 # 生效条件：当 `query` 为字符串时，返回含整句、≥2 字符分词及命中 `SYNONYM_GROUPS_WEIGHTED` 组加权项（同名取最大权重）的字典；空串返回 `{}`。
 def expand_query_terms_weighted(query: str) -> dict:
     """分级版查询扩展：返回 {词: 隶属度}，隶属度 ∈ (0, 1]。
@@ -957,6 +1186,12 @@ class _DirtyDict(dict):
         self.write_gen = 0
         self.path_gen = {}      # path → 该 path 最近一次标脏时的 write_gen
         self.broad_gen = 0      # 最近一次无 path 可辨变更的 write_gen（整池兜底）
+        # N230（2026-10-01）：**落盘逐字见证**——nid → 标脏那一刻节点文件的
+        # (st_mtime_ns, st_size)。`MdCG.__init__` 负责注入 `root`（本类不反查
+        # 宿主，免得与 MdCG 的构造顺序耦合）。语义与用法见
+        # `MdCG._dirty_entry_superseded`。
+        self.root = None
+        self.staged_stat = {}
 
     def _bump(self):
         self.write_gen += 1
@@ -969,13 +1204,36 @@ class _DirtyDict(dict):
         else:
             self.broad_gen = self.write_gen
 
+    # 生效条件：k 为节点 id、v 为 entry；恒 pop 该 k 的旧见证，随后仅当 v 为含非空 path 字符串的 dict 且 self.root 为真、且 os.stat(root/path) 成功时记入 self.staged_stat[k]=(st_mtime_ns, st_size)；其余情形（None tombstone / 无 path / stat 失败 / 无 root）不登记——不登记即「证不出陈旧」，重放按旧口径放行。
+    def _note_witness(self, k, v):
+        """落盘逐字见证的登记（N230）。
+
+        为什么记 (mtime_ns, size)：`_maybe_reload_index` 需要判「本实例这条
+        未 flush 的写入，是不是已经被他进程后来写下的**更新**记录盖过」。节点
+        文件是唯一真源——标脏时它长什么样，重放时再 stat 一次，不一样就说明
+        盘面已被别人改过（改写内容必然改 mtime_ns；NTFS 粒度 100ns）。
+        stat 失败与无 path 一律不登记：**证不出陈旧就不当陈旧**——「本实例未
+        落盘写入不因重载从检索面消失」是既有不变量，宁可漏挡也不误杀。
+        """
+        self.staged_stat.pop(k, None)
+        p = v.get("path") if isinstance(v, dict) else None
+        if not (isinstance(p, str) and p and self.root):
+            return
+        try:
+            st = os.stat(os.path.join(self.root, p))
+        except OSError:
+            return
+        self.staged_stat[k] = (st.st_mtime_ns, st.st_size)
+
     def __setitem__(self, k, v):
         self._bump()
         self._note(v)
+        self._note_witness(k, v)
         super().__setitem__(k, v)
 
     def __delitem__(self, k):
         self._bump()
+        self.staged_stat.pop(k, None)
         self.broad_gen = self.write_gen
         super().__delitem__(k)
 
@@ -996,26 +1254,31 @@ class _DirtyDict(dict):
         self._bump()
         if broad:
             self.broad_gen = self.write_gen
+        self.staged_stat.clear()
         super().clear()
 
     def pop(self, k, *d):
         self._bump()
+        self.staged_stat.pop(k, None)
         self.broad_gen = self.write_gen
         return super().pop(k, *d)
 
     def popitem(self):
         self._bump()
         self.broad_gen = self.write_gen
+        self.staged_stat.clear()      # 摘哪条不确定，保守清空（下一轮按「无见证」放行）
         return super().popitem()
 
     def setdefault(self, k, d=None):
         self._bump()
         self.broad_gen = self.write_gen
+        self.staged_stat.pop(k, None)
         return super().setdefault(k, d)
 
     def update(self, *a, **k):
         self._bump()
         self.broad_gen = self.write_gen
+        self.staged_stat.clear()
         super().update(*a, **k)
 
 
@@ -1174,6 +1437,11 @@ class MdCG:
         self.recent_log = os.path.join(self.root, "_recent.jsonl")
         self.autoflush = autoflush
         self._dirty = _DirtyDict()
+        # N230：把数据根交给脏集——标脏时按 entry["path"] 落「逐字见证」
+        # （见 _DirtyDict._note_witness / MdCG._dirty_entry_superseded）。
+        self._dirty.root = self.root
+        # 最近一次重载里被判定「已被盘面更新盖过」而未重放的条数（只作可观测读数）
+        self._dirty_replay_superseded = 0
         # realpath 进程内缓存（性能批次，候选 a）：root 解析一次 + rel→abs
         # 解析结果 memo 化，失效哨兵与 readcache 同源（见 _node_disk_path）。
         self._root_real = None
@@ -1183,6 +1451,12 @@ class MdCG:
         # （自身写入已由 _stage 落进内存索引，计入签名会让每次自身 flush 都被
         # 判成「他进程变化」→ 自身写入触发全量自重载）。flush() 里登记。
         self._own_shard = None
+        # 第 3 层结构索引（设计稿 §3.2）：装载期内存倒排，**首次 stg 访问时**才构建
+        # （惰性）；写路径经 `_set_index_entry`/`_remove_index_entry` 同钩增量维护，
+        # 整体换索引的路径（重载/compact/rebuild）经 `_invalidate_stg_index` 失效后
+        # 由下次访问重建。占用面：1.7 万节点 ≈ 三张小表 + 位序/分类两表（内存派生，
+        # 不改磁盘格式）。
+        self._stg_index = None
         self.index = self._load_index()
         # P1b-2（2026-09-26，DSH 在役复验）：索引只在本行装载一次，此后
         # read/get/search 全走内存态——其它进程（review_cli autoflush=1）
@@ -1324,7 +1598,37 @@ class MdCG:
             parts.append((fn, s.st_size, s.st_mtime_ns))
         return (snap, tuple(parts))
 
-# 生效条件：stat 对比 _index_signature() 与 self._index_sig，相等（含双侧 None）即返回 False 不做任何事；不等则调 _load_index() 重载，OSError/ValueError 时静默放弃并返回 False（重载失败不阻塞读，沿用旧内存态）；成功后把 self._dirty 重放回新索引（None=tombstone pop、否则覆盖，与 _load_index 的日志重放同语义——本实例未 flush 的写入不得因重载从检索面消失）并重算 buckets，替换 self.index、刷新 self._index_sig、返回 True；
+# 生效条件：self._dirty.staged_stat 中无该 nid 的见证、或 self._dirty[nid] 非含非空 path 的 dict 时返回 False；有见证时对 root/path 再 stat 一次——OSError（文件已不在，标脏时在）返回 True，成功则返回 (st_mtime_ns, st_size) 与见证不等的布尔（不等即 True）。
+    def _dirty_entry_superseded(self, nid) -> bool:
+        """本实例 `_dirty[nid]` 是否**已被盘面更新盖过**（N230：旧不得盖新）。
+
+        判据是**节点文件的逐字见证**：标脏那一刻记下 `(st_mtime_ns, st_size)`，
+        重放前再 stat 一次；不相等 ⇒ 盘面已被他进程改写过 ⇒ 本实例这条是旧的，
+        重放必须放行盘面（`_maybe_reload_index` 据此跳过本条）。
+
+        三条边界（都是有意的）：
+        · **证不出陈旧就不当陈旧**：无见证（无 path / stat 失败 / `_dirty` 未挂
+          root）返回 False ⇒ 照旧重放——「本实例未落盘写入不因重载从检索面消失」
+          这条既有不变量优先于本缺陷的覆盖面。
+        · **tombstone（`None`）不走本判据**：`_unstage` 立即 flush（删除不延迟到
+          autoflush 阈值），故 tombstone 实际上极少跨重载存活；其语义一字不改。
+        · **同内容改写**：他进程用同样的字节重写（size 同）时 mtime_ns 仍会变，
+          故仍判陈旧——放行的盘面条目与本条同义，结果无差。
+        """
+        st = self._dirty.staged_stat.get(nid)
+        if st is None:
+            return False
+        e = self._dirty.get(nid)
+        p = e.get("path") if isinstance(e, dict) else None
+        if not p:
+            return False
+        try:
+            cur = os.stat(os.path.join(self.root, p))
+        except OSError:
+            return True                # 标脏时文件在、现在不在 ⇒ 盘面确已变
+        return (cur.st_mtime_ns, cur.st_size) != st
+
+# 生效条件：stat 对比 _index_signature() 与 self._index_sig，相等（含双侧 None）即返回 False 不做任何事；不等则调 _load_index() 重载，OSError/ValueError 时静默放弃并返回 False（重载失败不阻塞读，沿用旧内存态）；成功后把 self._dirty 重放回新索引（None=tombstone pop、否则覆盖，与 _load_index 的日志重放同语义——本实例未 flush 的写入不得因重载从检索面消失；N230：见证失配者判为陈旧，**跳过重放**并计入 self._dirty_replay_superseded）并重算 buckets，替换 self.index、刷新 self._index_sig、返回 True；
     def _maybe_reload_index(self):
         """读路径入口的索引代际感知（P1b-2）：签名变化才重载。
 
@@ -1340,6 +1644,14 @@ class MdCG:
           （flush）都改变签名 → 此时重载并重放分片日志（_load_index 既有行为），
           写入可见；本实例 _dirty 未 flush 的条目在重载后**重放回内存索引**——
           _stage 双写 index+_dirty 的「检索看得到未落盘写入」语义保持。
+
+        N230（2026-10-01，**旧盖新**）：原实现无条件 `idx["nodes"][nid] = e`——
+        本实例标脏后**他进程重写过同一节点**时，重载取回的是更新记录，随即被
+        本地这条更旧的盖了回去（实测：盘面与新建读者实例都是 NEW，本实例索引
+        仍停在 OLD，`content_hash` 与盘面撕裂）。现按「**逐字见证**」判陈旧：
+        `_dirty_entry_superseded` 为真即**放行盘面**（跳过本条重放），并在
+        `self._dirty_replay_superseded` 留下条数读数。见证拿不到的条目照旧重放
+        ——「本实例未落盘写入不因重载从检索侧消失」这条不变量一并保留。
         """
         sig = self._index_signature()
         if sig == self._index_sig:
@@ -1348,13 +1660,27 @@ class MdCG:
             idx = self._load_index()
         except (OSError, ValueError):
             return False                # 重载失败不阻塞读：沿用旧内存态
+        superseded = 0
         for nid, e in self._dirty.items():
             if e is None:
                 idx["nodes"].pop(nid, None)
-            else:
-                idx["nodes"][nid] = e
+                continue
+            # N230（2026-10-01）：**新记录必须能盖住旧记录，旧不得盖新**。
+            # 重载后的 idx 来自快照（指纹校验过盘面）或全库扫描，两者都反映
+            # **当前盘面**；本实例这条 `_dirty` 若在标脏后盘面已被改过（逐字
+            # 见证失配），它就是旧的——放行盘面，不得盖回去。见证拿不到时
+            # 照旧重放（见 _note_witness 的「证不出陈旧就不当陈旧」）。
+            if self._dirty_entry_superseded(nid):
+                superseded += 1
+                continue
+            idx["nodes"][nid] = e
+        self._dirty_replay_superseded = superseded
         idx["buckets"] = self._count_buckets(idx["nodes"])
         self.index = idx
+        # 第 3 层结构索引随整体换索引一并失效：重载取回的是**另一份**快照
+        # （他进程写的新记录/新盘面），旧表按身份判代际必然不符——显式丢表，
+        # 下次 stg 访问按新快照重建（惰性失效重建，与 rebuild/compact 同路）。
+        self._invalidate_stg_index()
         self._index_sig = sig
         # 旧索引代里的派生缓存一并失效：query 结果缓存（hotcache，默认关）
         # 缓存的是旧候选池上的结果；解析读缓存（readcache，默认开）按 path
@@ -1469,13 +1795,20 @@ class MdCG:
             atomic_write(self.index_path, json.dumps(idx, ensure_ascii=False))
             ShardedLog.clear(self.index_log_dir)
         self.index = idx
+        # 第 3 层结构索引随快照替换失效（快照重建过，旧表与它的划分关系不再
+        # 有据可依）：下次 stg 访问重建；不在此处立即重算——compact 是收尾路
+        # 径，重建成本挪到真正需要索引的那次读（惰性失效重建，同一选）。
+        self._invalidate_stg_index()
         # P1b-2：自己写了快照 → 主动刷新签名，防止后续读路径把自己的
         # compact 误判为「他进程写入」而做一次无谓重载（自写自载循环）。
         self._index_sig = self._index_signature()
         return idx
 
-# 生效条件：self._dirty 非空时才在 FileLock(index_path) 下（必要时新建 ShardedLog）逐条 append、清空 _dirty 并关闭分片句柄；self._dirty 为空时立即返回、不写任何记录；
+# 生效条件：self._dirty 非空时才在 FileLock(index_path) 下（必要时新建 ShardedLog）逐条 append、清空 _dirty 并关闭分片句柄；self._dirty 为空时立即返回、不写任何记录；**不动 self.index、不失效第 3 层结构索引**——flush 只落索引派生物（分片日志），内存快照与其划分表本就不变（「flush 后表与快照一致」由守卫钉住）；
     def flush(self):
+        # 第 3 层结构索引（stgidx）：flush **不失效**——它不改内存索引（记录早在
+        # `_stage` 时就已同钩进表），若每次 flush 都丢表，惰性重建会在写读交替
+        # 负载下每轮重扫（与 readcache「写谁失效谁」同款纪律）。
         if not self._dirty:
             return
         # 世代/互斥防线（批次9，M3.3 落地）：append 必须与 compact/rebuild 的
@@ -1527,7 +1860,7 @@ class MdCG:
             self._log.close()
             self._log = None
 
-# 生效条件：以节点文件绝对路径 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 清洗后返回；
+# 生效条件：以节点文件绝对路径 p、其所在层目录名 layer、解析出的 fm 与 content 为入参，构造含 path（相对 root 正斜杠）/layer（fm 回落 layer）/role/content_kind/session/tags/bucket（父目录名，等于层名时 None）/bucket_zh/importance/importance_source（issue50-d：fm 键缺省 None）/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 共用的**唯一真源**。
 
@@ -1559,9 +1892,27 @@ class MdCG:
             # S1b 跨语言收敛免读文件可判。
             "bucket_zh": fm.get("bucket_zh") or None,
             "importance": fm.get("importance", 0.5),
+            # issue50-d（2026-10-02）：重要度**来源**入快照（"hint"|"heuristic"，
+            # 旧库无此键 → None）——「这条 0.8 是显式声明还是启发式分」免读
+            # 文件可判（与既有扁平键同理由：检索期/审计期不读盘）。
+            "importance_source": fm.get("importance_source"),
             "created_at": fm.get("created_at", 0),
             "verification_basis": fm.get("verification_basis"),
             "has_neg_conditions": nodefile.has_non_applicable(content),
+            # ── P2-1（§5.1 六要素 6 行）：后两行的**索引键**入快照 ──────────
+            # 验证方式 → 后置条件词；不适用条件 → 拒绝域词。与既有
+            # `time_window`/`observation_position` 同为**免读文件可判的扁指标量**
+            # （同款理由：检索期不读盘；§5.4「全进默认检索」的取数面即此）。
+            # 取值一律走 `nodefile` 的 CCG 行解析单点（检索面不另写正则）。
+            nodefile.POSTCONDITION_TERMS_KEY:
+                nodefile.ccg_element_terms(content, nodefile.POSTCONDITION_FIELD),
+            nodefile.REJECTION_TERMS_KEY: rejection_index_terms(fm, content),
+            # ── P4-2①（§7.2 卡点一）：访问计数入快照 ────────────────────────
+            # `access_count`/`last_access` 此前只记账（`_access.log` → 折叠落
+            # frontmatter），检索想用只能读盘（违反「检索不写少读」）——故与
+            # 上面两行同款：免读文件的扁指标量，供 `_score` 的刷新乘子取数。
+            "access_count": fm.get("access_count", 0),
+            "last_access": fm.get("last_access", 0),
             # 内容指纹走 nodefile 的唯一实现（两段式对账依赖同一算法）
             "content_hash": nodefile.content_hash(content),
             # 时空字段入索引快照：STG 查询免读文件（大域/目录索引的延伸）
@@ -1649,6 +2000,10 @@ class MdCG:
             atomic_write(self.index_path, json.dumps(idx, ensure_ascii=False))
             ShardedLog.clear(self.index_log_dir)
         self.index = idx
+        # 第 3 层结构索引随全量重建失效（新快照 = 新盘面语义）：下次 stg 访问
+        # 重建——重建后的划分不变量由守卫钉住（写/删/rebuild/compact 后三表与
+        # 快照一致）。
+        self._invalidate_stg_index()
         # P1b-2：rebuild 同 compact——写完快照即刷新签名（自写不自载）。
         self._index_sig = self._index_signature()
         # broad=True：rebuild 以盘面扫描为准——ccgc/crosscheck/backfill 等
@@ -1716,7 +2071,8 @@ class MdCG:
             derived_from=None, relation: str = provenance.DEFAULT_RELATION,
             semantic: str = None, depends_on=None, valid_from=None,
             valid_until=None, effective_from=None, effective_until=None,
-            believed_at=None, verification_state: str = None, **extra) -> str:
+            believed_at=None, verification_state: str = None,
+            importance_source: str = None, **extra) -> str:
         """写入一个节点。
 
         verification_basis: 外部验证基底（白箱信任的硬门槛），
@@ -1906,6 +2262,11 @@ class MdCG:
             "evidence_count": 0, "positive_evidence": 0, "negative_evidence": 0,
         }
         fm.update(extra)
+        # issue50-d（2026-10-02）：重要度**来源**声明（"hint"|"heuristic"）落
+        # frontmatter——下游免读文件即可判「这条 0.8 是显式声明还是闸门启发式
+        # 分」。缺省 None 不落键（既有调用方 fm 形态逐位不变，零回归）。
+        if importance_source:
+            fm["importance_source"] = importance_source
         if bucket_zh:
             fm["bucket_zh"] = bucket_zh
         # S1 大域先验：写入时固化「内容 → 大域」（契约 §3 S1）。
@@ -2105,8 +2466,14 @@ class MdCG:
             fm["derived_from"] = parents
             fm["derived_relation"] = derived_rel
         # 重要性 ≥0.7 自动打保护标记（对齐 tool_table：≥0.7 触发不可遗忘保护）
+        # issue50-d（2026-10-02）：自动保护只认**显式声明**——调用方随 add
+        # 下传 importance_source 时，"heuristic"（闸门启发式分）过线**只落分、
+        # 不打位**（remember_gated 的裁决面文案已如实说「未落保护」）；
+        # importance_source 缺省 None（add 的全部既有调用方都不传）⇒ 本条件
+        # 恒真、既有行为逐位不变，零回归由构造保证。
         if (float(importance or 0.0) >= protect.AUTO_PROTECT_IMPORTANCE
-                and not fm.get("protected")):
+                and not fm.get("protected")
+                and importance_source != "heuristic"):
             fm["protected"] = True
             fm["protection_reason"] = (f"importance={float(importance):.2f}"
                                        f"≥{protect.AUTO_PROTECT_IMPORTANCE}")
@@ -2143,8 +2510,20 @@ class MdCG:
             "layer": layer, "tags": tags, "bucket": bucket,
             "bucket_zh": bucket_zh or None,
             "importance": importance, "created_at": fm["created_at"],
+            # issue50-d：重要度来源入快照（与 _node_entry 同口径——写入后即可
+            # 免读文件判「0.8 是显式 hint 还是启发式」，不等全量重建）。
+            "importance_source": fm.get("importance_source"),
             "verification_basis": verification_basis,
             "has_neg_conditions": nodefile.has_non_applicable(sealed),
+            # P2-1 / P4-2①：与 `_node_entry`（重建路径）**同口径**——写路径的
+            # 定向 upsert 若漏这两组键，就得等下一次全量重建才补上（N137 同款
+            # 「重建后有、写入后没有」的形态漂移）。
+            nodefile.POSTCONDITION_TERMS_KEY:
+                nodefile.ccg_element_terms(sealed, nodefile.POSTCONDITION_FIELD),
+            nodefile.REJECTION_TERMS_KEY:
+                rejection_index_terms(fm, sealed),
+            "access_count": fm.get("access_count", 0),
+            "last_access": fm.get("last_access", 0),
             "content_hash": hashlib.sha256(sealed.encode("utf-8")).hexdigest()[:12],
             "temporal": fm.get("temporal"),
             "spatial": fm.get("spatial"),
@@ -2634,26 +3013,33 @@ class MdCG:
             atomic_write(self.recent_log, "")
         return len(recs)
 
-# 生效条件：无条件把 entry 写入 _dirty[node_id] 与 index["nodes"][node_id]；entry.get("bucket") 为真值时该桶计数 +1；当 len(self._dirty) >= self.autoflush 时调 flush()（autoflush 为 0 时每次标脏都立即 flush）；
+# 生效条件：无条件把 entry 记进 _dirty[node_id] 并经 _set_index_entry 写进 index["nodes"][node_id]（桶计数与 stg 结构索引同钩，见该函数）；当 len(self._dirty) >= self.autoflush 时调 flush()（autoflush 为 0 时每次标脏都立即 flush）；
     def _stage(self, node_id, entry):
         self._dirty[node_id] = entry
-        self.index["nodes"][node_id] = entry
-        if entry.get("bucket"):
-            self.index["buckets"][entry["bucket"]] = \
-                self.index["buckets"].get(entry["bucket"], 0) + 1
+        self._set_index_entry(node_id, entry)
         if len(self._dirty) >= self.autoflush:
             self.flush()
 
-# 生效条件：无条件 pop index["nodes"][node_id]（不存在则无操作）；被 pop 的条目有真值 bucket 时该桶计数 -1，减后 <=0 则删除该桶键；随后无论是否命中都把 _dirty[node_id] 置 None（删除 tombstone）并立即调 flush() 持久化；
-    def _unstage(self, node_id):
-        """摘除索引条目并**持久化**——与 `_stage` 对称的删除原语。
+# 生效条件：无条件把 entry 写入 index["nodes"][node_id]（同键覆写 = dict 原地更新，物理位序不变）；entry.get("bucket") 为真值时该桶计数 +1；self._stg_index 非 None（第 3 层结构索引已构建）时同钩增量增/改该 id，为 None（未构建/已失效）时**不构建**——首次 stg 访问才构建，写路径零额外成本；返回 None。
+    def _set_index_entry(self, node_id, entry):
+        """索引条目写入的**单点**（桶计数 + stg 结构索引同钩）。
 
-        只 pop 内存索引是不够的：`close()` 注释里记过同构的坑（已有
-        `_index.json` 的根重开不重扫目录），于是「删掉的条目」会在
-        `_index_log` 重放时复活成**幽灵条目**（索引有条目、节点文件不存在）。
-        幽灵条目的代价：检索白跑候选、`ref action=prune` 因 `cg.get` 取不回
-        而够不着它，`check` 的 dangling 永不归零（本机实测累积数百条）。
+        「同钩」是设计稿 §3.2 的字面要求：写路径的增量维护若与桶计数分家，
+        两处口径必然漂开（本仓既有教训：同一判据写两份 = 迟早各漏一次）。
+        无效化（rebuild/compact/重载）后 `_stg_index` 为 None ⇒ 这里退化为
+        无操作，读侧「首次需要时构建」的惰性路径接管。
         """
+        self.index["nodes"][node_id] = entry
+        b = entry.get("bucket")
+        if b:
+            self.index["buckets"][b] = self.index["buckets"].get(b, 0) + 1
+        ix = getattr(self, "_stg_index", None)
+        if ix is not None:
+            ix.add(node_id, entry)
+
+# 生效条件：无条件 pop index["nodes"][node_id]（不存在则无操作）；被 pop 的条目有真值 bucket 时该桶计数 -1，减后 <=0 则删除该桶键；self._stg_index 非 None 时同钩摘除该 id（未构建即不动）；返回被摘除的条目（不存在返回 None）。
+    def _remove_index_entry(self, node_id):
+        """索引条目摘除的**单点**（与 `_set_index_entry` 对称：桶计数 + 结构索引同钩）。"""
         e = self.index["nodes"].pop(node_id, None)
         if e and e.get("bucket"):
             b = e["bucket"]
@@ -2662,6 +3048,27 @@ class MdCG:
                 self.index["buckets"][b] = left
             else:
                 self.index["buckets"].pop(b, None)
+        ix = getattr(self, "_stg_index", None)
+        if ix is not None:
+            ix.remove(node_id)
+        return e
+
+# 生效条件：恒把 self._stg_index 置 None（丢弃已构建的第 3 层结构索引）——凡**整体替换 self.index** 的路径（重载/compact/rebuild）调它：表按身份判代际（`StgIndex.index_obj is self.index`），显式失效让下次 stg 访问重新按新快照构建（惰性失效重建，设计稿 §3.2 二选一之选）；恒返回 None、不抛。
+    def _invalidate_stg_index(self):
+        """第 3 层结构索引的失效单点（整体换索引的三处编排点都调它）。"""
+        self._stg_index = None
+
+# 生效条件：先经 _remove_index_entry 摘除 index["nodes"][node_id]（桶计数与 stg 结构索引同钩），随后无论是否命中都把 _dirty[node_id] 置 None（删除 tombstone）并立即调 flush() 持久化；
+    def _unstage(self, node_id):
+        """摘除索引条目并**持久化**——与 `_stage` 对称的删除原语。
+
+        只 pop 内存索引是不够的：`close()` 注释里记过同构的坑（已有
+        `_index.json` 的根重开不重扫目录），于是「删掉的条目」会在
+        `_index_log` 重放时复活成**幽灵条目**（索引有条目、节点文件不存在）。
+        幽灵条目的代价：检索白跑候选、`ref action=prune` 因 `cg.get` 取不回
+        而够不着它，`check` 的 dangling 永不归零（本机实测累积数百条）。
+        """
+        self._remove_index_entry(node_id)
         self._dirty[node_id] = None      # None = 删除记录，随 flush 落分片日志
         self.flush()                     # 删除不可延迟到 autoflush 阈值
 
@@ -3031,6 +3438,67 @@ class MdCG:
             acc = "无情境可比（未做正条件确认）+ " + acc
         return {"state": STATE_ACCEPT, "reason": acc}
 
+    # 生效条件：node_dict 为 {frontmatter, content}（缺键按空处理）、query 为字符串、context 为 dict 或 None；无条件先算边界命中（boundary_hit），再算资格判定——边界命中**且** query 为边界问句（is_boundary_query）时，资格判定改以「摘掉命中拒绝域条目后的 query」重跑（并在返回体的 qualification 上标 boundary_suppressed=True），其余情形资格判定原样跑 judge_qualification(node_dict, query, context)；返回 {"qualification","boundary","counts","recallable","reason"}——counts 内 reject 与 boundary_hit **分开计数**，recallable 为「可召回可展示」（边界命中恒真；无边界命中时 = 资格态不是 REJECT）。
+    @staticmethod
+    def judge_with_boundary(node_dict, query: str, context=None) -> dict:
+        """资格判定 + 拒绝域命中——**分开计数、分开呈现**（§5.2 / P0-4）。
+
+        返回形状（P2 的检索面直接消费）::
+
+            {"qualification": {"state": ..., "reason": ...},
+             "boundary":      {"hit": bool, "terms": [...],
+                               "marker": "boundary_hit" | None, "reason": str},
+             "counts":        {"accept":0|1, "reject":0|1, "defer":0|1,
+                               "blindspot":0|1, "boundary_hit":0|1},
+             "recallable":    bool,     # 与既有候选过滤同口径：state 不属
+                                        # (REJECT, BLINDSPOT) 即可召回
+             "reason":        str}
+
+        **不变量（本判据的核心）**：`boundary.hit` 为真**不构成**资格否定——
+        边界问句下资格判定摘掉命中词面再跑，故「问该节点的拒绝域」不会把该节点
+        打回 REJECT（自否定）；非边界问句下资格判定**原样**跑 `judge_qualification`，
+        负条件的灵敏度一字不变（情境里真的命中拒绝域 ⇒ 照旧 REJECT）。
+
+        **已接线（P2-2，2026-10-01）**：本函数与 `boundary_hit` 都**有生产调用方**——
+
+          · `MdCG._emit`（`md_cg/mdcg.py:4181`）＝默认打分收口，结果卡带
+            `boundary_hit` 标记 + `stat["boundary"]["counts"]` 分开计数；
+          · `MdCos.search_rrf`（`md_cg/mdcos.py:1754`）＝默认召回路径，同款标记与
+            `boundary_counts`。
+
+        两处都调**同一个** `judge_with_boundary`（边界标记一律经同族的
+        `boundary_mark` 取，其体内复用 P0-4 的 `boundary_hit`）——**单点复用、
+        不另写第二份判据**；接线是否在位由 `md_cg/test_boundary_hit.py` 的 B5 组
+        断言钉死（该组在 P2-2 已把 P0-4 的「本轮零接线」断言改判为接线断言）。
+        """
+        node_dict = node_dict or {}
+        bh = boundary_hit(node_dict, query, context)
+        bq = is_boundary_query(query)
+        if bh["hit"] and bq:
+            qual = dict(MdCG.judge_qualification(
+                node_dict, strip_boundary_terms(query, bh["terms"]), context))
+            qual["boundary_suppressed"] = True
+        else:
+            qual = dict(MdCG.judge_qualification(node_dict, query, context))
+            qual["boundary_suppressed"] = False
+        st = str(qual.get("state") or "")
+        counts = {"accept": int(st == STATE_ACCEPT),
+                  "reject": int(st == STATE_REJECT),
+                  "defer": int(st == STATE_DEFER),
+                  "blindspot": int(st == STATE_BLINDSPOT),
+                  "boundary_hit": int(bool(bh["hit"]))}
+        # 可召回与**既有候选过滤同口径**（mdcos 的 `st in (REJECT, BLINDSPOT)`
+        # 即剔除）：这两态不进候选，其余（ACCEPT/DEFER）可召回。
+        recallable = st not in (STATE_REJECT, STATE_BLINDSPOT)
+        return {"qualification": {"state": qual.get("state"),
+                                  "reason": qual.get("reason"),
+                                  "boundary_suppressed": qual["boundary_suppressed"]},
+                "boundary": {"hit": bh["hit"], "terms": bh["terms"],
+                             "marker": bh["marker"], "reason": bh["reason"]},
+                "counts": counts, "recallable": recallable,
+                "reason": ("边界命中（%s）+ 资格 %s" % (bh["marker"], st)
+                           if bh["hit"] else "无边界命中 + 资格 %s" % st)}
+
     # ---------- 检索（性能阶梯 + 资格判定）----------
 
 # 生效条件：query strip 后为空即返回 ([], {"tier": None, "reason": "empty_query", "scanned": 0})；非空时按 T0–T3 性能阶梯取候选（layer / session / branch / validity / view 为假值时对应维度不过滤），judge 为真时对每条结果附独立的四态资格判定；返回 (results, meta)；
@@ -3068,9 +3536,10 @@ class MdCG:
               ValueError（fail-closed 只针对调用方误用）。
         """
         q = (query or "").strip()
-        # 批次 15 统一口径（unify.py）：任意语言 query → 标准原子序列
-        # （统一翻译为中文→归一化到标准中文集→检索）；纯中文原样、
-        # MDCG_UNIFY_QUERY=0 可关、失败静默原样
+        # 批次 15 统一口径（unify.py，2026-09-30 收窄作用域）：只译**英文内容**
+        # → 标准原子序列，中文段逐字原样（不再整条归一）；纯中文/无 ASCII 字母
+        # 原样、归一层**缺省关**（2026-09-30 裁定，显式 MDCG_UNIFY_QUERY=1 才开）、
+        # 失败静默原样。口径真源见 docs/hive/检索算法口径对照_v0.1.md
         from .semantic.unify import unify_query
         q = unify_query(q)
         if not q:
@@ -3257,7 +3726,9 @@ class MdCG:
             if in_bucket:
                 docs = self._read_many(in_bucket, stat)
                 # 语义资格（MDCG_SEMANTIC=1）：fm.semantic 节点无条件入池
-                hits = [d for d in docs if self._like(d[2], d[1], terms)
+                hits = [d for d in docs
+                        if self._like(d[2], d[1], terms,
+                                      index_key_hits(d[0], terms, q))
                         or (semantic_on() and d[1].get("semantic"))]
                 out = try_stage(hits, TIER_BUCKET_LIKE)
                 if out:
@@ -3283,7 +3754,8 @@ class MdCG:
             docs_r = self._read_many(reach_entries, stat)
             _dif = set(_rstat.get("reach_diffused_paths") or ())
             hits_r = [d for d in docs_r
-                      if self._like(d[2], d[1], terms)
+                      if self._like(d[2], d[1], terms,
+                                    index_key_hits(d[0], terms, q))
                       or (semantic_on() and d[1].get("semantic"))
                       or d[0].get("path") in _dif]     # 图扩散补召回：无词面命中也放行进打分
             stat["pre_cap"] = len(hits_r)     # 与 T2 同序：截断**前**的候选数
@@ -3384,11 +3856,19 @@ class MdCG:
         _s7_scan0 = stat["scanned"]        # S7 窄化前的扫描基线（供 T3 兜底还原口径）
         docs_all = self._read_many(entries, stat)
         # 语义资格（MDCG_SEMANTIC=1）：fm.semantic 节点无条件入池
-        hits = [d for d in docs_all if self._like(d[2], d[1], terms)
+        hits = [d for d in docs_all
+                if self._like(d[2], d[1], terms,
+                              index_key_hits(d[0], terms, q))
                 or (semantic_on() and d[1].get("semantic"))]
         # ---- S3 图扩散激活（契约 §3 S3；flag 控，默认关）----
-        # 为何：edges 一直只被写入、检索从不使用（审计偏差 1）。这里从词法命中节点沿
-        # edges 双向扩散，把「关联但词面不重叠」的记忆作为独立一层候选（TIER_SPREAD）。
+        # 为何：审计偏差 1 曾成立——「edges 一直只被写入、检索从不使用」。**该偏差
+        # 已消除（P3-causal，2026-10-01）**：检索侧现有两条路读 edges——①
+        # `search_rrf` 的 `chain` 路（因果路，复用 md_cg/chain.py，按裁定 9 进
+        # 缺省集）；② 本层 S3 扩散（`search` 的候选生成段，flag 控、默认关，产物
+        # 是独立 tier TIER_SPREAD）。两者定位不同：chain 是「路内排名项」，
+        # 本层是「新增候选层」（契约 §4.1 的「有意保留的差异」同款划界）。
+        # 本层从词法命中节点沿 edges 双向扩散，把「关联但词面不重叠」的记忆作为
+        # 独立一层候选（TIER_SPREAD）。
         # 约束：扩散只走索引里的 edges（不读文件）；**不得引入未通过 S1/S2 门控**的节点；
         # 命中不足时自然落回原 T2/T3 路径（无召回损失）。
         if _s3 and hits:
@@ -3523,10 +4003,19 @@ class MdCG:
         return docs
 
     @staticmethod
-# 生效条件：terms 为空时返回 False；否则任一 t 在 positive_body(content) 的小写串中出现，或该 t 的小写形式出现在 fm 的 tags（tags 取自 fm.get("tags") or []，缺键或假值按空列表拼接）小写串中即返回 True。
-    def _like(content, fm, terms):
+# 生效条件：terms 为空时返回 False；否则任一 t 在 positive_body(content) 的小写串中出现，或该 t 的小写形式出现在 fm 的 tags（tags 取自 fm.get("tags") or []，缺键或假值按空列表拼接）小写串中，或 index_keys 为真值（六要素后两行的索引键命中，见 index_key_hits）即返回 True。
+    def _like(content, fm, terms, index_keys=None):
         # 负条件行（`# 不适用条件：`）是反例声明，不作召回键：命中它只应由
         # judge_qualification 走 REJECT，不能把节点召回。tags 仍参与匹配。
+        #
+        # P2-3（§5.4「六要素 6 行全进默认检索」）：**后两行**（验证方式 /
+        # 不适用条件）的**索引键**（`postcondition_terms`/`rejection_terms`，
+        # 已在索引条目里）在此参与召回。`positive_body` 的立场**不变**——
+        # 拒绝域仍不作普通问句的召回键（`index_key_hits` 只在**边界问句**上
+        # 放开拒绝域召回；见函数说明）。index_keys 为 None（旧调用方）时
+        # 行为与改动前逐位一致。
+        if index_keys and index_keys.get("hit"):
+            return True
         tags = " ".join(str(t) for t in (fm.get("tags") or []))
         body = nodefile.positive_body(content)
         # 双边小写化：英文大小写统一（中文无大小写不受影响）
@@ -3572,6 +4061,15 @@ class MdCG:
             if pools:                       # §七 降权：乘数只来自显式权重表（可复算）
                 raw = max(0.0, min(1.0, raw * pooling.weight_of(
                     fm.get("id") or e["path"], e, pools)))
+            # ── P4（§7.1/§7.2）：刷新与衰减乘子——**与上一行同一个乘子位** ──
+            # 形态（已裁）：score ← score × cred_factor(γ, Δt) × refresh(ac, la)。
+            # 「不新开乘子链」= 就在这里乘，不另起一条对最终 RRF 分做后处理的链。
+            # 取数全来自**索引条目** `e`（`_node_entry` 已落 created_at /
+            # access_count / last_access），检索期**不读盘**（§7.2 卡点一）。
+            # 核走唯一权威 time_core，γ 走 P3 已落的唯一读取点（见 freshness 模块头）。
+            # 开关 `MDCG_FRESHNESS`（缺省开）=0 时乘子恒 1.0（与改动前逐位一致）。
+            if freshness.enabled():
+                raw = raw * freshness.entry_weight(e, fm=fm)[0]
             if _boost:                      # S4：层级加成（最后一步；上限仍夹在 1.0）
                 raw = min(1.0, raw + _boost.get(str(fm.get("layer") or ""), 0.0))
             scored.append(({"id": fm.get("id") or e["path"], "frontmatter": fm,
@@ -3743,15 +4241,42 @@ class MdCG:
                 stat.setdefault("gates", {})["s6"] = {
                     "checked": len(_rows6), "by_track": _track6,
                     "flagged": _flagged6, "rows": _rows6}
-        # 资格判定（与性能正交）
+        # 资格判定（与性能正交）——**P2-2（§5.2）在此接线**：
+        # 走 `MdCG.judge_with_boundary`（P0-4 已落的判据函数，**复用不另写一份**）：
+        #   · 边界命中（拒绝域）→ 结果卡带 `boundary_hit` 标记（可召回、可展示）；
+        #   · 该节点的**正例资格不受影响**：边界问句下资格判定先摘掉命中词面再跑，
+        #     故「问它什么时候不适用」不会把它自己打成 REJECT（自否定）；
+        #   · **分开计数、分开呈现**：`boundary_hit` 与资格 REJECT 各计各的
+        #     （stat["boundary"]["counts"]，不混成一个数）。
+        # 非边界问句下 judge_with_boundary 内部原样调 judge_qualification，
+        # 故默认口径的 state 与改动前逐位一致（负条件灵敏度一字不动）。
         out = []
+        _bnd = {"hit": 0, "terms": 0,
+                "counts": {"accept": 0, "reject": 0, "defer": 0,
+                           "blindspot": 0}}
         for r in results:
             if judge:
-                qual = self.judge_qualification(r[0], stat.get("query") or "",
-                                                context)
+                _jw = MdCG.judge_with_boundary(r[0], stat.get("query") or "",
+                                               context)
+                qual = dict(_jw["qualification"])
+                _b = boundary_mark(r[0], stat.get("query") or "", context)
+                if _b.get("hit"):
+                    _bnd["hit"] += 1
+                    _bnd["terms"] += len(_b.get("terms") or [])
+                    # 拒绝域命中走**独立字段**展示（不写进 qualification，
+                    # 否则下游按 state 判定的地方会把它读成资格结论）
+                    r[0]["boundary_hit"] = True
+                    r[0]["boundary_marker"] = _b.get("marker")
+                    r[0]["boundary_terms"] = list(_b.get("terms") or [])
+                for _k in ("accept", "reject", "defer", "blindspot"):
+                    _bnd["counts"][_k] += int(
+                        (_jw.get("counts") or {}).get(_k) or 0)
             else:
                 qual = {"state": None, "reason": "judge_disabled"}
             out.append((r[0], r[1], qual))
+        # 边界读数只在**确有边界命中**时落键（与 S1/S2/S5「产生信息才落键」同规则）
+        if _bnd["hit"]:
+            stat["boundary"] = _bnd
         # 负覆盖提示条目**追加在尾部**（不是首条——旧注释「（首条）」与代码相反）：
         # 它们在 `_neg_tail` 里已按 k 预算建好（①分数哨兵 ②计入 k ④位置=尾）。
         out.extend(_neg_tail)
@@ -3792,6 +4317,10 @@ class MdCG:
         # 分阶段审计仅在门控真的产生信息时落键（默认关闭 → meta 与改动前逐字节一致；契约 §5.3）
         if stat.get("gates"):
             meta["gates"] = stat["gates"]
+        # P2-2（§5.2）：拒绝域命中的**独立读数**（与资格 REJECT 分开计数）——
+        # 只在确有边界命中时落键（无边界命中的路径 meta 键集合与改动前一致）。
+        if stat.get("boundary"):
+            meta["boundary"] = stat["boundary"]
         # 负覆盖尾审计（H10①②）：仅在**确有提示条目入榜**时落键（无覆盖的路径
         # meta 键集合与改动前逐字节一致）。下游可据此把「提示」与「答案」分区：
         # 尾条目的负性判据是 card/qual 的 `negative_coverage`，本块是同一事实的
@@ -3944,12 +4473,28 @@ class MdCG:
                 and os.path.exists(old_full)):
             os.remove(old_full)
         rel = os.path.relpath(new_path, self.root).replace("\\", "/")
+        # N137（2026-10-01）：本条 _stage 条目此前缺 edges / subgraph / 双时间轴
+        # （trust.FROM/UNTIL/EFFECTIVE_FROM/EFFECTIVE_UNTIL）四组键——搬迁 =
+        # 「删除源层条目 + 写入目标层条目」，缺键即让目标层条目**静默退化**：
+        # ① 新检索路（P3-causal 的 chain 路走 index 的 edges 建邻接、P3-temporal
+        #    走索引标量）搬迁后对它即不可达（节点还在，边/时刻没了）；
+        # ② trust.validity 的时效过滤免读盘判定失效（valid_from/until 不在快照）。
+        # 写入口 `_node_entry`（_scan_nodes / rebuild 共用）与 `add()` 的 _stage
+        # 条目都带这些键——本条与之对齐，杜绝「重建后有、搬迁后没有」的形态漂移。
         self._stage(node_id, _strip_empty_gate_fields({
             "path": rel, "layer": to_layer, "tags": fm.get("tags", []),
             "bucket": 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(node["content"]),
+            # P2-1 / P4-2①（与 `_node_entry` / `add()` 同口径；N137 的教训：
+            # 搬迁条目缺键 = 新检索路对搬迁后的节点静默不可达）
+            nodefile.POSTCONDITION_TERMS_KEY: nodefile.ccg_element_terms(
+                node["content"], nodefile.POSTCONDITION_FIELD),
+            nodefile.REJECTION_TERMS_KEY: rejection_index_terms(
+                fm, node["content"]),
+            "access_count": fm.get("access_count", 0),
+            "last_access": fm.get("last_access", 0),
             "content_hash": hashlib.sha256(
                 node["content"].encode("utf-8")).hexdigest()[:12],
             "temporal": fm.get("temporal"), "spatial": fm.get("spatial"),
@@ -3957,6 +4502,16 @@ class MdCG:
             "big_domain": fm.get("big_domain"),
             "observation_position": (fm.get("condition_space") or {}).get("observation_position"),
             "evidence_count": fm.get("evidence_count", 0),
+            # N137：边域与嵌套子图（chain 路 / 递归展开的免读盘来源）
+            "edges": fm.get("edges") or [],
+            "subgraph": fm.get("subgraph"),
+            # N137：双时间轴（trust.validity 的免读盘判定面，与 add/_node_entry 同口径）
+            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),
+            trust.EFFECTIVE_FROM_FIELD: fm.get(trust.EFFECTIVE_FROM_FIELD),
+            trust.EFFECTIVE_UNTIL_FIELD: fm.get(trust.EFFECTIVE_UNTIL_FIELD),
         }))
         self.index["buckets"] = self._count_buckets(self.index["nodes"])
         return {"id": node_id, "from": from_layer, "to": to_layer,