@furongjun1999/dsh-memory 0.4.10 → 0.5.0

package/md_cg/mdcg.py

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

package/md_cg/mdcos.py

@@ -30,7 +30,7 @@ from .mdcg import (MdCG, expand_query_terms, bigrams, normalize_en, STATE_ACCEPT
                    TIER_BUCKET_SCAN, TIER_GLOBAL_LIKE, TIER_GLOBAL_SCAN,
                    GLOBAL_CAP, expand_query_terms_weighted,
                    expand_query_terms_llm, en_zh_bigrams, semantic_on,
-                   cut_by_relevance)
+                   cut_by_relevance, apply_retrieval_gates)
 from . import (nodefile, routing, chain, subgraph, forgetting, protect,
                identity, consistency, metacognition, crypto, sustain,
                self_state, predict, evolution, weights, pooling,
@@ -326,6 +326,21 @@ class MdCGOS(MdCG):
         os.makedirs(self.trash_dir, exist_ok=True)
         self._audit_writes = 0        # 进程内写入计数（轮转探测节流，稳态零 stat）
         self._audit_index = None      # 归档索引缓存（懒加载）
+        # 热缓存挂载（issue #28，2026-09-23）：读侧（search_rrf）与失效侧
+        # （writepipe）早已接好，唯独无人调 attach——生产恒 None，重复 query
+        # 无法命中。默认关（env 未设 → get(self) 恒 None，零变更纪律）；
+        # MDCG_HOTCACHE=1 显式启用，容量经 MDCG_HOTCACHE_MAX_NODES/MAX_QUERIES
+        # 可配（缺省 256 对 567 节点级库会持续 LRU 淘汰，大库请调大）。
+        if os.environ.get("MDCG_HOTCACHE") == "1":
+            from . import hotcache as _hc
+            _hc.attach(self)
+        # 检索读缓存挂载（issue #31 P2，批次 21）：MdStore 理论落地——节点
+        # 文件解析产物常驻（567 池实测 572 次 open/查询 → 缓存后 ~0），写失
+        # 效走 _dirty 代际哨兵（所有写路径必然标脏，无漏挂面）。默认关
+        # （MDCG_READ_CACHE=1 显式启用，零变更纪律）。
+        if os.environ.get("MDCG_READ_CACHE") == "1":
+            from . import readcache as _rc
+            _rc.install(self)
 
     # ================= 6. payload-free 审计 =================
 
@@ -608,7 +623,8 @@ class MdCGOS(MdCG):
         for e in self.index["nodes"].values():
             if e.get("layer") in ("rejected", "unresolved", "goals"):
                 continue  # 负记忆走覆盖标记；目标只做定向，都不进正排
-            if session and e.get("session") != session:
+            # '"*"' = 显式跨会话（读遍所有会话）；缺省 None 同义（见 stg.timeline）
+            if session and session != "*" and e.get("session") != session:
                 continue
             if e.get("branch_id") not in (None, branch):
                 continue
@@ -705,6 +721,10 @@ class MdCGOS(MdCG):
         详见 _candidates。
         """
         q = (query or "").strip()
+        # 批次 15 统一口径（unify.py）：任意语言 query → 标准原子序列；
+        # 与 MdCG.search/search_rrf 三入口同口径（MDCG_UNIFY_QUERY=0 可关）
+        from .semantic.unify import unify_query
+        q = unify_query(q)
         if not q:
             return [], {"tier": None, "reason": "empty_query", "scanned": 0}
         pool_cfg = pooling.resolve(pooling.from_env(pools))
@@ -740,6 +760,15 @@ class MdCGOS(MdCG):
             route_bucket = routing.bucket_dir(routing.route_key(ctx, ctx.get("tags")))
         big_domain = routing.big_domain_classify(terms)
         big_scores = routing.big_domain_score_breakdown(terms)
+        # S1/S1b/S2 收敛 + S4 审计——与 MdCG.search 共享同一实现（issue #25：
+        # 本覆写此前完全不含门控，生产路径（MdCGSecure → 本类）从未生效——
+        # 开关显式打开也不生效、gates 审计不出现、scanned 恒全表）。
+        # 收敛在 _read_many 之前 → scanned 真实下降；gates 非空才落键
+        # （默认关时 meta 键集合与改动前逐字节一致，零变更纪律）。
+        entries, gates = apply_retrieval_gates(
+            entries, terms, big_domain, context, min_results)
+        if gates:
+            stat["gates"] = gates
         neg_coverage = self._neg_coverage(terms) if include_neg else []
 
 # 生效条件：对 docs 调 self._score 后，若其中分数 >0 的条数达到（search 作用域内的）min_results 就返回 self._emit(scored, k, tier, stat, route_bucket, record, len(docs), ...)，否则返回 None。
@@ -1175,6 +1204,10 @@ class MdCGOS(MdCG):
             串结果）；候选层语义与 search 一致，详见 _candidates。
         """
         q = (query or "").strip()
+        # 批次 15 统一口径（unify.py）：任意语言 query → 标准原子序列；
+        # 归一后的 q 进热路径缓存键（归一确定 → 缓存不串味）
+        from .semantic.unify import unify_query
+        q = unify_query(q)
         if not q:
             return [], {"tier": None, "reason": "empty_query", "paths": {}}
         # 热路径：query 结果缓存命中即返回（不改 RRF 核心）
@@ -1485,15 +1518,24 @@ class MdCGOS(MdCG):
 
     # ================= 1. Fix pairs 自动挖掘 =================
 
-# 生效条件：当 events 传入时，兼容显式 {error,fix} 对与含 text 的事件序列；后者在错误行长度 >= min_len 后向后 lookahead 条内寻找 _FIX_RE 命中的行配对并 break；去重后为每对 add 知识节点和 add_rejected，返回 pairs/rejected_ids/knowledge_ids；
-    def mine_fix_pairs(self, events, lookahead: int = 4, min_len: int = 6):
+# 生效条件：当 events 传入时，兼容显式 {error,fix} 对与含 text 的事件序列；后者在错误行长度 >= min_len 后向后 lookahead 条内寻找 _FIX_RE 命中的行配对并 break；去重后为每对产出修复知识（as_proposals 为假→add 直写 knowledge 层；为真→propose 入审核队列，判据指纹随提案落盘，knowledge_ids 为空、pids 收提案 id 并附 as_proposals=True）与 add_rejected 负记忆，返回 pairs/rejected_ids/knowledge_ids（提案模式另附 pids）；
+    def mine_fix_pairs(self, events, lookahead: int = 4, min_len: int = 6,
+                       as_proposals: bool = False):
         """从行为日志挖掘「错误 → 修复」对。
 
         events: [{"role": ..., "text": ...}] 或 [{"error":..., "fix":...}]（显式对）
         返回 {"pairs": [...], "rejected_ids": [...], "knowledge_ids": [...]}
 
+        as_proposals=False（默认，显式调用语义）：正记忆直写 knowledge 层——
+        调用方是有意图的显式动作（如 mdcg_mine_fix_pairs 工具直调）。
+        as_proposals=True（自动管线语义）：正记忆改走 propose 审核队列——
+        自动产物不经收口不入知识层（§5.5 系统纪律化，zcode 外评 break#2）；
+        判据指纹随提案落盘，复核者只能按原判据裁决不能放宽；payload_hash
+        幂等（重试与崩溃恢复无害）。负记忆一律直写 rejected 层（隔离层，
+        不存在 knowledge 污染问题）。
+
         产出：
-          · knowledge/<fix_xxx>.md —— 可路由的修复知识（CCG 5 要素）
+          · knowledge/<fix_xxx>.md 或审核队列提案 —— 可路由的修复知识（CCG 5 要素）
           · rejected/<rej_xxx>.md  —— 负记忆「此错误不必深挖根因」（防重复踩坑）
         """
         pairs = []
@@ -1528,7 +1570,7 @@ class MdCGOS(MdCG):
             seen.add(k)
             uniq.append((err, fix))
 
-        rej_ids, kno_ids = [], []
+        rej_ids, kno_ids, pids = [], [], []
         for err, fix in uniq:
             # 1) 可路由的修复知识
             kid = "fix_" + _sig(err + "\x00" + fix)
@@ -1540,17 +1582,31 @@ class MdCGOS(MdCG):
                 f"# 验证方式：行为日志（后续同类错误不再出现）\n"
                 f"# 不适用条件：与「{err[:30]}」不同的错误\n\n"
                 f"错误：{err}\n修复：{fix}\n")
