@furongjun1999/dsh-memory 0.4.11 → 0.5.1

package/md_cg/test_emit_negtail_cache.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""_emit 尾部 covered_neg 裸读守卫（v9 留档复测·修复，缺陷迭代第 14 轮）。
+
+缺陷形态（缺陷报告实测，60 knowledge + 8 rejected 临时库，逐位复现）：
+  _emit 尾部「把被负记忆覆盖的查询也作为结果条目返回」对 neg_coverage[:3]
+  逐条裸 open+nodefile.loads（mdcg.py _emit 尾，不经 self._read 不在读缓存
+  包装面）——每条命中负层的查询恒 ≤3 次盘读（Q1 loads=71=全池 60+负层
+  扫描 8+尾部 3；Q2 同查询增量恰 3）；负层主面 IO 已被读缓存覆盖（残余项）。
+
+修复口径：尾部改走 self._read(nc)（读缓存覆盖，增量归零）；_read 同款
+  _node_disk_path 边界闸（P2-20——索引被污染时不得绕过统一校验读 root 外
+  文件）、OSError→(None,None) 与旧 continue 同义；负层写路径（add/
+  add_rejected → _stage 标脏带 path）在读缓存脏集精确失效面内——覆写后
+  尾部条目即时见新内容，不陈旧。
+
+本守卫（调用计数断言形态，非时间阈值）：
+  E1 热缓存后同查询 loads 增量 == 0（旧实现恒 3 → 红）；
+  E2 功能在位：rejected 前 3 条仍在结果、covered_neg 计数/tier/scanned
+     不变（尾部不是被静默关掉）；
+  E3 两轮查询结果 ids 逐位一致（确定性）；
+  E4 读缓存开/关（MDCG_READ_CACHE=1/0）同库同查询 ids 逐位一致；
+  E5 覆写负层节点后尾部条目见新内容（脏集精确失效联动，不陈旧）。
+
+运行：python -m md_cg.test_emit_negtail_cache
+"""
+import os
+import shutil
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from md_cg import nodefile                     # noqa: E402
+from md_cg.mdcos import MdCGOS                 # noqa: E402
+
+PASS = 0
+FAIL = 0
+FAILS = []
+
+N = 60
+NNEG = 8
+QUERY = "已被否决的做法"
+
+
+def check(name, cond, detail=""):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  OK   {name}")
+    else:
+        FAIL += 1
+        FAILS.append(name)
+        print(f"  FAIL {name}  {detail}")
+
+
+def build_lib(root):
+    cg = MdCGOS(root)
+    for i in range(N):
+        cg.add("mem_%03d" % i,
+               "# 功能名：正层样本 %d\n# 正文：蜂群调度 节点 %d" % (i, i),
+               layer="knowledge")
+    for j in range(NNEG):
+        cg.add("r%d" % j,
+               "# 假设：%s 第 %d 号\n# 原因：与既有验证结论冲突" % (QUERY, j),
+               layer="rejected", verification_basis="test")
+    cg.flush()
+    return cg
+
+
+def count_loads(fn):
+    st = {"n": 0}
+    real = nodefile.loads
+
+    def _spy(*a, **kw):
+        st["n"] += 1
+        return real(*a, **kw)
+
+    nodefile.loads = _spy
+    try:
+        return fn(), st["n"]
+    finally:
+        nodefile.loads = real
+
+
+def neg_ids(res):
+    return [x[0].get("id") for x in res if str(x[0].get("id")).startswith("rejected/")]
+
+
+def main():
+    root = tempfile.mkdtemp(prefix="mdcg_negtail_")
+    cg = None
+    try:
+        os.environ.pop("MDCG_READ_CACHE", None)
+        cg = build_lib(root)
+        (r1, m1), n1 = count_loads(lambda: cg.search(QUERY))
+        ids1 = [x[0].get("id") for x in r1]
+        check("E0a 首查口径复现：covered_neg=8、tier=T3、scanned=60",
+              len(m1.get("covered_neg") or []) == NNEG
+              and m1.get("tier") == "T3_global_scan"
+              and m1.get("scanned") == N,
+              f"covered={len(m1.get('covered_neg') or [])} "
+              f"tier={m1.get('tier')} scanned={m1.get('scanned')}")
+        check("E0b rejected 前 3 条在结果（尾部功能在位）",
+              neg_ids(r1)[:3] == ["rejected/r0.md", "rejected/r1.md",
+                                  "rejected/r2.md"],
+              f"neg={neg_ids(r1)[:3]}")
+
+        (r2, m2), n2 = count_loads(lambda: cg.search(QUERY))
+        ids2 = [x[0].get("id") for x in r2]
+        check("E1a 热缓存后同查询 loads 增量 == 0（旧实现恒 3）",
+              n2 == 0, f"loads={n2}")
+        check("E2a rejected 前 3 条仍逐位在位、meta 口径不变",
+              neg_ids(r2)[:3] == ["rejected/r0.md", "rejected/r1.md",
+                                  "rejected/r2.md"]
+              and len(m2.get("covered_neg") or []) == NNEG
+              and m2.get("tier") == "T3_global_scan"
+              and m2.get("scanned") == N)
+        check("E3a 两轮查询结果 ids 逐位一致", ids1 == ids2,
+              f"n={len(ids1)}/{len(ids2)}")
+
+        # E4 读缓存开/关结果一致
+        os.environ["MDCG_READ_CACHE"] = "0"
+        try:
+            cg0 = MdCGOS(root)
+            r_off, m_off = cg0.search(QUERY)
+            cg0.close()
+            check("E4a 读缓存开/关同库同查询 ids 逐位一致",
+                  [x[0].get("id") for x in r_off] == ids2)
+        finally:
+            os.environ.pop("MDCG_READ_CACHE", None)
+
+        # E5 覆写负层节点 → 尾部条目即时见新内容（脏集精确失效联动）
+        cg.add("r0", "# 假设：%s 第 0 号\n# 原因：覆写后的新结论ZZZ" % QUERY,
+               layer="rejected", verification_basis="test")
+        r3, _ = cg.search(QUERY)
+        neg3 = next((x[0] for x in r3
+                     if x[0].get("id") == "rejected/r0.md"), None)
+        check("E5a 覆写 r0 后尾部条目见新内容（不陈旧）",
+              neg3 is not None and "新结论ZZZ" in (neg3.get("content") or ""),
+              f"content={str((neg3 or {}).get('content'))[:40]}")
+        cg.close()
+    finally:
+        os.environ.pop("MDCG_READ_CACHE", None)
+        shutil.rmtree(root, ignore_errors=True)
+
+    print("\n" + "=" * 60)
+    print(f"结果：PASS {PASS} / FAIL {FAIL}")
+    if FAILS:
+        for f in FAILS:
+            print(f"  - {f}")
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_en_pipeline.py

@@ -13,6 +13,14 @@
   MDCG_EN_ATOMS=1 显式开启；纯中文 query 零触发；
   mdcos 四路 RRF 的 lexical 路同源复用 expand_query_terms，自动受益。
 
+⚠ 与**统一归一层**的关系（2026-09-24 澄清，曾造成本件红灯）：
+  `semantic/unify.py::unify_query` 是**另一个、且默认开启**的开关
+  （MDCG_UNIFY_QUERY，默认 "1"，2026-09-23 口径转正）：检索入口把任意语言的
+  query 先归一成标准中文原子序列——英文 query 因此在**词法路**上就能命中中文
+  节点（与 en_zh_terms 默认关并不矛盾：一个在 query 侧归一，一个在召回词扩展侧）。
+  故本件的「跨语词面零交集 ⇒ 召回必须归零」只在**两个开关都关**时成立；
+  默认态断言相应改为「命中」，两个态都钉住（改口径必红）。
+
 运行：python -m md_cg.test_en_pipeline
 """
 from __future__ import annotations