-            self.add(kid, content, layer="knowledge", tags=["fix_pair"],
-                     verification_basis="data", importance=0.7)
-            kno_ids.append(kid)
+            if as_proposals:
+                # 自动管线：入审核队列（判据指纹随提案落盘，复核者不能放宽；
+                # payload_hash 幂等——同内容重试返回原 pid）
+                pid = self.propose(
+                    kid, content, layer="knowledge", tags=["fix_pair"],
+                    verify={"kind": "data",
+                            "assertions": ["error/fix 均非空且来自真实行为日志",
+                                           "与既有 fix_pair 知识不重复"]})
+                pids.append(pid)
+            else:
+                self.add(kid, content, layer="knowledge", tags=["fix_pair"],
+                         verification_basis="data", importance=0.7)
+                kno_ids.append(kid)
             # 2) 负记忆：这个错误不是死路（防止重复深挖）
             rid = self.add_rejected(
                 hypothesis=f"「{err[:60]}」需要深挖根因（无现成解法）",
                 reason=f"已有修复：{fix[:80]}",
                 verification_basis="data", tags=["fix_pair"])
             rej_ids.append(rid)
-        return {"pairs": [{"error": e, "fix": f} for e, f in uniq],
-                "rejected_ids": rej_ids, "knowledge_ids": kno_ids}
+        result = {"pairs": [{"error": e, "fix": f} for e, f in uniq],
+                  "rejected_ids": rej_ids, "knowledge_ids": kno_ids}
+        if as_proposals:
+            result["as_proposals"] = True
+            result["pids"] = pids
+        return result
 
     # ================= 4. 审核队列（inbox → decisions） =================
 