@@ -135,9 +143,21 @@ try:
     ids = [r[0].get("id") for r in res]
     del os.environ["MDCG_EN_ATOMS"]
     ok(len(res) >= 1 and ids[0] == "n_beef", "开启：英文 query top1 召回中文牛肉节点 %s" % ids)
-    res0, _m0 = cg.search("I ate beef yesterday", judge=False)   # 默认未设=关闭
+    # 默认（两个开关都不设）：**统一归一层**（MDCG_UNIFY_QUERY 默认 "1"）把英文
+    # query 归一成中文原子序列 → 词法路直达中文节点。这是 2026-09-23 使用者拍板的
+    # 口径转正（semantic/unify.py），与旧的「跨语词面零交集」契约相反：
+    # 旧断言已按新口径改写——默认态断言「命中」，unify=0 才断言「归零」。
+    res_u, _mu = cg.search("I ate beef yesterday", judge=False)
+    ids_u = [r[0].get("id") for r in res_u]
+    ok(len(res_u) >= 1 and ids_u[0] == "n_beef",
+       "默认（unify 开）：英文 query 经统一归一后 top1 命中中文节点 %s" % ids_u)
+    os.environ["MDCG_UNIFY_QUERY"] = "0"
+    try:
+        res0, _m0 = cg.search("I ate beef yesterday", judge=False)   # 关归一+EN_ATOMS 关
+    finally:
+        os.environ.pop("MDCG_UNIFY_QUERY", None)
     ok(not res0 or all(r[1] <= 0 for r in res0),
-       "默认关闭：词面零重叠召回归零（跨语断点复现）")
+       "unify=0 且 EN_ATOMS 关：词面零重叠召回归零（跨语断点复现）")
 finally:
     shutil.rmtree(tmp, ignore_errors=True)
 

package/md_cg/test_gain_gate.py

@@ -1,212 +1,212 @@
-# -*- coding: utf-8 -*-
-"""信息增益门槛（P-T-40④）+ 价值链筛选（#37）验证。
-
-断言面：
-  ① 首探放行：无探索历史 → σ=1.0, gain=None（无证据不否决）
-  ② 停滞冷却：连续 2 次终态无变化（DEFER_EXHAUSTED）→ σ=0；冷却过期 → σ=1.0
-  ③ 证据不足：仅 1 次记录不冷却；有变化（carried→resolved）→ σ=1.0
-  ④ 集成：proposals 端 σ 筛选拦截 → deferred 可审计；enforce_gain=False 放行
-  ⑤ explore 留痕 outcomes 实现值（下轮 gain_gate 的裁决输入）
-     + meta_outcomes 并列留痕（D_meta 压力，不改 outcomes 值类型）
-  ⑥ 预算豁免：bypass_gain=True 冷却中照常探索且留痕 bypass_gain
-  ⑦ D_meta 压力冷却：终态停滞且压力仍扩大 → 冷却过期也不放行（新分支）
-
-运行：python -m md_cg.test_gain_gate
-"""
-from __future__ import annotations
-
-import os
-import shutil
-import tempfile
-import time
-
-from . import autonomy, d_meta, metacognition
-from .fsutil import append_jsonl
-from .mdcos import MdCGOS
-
-PASS = FAIL = 0
-FAILS = []
-
-
-def ok(cond, label):
-    global PASS, FAIL
-    if cond:
-        PASS += 1
-    else:
-        FAIL += 1
-        FAILS.append(label)
-        print(f"  FAIL {label}")
-
-
-def _sig(cg, t, query, d2, states):
-    append_jsonl(cg.reflection_log,
-                 {"t": t, "query": query, "d_prev": 1.0, "d_curr": 1.0,
-                  "d_delta": 0.0, "d2": d2, "states": states,
-                  "n_results": 3, "feedback": None})
-
-
-def _hist(cg, bid, terminals, t0=None, step=5.0):
-    t0 = time.time() - 10.0 if t0 is None else t0
-    for i, tml in enumerate(terminals):
-        append_jsonl(autonomy._explore_log_path(cg),
-                     {"type": "explore", "t": t0 + i * step,
-                      "actor": "test", "outcomes": {bid: tml}, "bids": [bid]})
-
-
-def _hist_meta(cg, bid, terminals, delta, t0=None, step=5.0):
-    """同 _hist，但并列留 D_meta 跨轮压力增量（新分支的裁决输入）。"""
-    t0 = time.time() - 10.0 if t0 is None else t0
-    for i, tml in enumerate(terminals):
-        append_jsonl(autonomy._explore_log_path(cg),
-                     {"type": "explore", "t": t0 + i * step,
-                      "actor": "test", "outcomes": {bid: tml}, "bids": [bid],
-                      "meta_outcomes": {"delta": {"unmodeled_growth": delta},
-                                        "proxy": autonomy.DMETA_PROXY}})
-
-
-def main():
-    tmp = tempfile.mkdtemp(prefix="mdcg_gain_")
-    try:
-        root = os.path.join(tmp, "root")
-        os.makedirs(root, exist_ok=True)
-        cg = MdCGOS(root)
-        bid = metacognition._key("反应堆冷却方案")
-
-        # ---------- ① 首探放行 ----------
-        g0 = autonomy.gain_gate(cg, bid, now=250.0)
-        ok(g0["sigma"] == 1.0 and g0["gain"] is None,
-           "①无探索历史 → σ=1.0, gain=None（Gain 是筛选器，无证据不否决）")
-
-        # ---------- ② 停滞冷却（DEFER_EXHAUSTED） ----------
-        _hist(cg, bid, ["carried", "carried"])
-        g1 = autonomy.gain_gate(cg, bid, now=time.time())
-        ok(g1["sigma"] == 0.0 and g1["gain"] == 0
-           and "DEFER_EXHAUSTED" in g1["reason"],
-           "②连续 2 次 carried 且冷却内 → σ=0（P-T-40 增益门槛）")
-        g2 = autonomy.gain_gate(cg, bid,
-                                now=(g1["last_t"] or 0.0) + 3600.0 + 1.0)
-        ok(g2["sigma"] == 1.0,
-           "②b冷却过期（now>last_t+3600）→ σ=1.0（不永久冻结）")
-
-        # ---------- ③ 证据不足 / 有变化 ----------
-        cg2_root = os.path.join(tmp, "root2")
-        os.makedirs(cg2_root, exist_ok=True)
-        cg2 = MdCGOS(cg2_root)
-        _hist(cg2, bid, ["carried"])
-        ok(autonomy.gain_gate(cg2, bid, now=250.0)["sigma"] == 1.0,
-           "③仅 1 次记录（< GAIN_WINDOW=2）不冷却（证据不足放行）")
-        cg3_root = os.path.join(tmp, "root3")
-        os.makedirs(cg3_root, exist_ok=True)
-        cg3 = MdCGOS(cg3_root)
-        _hist(cg3, bid, ["carried", "resolved"])
-        g3 = autonomy.gain_gate(cg3, bid, now=250.0)
-        ok(g3["sigma"] == 1.0 and g3["gain"] == 1,
-           "③b终态有变化（carried→resolved）→ 有增益 σ=1.0")
-
-        # ---------- ④ proposals 集成：σ 筛选拦截 ----------
-        cg4_root = os.path.join(tmp, "root4")
-        os.makedirs(cg4_root, exist_ok=True)
-        cg4 = MdCGOS(cg4_root)
-        _sig(cg4, 1.0, "反应堆冷却方案", 0.9, {"BLINDSPOT": 2})
-        _hist(cg4, bid, ["carried", "carried"])
-        pr = autonomy.proposals(cg4)
-        ok(not pr["proposals"] and len(pr["deferred"]) == 1
-           and pr["deferred"][0]["status"] == "deferred_exhausted",
-           "④冷却中盲区被 σ 筛选拦截 → deferred 可审计（不静默丢弃）")
-        ok(pr["deferred"][0]["score"] > 0,
-           "④b被拦提案的 ΔD 定价仍在（被拦原因=σ=0 非 score 低）")
-        ok("σ(Gain)" in pr["value_chain"],
-           "④c价值链口径声明（score 定价排序 + σ 资格筛选）")
-        pr2 = autonomy.proposals(cg4, enforce_gain=False)
-        ok(len(pr2["proposals"]) == 1 and not pr2["deferred"],
-           "④denforce_gain=False 放行（预算豁免入口）")
-
-        # ---------- ⑤ explore 留痕 outcomes ----------
-        cg5_root = os.path.join(tmp, "root5")
-        os.makedirs(cg5_root, exist_ok=True)
-        cg5 = MdCGOS(cg5_root)
-        cg5.add("k1", "# 功能名：反应堆冷却知识\n"
-                     "# 生效条件：问反应堆冷却方案\n"
-                     "# 子功能：知识片段\n"
-                     "# 执行：陈述知识\n"
-                     "# 验证方式：test\n"
-                     "# 不适用条件：无\n"
-                     "反应堆冷却方案概述。\n",
-               layer="knowledge", verification_basis="test")
-        _sig(cg5, 1.0, "反应堆冷却方案", 0.9, {"BLINDSPOT": 2})
-        ex = autonomy.explore(cg5, actor="test")
-        with open(autonomy._explore_log_path(cg5), encoding="utf-8") as f:
-            rec = [__import__("json").loads(x) for x in f if x.strip()][-1]
-        ok(rec.get("outcomes") and set(rec["outcomes"]) == set(rec["bids"]),
-           "⑤explore 留痕 outcomes（实现值，下轮 gain_gate 裁决输入）")
-        ok(all(t in ("unknowable", "no_anchor", "unresolved", "carried",
-                     "resolved") for t in rec["outcomes"].values()),
-           "⑤b实现值为诚实五态（不编造）")
-        ok(rec.get("bypass_gain") is False, "⑤c留痕 bypass_gain=False")
-        mo = rec.get("meta_outcomes") or {}
-        ok(set(mo.get("before") or {}) == set(d_meta.PROXY_KEYS)
-           and mo.get("proxy") == autonomy.DMETA_PROXY,
-           "⑤dexplore 留痕 meta_outcomes.before（D_meta 三代理，并列不改 outcomes）")
-        ok(all(isinstance(v, str) for v in rec["outcomes"].values()),
-           "⑤eoutcomes 值仍为终态字符串（dict 化会使 σ 静默恒 1.0，此处守卫）")
-
-        # ---------- ⑥ 预算豁免 ----------
-        cg6_root = os.path.join(tmp, "root6")
-        os.makedirs(cg6_root, exist_ok=True)
-        cg6 = MdCGOS(cg6_root)
-        cg6.add("k1", "# 功能名：反应堆冷却知识\n"
-                     "# 生效条件：问反应堆冷却方案\n"
-                     "# 子功能：知识片段\n"
-                     "# 执行：陈述知识\n"
-                     "# 验证方式：test\n"
-                     "# 不适用条件：无\n"
-                     "反应堆冷却方案概述。\n",
-               layer="knowledge", verification_basis="test")
-        _sig(cg6, 1.0, "反应堆冷却方案", 0.9, {"BLINDSPOT": 2})
-        _hist(cg6, bid, ["carried", "carried"])
-        ex2 = autonomy.explore(cg6, actor="test", bypass_gain=True)
-        ok(bool(ex2["steps"]) and ex2["steps"][0]["blindspot_id"] == bid,
-           "⑥预算豁免：冷却中盲区 bypass_gain=True 仍照常探索（2.9.3.1）")
-        with open(autonomy._explore_log_path(cg6), encoding="utf-8") as f:
-            rec6 = [__import__("json").loads(x) for x in f if x.strip()][-1]
-        ok(rec6.get("bypass_gain") is True,
-           "⑥b豁免留痕可审计（bypass_gain=True）")
-
-        # ---------- ⑦ D_meta 压力冷却（新分支） ----------
-        cg7_root = os.path.join(tmp, "root7")
-        os.makedirs(cg7_root, exist_ok=True)
-        cg7 = MdCGOS(cg7_root)
-        _hist_meta(cg7, bid, ["carried", "carried"], 0.2)
-        g7 = autonomy.gain_gate(cg7, bid, now=time.time() + 3600.0 + 60.0)
-        ok(g7["sigma"] == 0.0 and "UNDER_PRESSURE" in g7["reason"],
-           "⑦停滞 + 压力仍扩大 → 冷却过期也不放行（DEFER_EXHAUSTED_UNDER_PRESSURE）")
-        ok(g7.get("meta_rising") is True,
-           "⑦b新分支留痕 meta_rising=True（可审计，不静默冷却）")
-        ok(autonomy.gain_gate(cg7, bid, now=time.time())["sigma"] == 0.0,
-           "⑦c冷却内仍走既有分支（口径保持，不重复计算）")
-        cg8_root = os.path.join(tmp, "root8")
-        os.makedirs(cg8_root, exist_ok=True)
-        cg8 = MdCGOS(cg8_root)
-        _hist_meta(cg8, bid, ["carried", "carried"], 0.0)
-        ok(autonomy.gain_gate(cg8, bid,
-                              now=time.time() + 3600.0 + 60.0)["sigma"] == 1.0,
-           "⑦d压力未扩大（delta=0）→ 冷却过期照旧放行（只在上升时延长）")
-        cg9_root = os.path.join(tmp, "root9")
-        os.makedirs(cg9_root, exist_ok=True)
-        cg9 = MdCGOS(cg9_root)
-        _hist(cg9, bid, ["carried", "carried"])
-        ok(autonomy.gain_gate(cg9, bid,
-                              now=time.time() + 3600.0 + 60.0)["sigma"] == 1.0,
-           "⑦e缺 meta_outcomes 键 → 新分支不触发（旧留痕兼容）")
-    finally:
-        shutil.rmtree(tmp, ignore_errors=True)
-
-    print(f"\ngain_gate: {PASS} passed, {FAIL} failed")
-    if FAILS:
-        for f in FAILS:
-            print(f"  - {f}")
-    raise SystemExit(1 if FAIL else 0)
-
-
-if __name__ == "__main__":
-    main()
+# -*- coding: utf-8 -*-
+"""信息增益门槛（P-T-40④）+ 价值链筛选（#37）验证。
+
+断言面：
+  ① 首探放行：无探索历史 → σ=1.0, gain=None（无证据不否决）
+  ② 停滞冷却：连续 2 次终态无变化（DEFER_EXHAUSTED）→ σ=0；冷却过期 → σ=1.0
+  ③ 证据不足：仅 1 次记录不冷却；有变化（carried→resolved）→ σ=1.0
+  ④ 集成：proposals 端 σ 筛选拦截 → deferred 可审计；enforce_gain=False 放行
+  ⑤ explore 留痕 outcomes 实现值（下轮 gain_gate 的裁决输入）
+     + meta_outcomes 并列留痕（D_meta 压力，不改 outcomes 值类型）
+  ⑥ 预算豁免：bypass_gain=True 冷却中照常探索且留痕 bypass_gain
+  ⑦ D_meta 压力冷却：终态停滞且压力仍扩大 → 冷却过期也不放行（新分支）
+
+运行：python -m md_cg.test_gain_gate
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import tempfile
+import time
+
+from . import autonomy, d_meta, metacognition
+from .fsutil import append_jsonl
+from .mdcos import MdCGOS
+
+PASS = FAIL = 0
+FAILS = []
+
+
+def ok(cond, label):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+    else:
+        FAIL += 1
+        FAILS.append(label)
+        print(f"  FAIL {label}")
+
+
+def _sig(cg, t, query, d2, states):
+    append_jsonl(cg.reflection_log,
+                 {"t": t, "query": query, "d_prev": 1.0, "d_curr": 1.0,
+                  "d_delta": 0.0, "d2": d2, "states": states,
+                  "n_results": 3, "feedback": None})
+
+
+def _hist(cg, bid, terminals, t0=None, step=5.0):
+    t0 = time.time() - 10.0 if t0 is None else t0
+    for i, tml in enumerate(terminals):
+        append_jsonl(autonomy._explore_log_path(cg),
+                     {"type": "explore", "t": t0 + i * step,
+                      "actor": "test", "outcomes": {bid: tml}, "bids": [bid]})
+
+
+def _hist_meta(cg, bid, terminals, delta, t0=None, step=5.0):
+    """同 _hist，但并列留 D_meta 跨轮压力增量（新分支的裁决输入）。"""
+    t0 = time.time() - 10.0 if t0 is None else t0
+    for i, tml in enumerate(terminals):
+        append_jsonl(autonomy._explore_log_path(cg),
+                     {"type": "explore", "t": t0 + i * step,
+                      "actor": "test", "outcomes": {bid: tml}, "bids": [bid],
+                      "meta_outcomes": {"delta": {"unmodeled_growth": delta},
+                                        "proxy": autonomy.DMETA_PROXY}})
+
+
+def main():
+    tmp = tempfile.mkdtemp(prefix="mdcg_gain_")
+    try:
+        root = os.path.join(tmp, "root")
+        os.makedirs(root, exist_ok=True)
+        cg = MdCGOS(root)
+        bid = metacognition._key("反应堆冷却方案")
+
+        # ---------- ① 首探放行 ----------
+        g0 = autonomy.gain_gate(cg, bid, now=250.0)
+        ok(g0["sigma"] == 1.0 and g0["gain"] is None,
+           "①无探索历史 → σ=1.0, gain=None（Gain 是筛选器，无证据不否决）")
+
+        # ---------- ② 停滞冷却（DEFER_EXHAUSTED） ----------
+        _hist(cg, bid, ["carried", "carried"])
+        g1 = autonomy.gain_gate(cg, bid, now=time.time())
+        ok(g1["sigma"] == 0.0 and g1["gain"] == 0
+           and "DEFER_EXHAUSTED" in g1["reason"],
+           "②连续 2 次 carried 且冷却内 → σ=0（P-T-40 增益门槛）")
+        g2 = autonomy.gain_gate(cg, bid,
+                                now=(g1["last_t"] or 0.0) + 3600.0 + 1.0)
+        ok(g2["sigma"] == 1.0,
+           "②b冷却过期（now>last_t+3600）→ σ=1.0（不永久冻结）")
+
+        # ---------- ③ 证据不足 / 有变化 ----------
+        cg2_root = os.path.join(tmp, "root2")
+        os.makedirs(cg2_root, exist_ok=True)
+        cg2 = MdCGOS(cg2_root)
+        _hist(cg2, bid, ["carried"])
+        ok(autonomy.gain_gate(cg2, bid, now=250.0)["sigma"] == 1.0,
+           "③仅 1 次记录（< GAIN_WINDOW=2）不冷却（证据不足放行）")
+        cg3_root = os.path.join(tmp, "root3")
+        os.makedirs(cg3_root, exist_ok=True)
+        cg3 = MdCGOS(cg3_root)
+        _hist(cg3, bid, ["carried", "resolved"])
+        g3 = autonomy.gain_gate(cg3, bid, now=250.0)
+        ok(g3["sigma"] == 1.0 and g3["gain"] == 1,
+           "③b终态有变化（carried→resolved）→ 有增益 σ=1.0")
+
+        # ---------- ④ proposals 集成：σ 筛选拦截 ----------
+        cg4_root = os.path.join(tmp, "root4")
+        os.makedirs(cg4_root, exist_ok=True)
+        cg4 = MdCGOS(cg4_root)
+        _sig(cg4, 1.0, "反应堆冷却方案", 0.9, {"BLINDSPOT": 2})
+        _hist(cg4, bid, ["carried", "carried"])
+        pr = autonomy.proposals(cg4)
+        ok(not pr["proposals"] and len(pr["deferred"]) == 1
+           and pr["deferred"][0]["status"] == "deferred_exhausted",
+           "④冷却中盲区被 σ 筛选拦截 → deferred 可审计（不静默丢弃）")
+        ok(pr["deferred"][0]["score"] > 0,
+           "④b被拦提案的 ΔD 定价仍在（被拦原因=σ=0 非 score 低）")
+        ok("σ(Gain)" in pr["value_chain"],
+           "④c价值链口径声明（score 定价排序 + σ 资格筛选）")
+        pr2 = autonomy.proposals(cg4, enforce_gain=False)
+        ok(len(pr2["proposals"]) == 1 and not pr2["deferred"],
+           "④denforce_gain=False 放行（预算豁免入口）")
+
+        # ---------- ⑤ explore 留痕 outcomes ----------
+        cg5_root = os.path.join(tmp, "root5")
+        os.makedirs(cg5_root, exist_ok=True)
+        cg5 = MdCGOS(cg5_root)
+        cg5.add("k1", "# 功能名：反应堆冷却知识\n"
+                     "# 生效条件：问反应堆冷却方案\n"
+                     "# 子功能：知识片段\n"
+                     "# 执行：陈述知识\n"
+                     "# 验证方式：test\n"
+                     "# 不适用条件：无\n"
+                     "反应堆冷却方案概述。\n",
+               layer="knowledge", verification_basis="test")
+        _sig(cg5, 1.0, "反应堆冷却方案", 0.9, {"BLINDSPOT": 2})
+        ex = autonomy.explore(cg5, actor="test")
+        with open(autonomy._explore_log_path(cg5), encoding="utf-8") as f:
+            rec = [__import__("json").loads(x) for x in f if x.strip()][-1]
+        ok(rec.get("outcomes") and set(rec["outcomes"]) == set(rec["bids"]),
+           "⑤explore 留痕 outcomes（实现值，下轮 gain_gate 裁决输入）")
+        ok(all(t in ("unknowable", "no_anchor", "unresolved", "carried",
+                     "resolved") for t in rec["outcomes"].values()),
+           "⑤b实现值为诚实五态（不编造）")
+        ok(rec.get("bypass_gain") is False, "⑤c留痕 bypass_gain=False")
+        mo = rec.get("meta_outcomes") or {}
+        ok(set(mo.get("before") or {}) == set(d_meta.PROXY_KEYS)
+           and mo.get("proxy") == autonomy.DMETA_PROXY,
+           "⑤dexplore 留痕 meta_outcomes.before（D_meta 三代理，并列不改 outcomes）")
+        ok(all(isinstance(v, str) for v in rec["outcomes"].values()),
+           "⑤eoutcomes 值仍为终态字符串（dict 化会使 σ 静默恒 1.0，此处守卫）")
+
+        # ---------- ⑥ 预算豁免 ----------
+        cg6_root = os.path.join(tmp, "root6")
+        os.makedirs(cg6_root, exist_ok=True)
+        cg6 = MdCGOS(cg6_root)
+        cg6.add("k1", "# 功能名：反应堆冷却知识\n"
+                     "# 生效条件：问反应堆冷却方案\n"
+                     "# 子功能：知识片段\n"
+                     "# 执行：陈述知识\n"
+                     "# 验证方式：test\n"
+                     "# 不适用条件：无\n"
+                     "反应堆冷却方案概述。\n",
+               layer="knowledge", verification_basis="test")
+        _sig(cg6, 1.0, "反应堆冷却方案", 0.9, {"BLINDSPOT": 2})
+        _hist(cg6, bid, ["carried", "carried"])
+        ex2 = autonomy.explore(cg6, actor="test", bypass_gain=True)
+        ok(bool(ex2["steps"]) and ex2["steps"][0]["blindspot_id"] == bid,
+           "⑥预算豁免：冷却中盲区 bypass_gain=True 仍照常探索（2.9.3.1）")
+        with open(autonomy._explore_log_path(cg6), encoding="utf-8") as f:
+            rec6 = [__import__("json").loads(x) for x in f if x.strip()][-1]
+        ok(rec6.get("bypass_gain") is True,
+           "⑥b豁免留痕可审计（bypass_gain=True）")
+
+        # ---------- ⑦ D_meta 压力冷却（新分支） ----------
+        cg7_root = os.path.join(tmp, "root7")
+        os.makedirs(cg7_root, exist_ok=True)
+        cg7 = MdCGOS(cg7_root)
+        _hist_meta(cg7, bid, ["carried", "carried"], 0.2)
+        g7 = autonomy.gain_gate(cg7, bid, now=time.time() + 3600.0 + 60.0)
+        ok(g7["sigma"] == 0.0 and "UNDER_PRESSURE" in g7["reason"],
+           "⑦停滞 + 压力仍扩大 → 冷却过期也不放行（DEFER_EXHAUSTED_UNDER_PRESSURE）")
+        ok(g7.get("meta_rising") is True,
+           "⑦b新分支留痕 meta_rising=True（可审计，不静默冷却）")
+        ok(autonomy.gain_gate(cg7, bid, now=time.time())["sigma"] == 0.0,
+           "⑦c冷却内仍走既有分支（口径保持，不重复计算）")
+        cg8_root = os.path.join(tmp, "root8")
+        os.makedirs(cg8_root, exist_ok=True)
+        cg8 = MdCGOS(cg8_root)
+        _hist_meta(cg8, bid, ["carried", "carried"], 0.0)
+        ok(autonomy.gain_gate(cg8, bid,
+                              now=time.time() + 3600.0 + 60.0)["sigma"] == 1.0,
+           "⑦d压力未扩大（delta=0）→ 冷却过期照旧放行（只在上升时延长）")
+        cg9_root = os.path.join(tmp, "root9")
+        os.makedirs(cg9_root, exist_ok=True)
+        cg9 = MdCGOS(cg9_root)
+        _hist(cg9, bid, ["carried", "carried"])
+        ok(autonomy.gain_gate(cg9, bid,
+                              now=time.time() + 3600.0 + 60.0)["sigma"] == 1.0,
+           "⑦e缺 meta_outcomes 键 → 新分支不触发（旧留痕兼容）")
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+    print(f"\ngain_gate: {PASS} passed, {FAIL} failed")
+    if FAILS:
+        for f in FAILS:
+            print(f"  - {f}")
+    raise SystemExit(1 if FAIL else 0)
+
+
+if __name__ == "__main__":
+    main()