@@ -3603,6 +3659,7 @@ class MdCGSecure(MdCGOS):
         res, meta = super().search_rrf(*a, **kw)
         validity = kw.get("validity")
         view = kw.get("view")
+        session = kw.get("session")
         now = time.time() if validity else None
         _en_t, _ax_t, _why_t = trust.check_time_args(
             kw.get("start_time"), kw.get("end_time"), kw.get("start_operator"),
@@ -3612,6 +3669,11 @@ class MdCGSecure(MdCGOS):
             e = self.index["nodes"].get(r[0]["id"], r[0])
             if not self._readable(e):
                 continue
+            # 会话归属同为候选资格：图扩展会把**别的会话**的节点顺着边带回来，
+            # 绕过 _candidates 的会话过滤 → 自动召回照样串台。故与 validity/view
+            # 一并在此兜底（"*" = 跨会话视图，不过滤）。
+            if session and session != "*" and e.get("session") != session:
+                continue
             if view is not None and not roleviews.matches(e, view):
                 continue
             if validity and trust.is_expired(e, now=now):
@@ -3641,9 +3703,13 @@ class MdCGSecure(MdCGOS):
         self.principal.require_admin("restore")
         return super().restore(node_id, force=force)
 
-# 生效条件：先 principal.require_admin("review_decide")，再把 *a/**kw 原样转给 super().review_decide。
+# 生效条件：先 principal.require_op("review")（语义修正 2026-09-22：裁决权从
+#   require_admin 拆出——编排者/仲裁位持 review op 即可裁决，存在级管理权
+#   （forget/protect/anchor 写）仍由 require_admin 把守、designer 专属；
+#   designer ops=["*"] 天然兼容），再把 *a/**kw 原样转给 super().review_decide；
+#   accept/edit 落节点时的层写仍由下游 require_layer_write 按裁决者可写层拦截。
     def review_decide(self, *a, **kw):
-        self.principal.require_admin("review_decide")
+        self.principal.require_op("review")
         return super().review_decide(*a, **kw)
 
 # 生效条件：先 principal.require_admin("evolution_rollback")，再转 super().evolution_rollback(entry_id, dry_run=dry_run, note=note)。