@furongjun1999/dsh-memory 0.5.1 → 0.6.1

package/md_cg/test_none_id_write_guard.py

@@ -0,0 +1,166 @@
+# -*- coding: utf-8 -*-
+"""test_none_id_write_guard —— None.md 脏节点写入面守卫（DSH 在役库实测缺陷 P3）
+
+现场（DSH 端在役库实测）：``knowledge/orphan/None.md`` 出现在检索与 route 候选中
+参与打分。取证链（2026-09-26，临时库实弹复现）：
+
+  1. 批次 24（2a57c2a2，2026-09-24）之前 ``add()`` 对 node_id **零校验**，
+     ``path = os.path.join(d, f"{node_id}.md")`` 直拼——``add(None, ...)`` 直落
+     ``None.md``（旧版直接源头，git 取证 ``git show 2a57c2a2^:md_cg/mdcg.py``）。
+  2. 现行代码 ``add(None)``/``add("")`` 已被 P0-1 白名单拒绝（mdcg.py _NODE_ID_RE），
+     **但字符串 ``"None"``（Python ``str(None)`` 的污染形态）形状合法照常放行**：
+     实弹复现 ``add("None", ...)`` → 生成 ``knowledge/orphan/None.md``。
+     ``"null"``（TS/JS ``String(null)`` 形态）同族放行。这是现行写入面残留洞。
+  3. 盘上存量 ``None.md`` 经 ``_scan_nodes`` 全库扫描收录为 ``id="None"``，
+     ``search``/route 候选参与打分（复现实测命中）——与 DSH 病理现象完全吻合。
+
+修复（本守卫的红绿两态锚点）：``md_cg/mdcg.py`` ``add()`` 写入边界把空语义值的
+字符串化污染形态（整串精确等值 ``"None"`` / ``"null"``，**大小写敏感、不扩子串**）
+结构化拒绝（ValueError，fail-closed）——add 是全部写入链（writepipe 执行器 /
+review accept / identity / consolidate / branches）落盘的唯一真源边界，堵一处即
+全链路堵死。``_move_layer`` 等直写点只对已在索引中的既有节点操作，不新造 id。
+
+清理面（不在本守卫内，运维建议）：存量 None.md 属历史脏数据——删除
+``<root>/knowledge/orphan/None.md`` 文件后 ``rebuild_index()`` 即从索引与检索/
+route 候选中消失（[6] 的收录取证即清理有效性依据）；勿用 ``add("None",...)``
+覆写清理（修复后该形态被拒）。
+
+隔离纪律：全程 ``tempfile.mkdtemp`` 临时库，MDCG_ROOT/MDCG_TOKEN_FILE 不参与
+（库实例以显式 root 构造），不触真实令牌库与真实在役数据目录。
+
+自检 floor：断言总数低于 FLOOR 视为失败——防「探针面失效 → 假绿」。
+
+运行：python -X utf8 -m md_cg.test_none_id_write_guard
+"""
+from __future__ import annotations
+
+import os
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from md_cg.mdcos import MdCGOS  # noqa: E402
+
+FLOOR = 12           # 断言总数下限（防假绿）
+passed = failed = 0
+
+
+def check(name, cond, detail=""):
+    global passed, failed
+    if cond:
+        passed += 1
+        print("  [PASS] " + name)
+    else:
+        failed += 1
+        print("  [FAIL] " + name + "  " + str(detail)[:200])
+
+
+def _none_md_hits(root):
+    """盘面上所有 None.md（大小写不敏感——Windows 盘面本就不区分）。"""
+    hits = []
+    for dirpath, _dirs, files in os.walk(root):
+        for f in files:
+            if f.lower() == "none.md":
+                hits.append(os.path.relpath(os.path.join(dirpath, f), root)
+                            .replace("\\", "/"))
+    return sorted(hits)
+
+
+def main():
+    root = tempfile.mkdtemp(prefix="mdcg_none_guard_")
+    try:
+        return _run(root)
+    finally:
+        import shutil
+        shutil.rmtree(root, ignore_errors=True)   # 测毕清理（临时库纪律）
+
+
+def _run(root):
+    cg = MdCGOS(root)
+
+    print("[1] 红形态：字符串 \"None\"（str(None) 污染形态）在写入边界拒绝")
+    rejected = False
+    try:
+        nid = cg.add("None", "污染形态内容 无条件")
+        check("add(\"None\") 被拒绝", False, "返回了 " + repr(nid))
+    except ValueError as e:
+        rejected = True
+        check("add(\"None\") 被拒绝", True)
+        check("拒绝是结构化 ValueError 且消息点名形态",
+              "None" in str(e) and "node_id" in str(e), str(e)[:120])
+    check("盘面无 None.md 生成", _none_md_hits(root) == [], _none_md_hits(root))
+    check("索引无 id='None' 条目", "None" not in cg.index["nodes"])
+
+    print("[2] 红形态：字符串 \"null\"（String(null) 跨语言同族形态）")
+    try:
+        nid = cg.add("null", "跨语言污染形态内容 无条件")
+        check("add(\"null\") 被拒绝", False, "返回了 " + repr(nid))
+    except ValueError:
+        check("add(\"null\") 被拒绝", True)
+    check("盘面仍无 None.md/null.md", _none_md_hits(root) == [],
+          _none_md_hits(root))
+
+    print("[3] 防误杀：含 None/null 子串的合法 id 照常写入（只拒整串精确等值）")
+    ok1 = cg.add("NoneBot_1", "含 None 子串的合法 id 无条件")
+    ok2 = cg.add("nullify_test", "含 null 子串的合法 id 无条件")
+    check("add(\"NoneBot_1\") 正常", ok1 == "NoneBot_1")
+    check("add(\"nullify_test\") 正常", ok2 == "nullify_test")
+
+    print("[4] 既有语义不回退：None 本体 / falsy 仍结构化拒绝（P0-1）")
+    # 注（2026-09-28 更新）：这条相邻缺陷（非字符串 node_id 以原值入索引键）
+    # 已在 legacy P3 轮次修复——写面 add 对非 str node_id fail-closed 拒写 +
+    # 派生面 _scan_nodes/日志重放键归一为 str，守卫见
+    # md_cg/test_legacy_p3_node_id_type.py；此处 falsy 三形态的拒绝语义不变。
+    for bad in (None, "", 0):
+        try:
+            cg.add(bad, "非法形态内容")
+            check("add(%r) 仍被拒绝" % (bad,), False, "竟返回成功")
+        except ValueError:
+            check("add(%r) 仍被拒绝（ValueError）" % (bad,), True)
+
+    print("[5] writepipe 链：node_id=\"None\" 不落盘（DEFER/BLINDSPOT 短路入队"
+          "或落盘前被 add 边界拒绝，两态皆 fail-closed）")
+    from md_cg import writepipe
+    pipe = writepipe.WritePipeline()
+    writepipe.install_default_gates(pipe)
+    committed = None
+    try:
+        out = pipe.execute(cg, {"content": "writepipe 污染形态", "node_id": "None",
+                                "content_kind": "work_done",
+                                "生效条件": "writepipe 守卫探针"})
+        committed = out.get("committed")
+    except ValueError:
+        committed = False                       # 落盘前被 add 边界拒绝（修复态）
+    check("writepipe 对 node_id='None' 不提交落盘", committed is not True,
+          repr(committed))
+    check("盘面无 None.md（writepipe 后复查）", _none_md_hits(root) == [],
+          _none_md_hits(root))
+
+    print("[6] 存量脏数据收录取证：盘上 None.md 被 _scan_nodes 收进索引（DSH 病理机理；"
+          "亦是清理建议的依据——删文件 + rebuild 即消失）")
+    d = os.path.join(root, "knowledge", "orphan")
+    os.makedirs(d, exist_ok=True)
+    with open(os.path.join(d, "None.md"), "w", encoding="utf-8") as f:
+        f.write("---\nid: None\nlayer: knowledge\nimportance: 0.5\n"
+                "confidence: 0.6\ncreated_at: 1\ntags: []\n---\n\n历史脏数据内容\n")
+    cg2 = MdCGOS(root)                      # 重开：走 _scan_nodes 全库扫描
+    cg2.rebuild_index()
+    check("历史 None.md 被扫描收录（机理复证）", "None" in cg2.index["nodes"])
+    res, _m = cg2.search_rrf("历史脏数据内容", k=10, judge=False)
+    check("检索候选命中 id='None'（病理复证）",
+          any(r[0]["id"] == "None" for r in res), [r[0]["id"] for r in res])
+    os.remove(os.path.join(d, "None.md"))   # 清理后即消失（清理建议有效性）
+    cg3 = MdCGOS(root)
+    cg3.rebuild_index()
+    check("删文件 + rebuild 后 id='None' 从索引消失（清理有效）",
+          "None" not in cg3.index["nodes"])
+
+    check(f"断言总数不低于 FLOOR（{passed} >= {FLOOR}）", passed >= FLOOR)
+
+    print(f"\nnone_id_write_guard: {passed} 通过 / {failed} 失败")
+    return 0 if not failed else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_opt_batch1_md_cg.py

@@ -0,0 +1,451 @@
+# -*- coding: utf-8 -*-
+"""opt-batch1 守卫 · md_cg 侧（C-1 三处写盘标脏 + C-7 升格门槛接真源）。
+
+来源：外部双路调研（Codex 实测 + ZCode 工作流）确认、并经编排侧抽核实的
+opt-batch1 批次。本文件只覆盖 md_cg 侧两条；rust 侧（R-1/R-2/R-3/R-6）的
+守卫是 crate 内单测（`rust/src/*.rs` 的 `#[cfg(test)]` 与 `rust/tests/`）。
+
+覆盖与判据：
+
+  C-1（三处「写后读」永久陈旧）——`forgetting.reinforce`（reinforce 落库）、
+      `insight.verify`（洞见裁决）、`scrub._apply_offset`（置信度校准）三处
+      调 `cg._write_node` 后只改内存 index entry（scrub 连条目都不改），
+      **不标 `_dirty`**。读缓存默认开（`MDCG_READ_CACHE=1`，见 `readcache.enabled`），
+      其新鲜度按 `_DirtyDict.path_gen` 判；不标脏 ⇒ 同进程「写后读」永久拿到
+      旧 fm。对照先例：`md_cg/mdcg.py` 的 `update_tags` / verify 直写分支
+      `self._dirty[node_id] = e`。
+      每处三条断言：①写盘确实发生（正对照，防夹具空转）②`nid in cg._dirty`
+      ③同实例 `cg._read(e)` 与 `readcache.direct_read`（穿透缓存读盘上真值）
+      逐位一致——②③即「标脏」的可观测判据。
+
+  C-7（升格门槛自带第二份要素常量）——`consolidate.py` 原先自带
+      `CCG_REQUIRED = ("生效条件","子功能","执行","不适用条件")`（4 元素），
+      与真源 `nodefile.CCG_REQUIRED`（6 元素，多「功能名」「验证方式」）不一致
+      ⇒ 缺「验证方式」的弱证据节点判 complete，可被 `promote_memories` 升格进
+      knowledge 层（`predict` 亦按同一常量判 node_ready）。
+      断言：转发真源（`is` 同一对象）/ 缺「验证方式」者被拒 / 六要素齐全者不被误伤。
+
+运行：
+    python -X utf8 -m md_cg.test_opt_batch1_md_cg                  # 正向
+    python -X utf8 -m md_cg.test_opt_batch1_md_cg --mutate          # 定点变异自证
+    python -X utf8 -m md_cg.test_opt_batch1_md_cg --mutate --list   # 只列变异表
+
+退出码（fail-closed）：0 = 全绿；1 = 有断言失败 / 变异未按预期转红；
+2 = **ANCHOR-MISS**（变异锚点在当前源码里找不到，说明实现改了却没同步本表——
+本表就是判据，锚点漂移必须硬失败，不得静默跳过）。
+
+**基线纪律**：本守卫**不以 git HEAD（或任何提交快照）为基线源**——所有
+「修复前」形态都由**在当前工作区源码上做定点文本变异**得到（`_MUTATIONS`），
+基线随代码一起走、不随提交漂移（本仓已有两次「基线绑提交即失效」的教训）。
+变异表每条都记 `expect_red`（预期转红条数），实际红数不等即判失败——这条
+同时钉住「有判别力」（红数 > 0）与「无过度杀伤」（红数恰好命中预期）。
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import sys
+import tempfile
+import time
+import types
+
+# ── 隔离前置：必须在 import md_cg 子模块**之前**（tokens/theory 等在模块级把
+# aux_root() 冻成常量）——否则会指到真实 ~/.mdcg 并在那里建密钥/令牌库。
+# 与 md_cg/test_n197_n208_write_face_gates.py 同款前置（同一纪律）。 ──
+_TMP = tempfile.mkdtemp(prefix="optb1_")
+os.environ["MDCG_AUX_ROOT"] = os.path.join(_TMP, "auxroot")
+os.environ["MDCG_MASTER_KEY"] = "ab" * 32          # 哑主密钥（绝不触真实密钥面）
+os.environ["MDCG_TOKEN_FILE"] = os.path.join(_TMP, "tokens.json")
+os.environ["MDCG_ROOT"] = os.path.join(_TMP, "cgroot")
+for _k in ("MDCG_TOKEN", "MDCG_TENANT", "MDCG_CLEARANCE", "MDCG_SESSION",
+           "DSH_SESSION_ID", "MDCG_LEGACY_ENV_AUTH", "MDCG_LEGACY_ENV_ADMIN",
+           "MDCG_CAN_ADMIN", "MDCG_CAN_WRITE", "MDCG_STATE_ROOT",
+           "MDCG_DATA_ROOT", "MDCG_TENANT_REGISTRY", "MDCG_VERIFIER_MODULES"):
+    os.environ.pop(_k, None)
+
+from . import consolidate, forgetting, insight, nodefile, readcache, scrub, tokens  # noqa: E402
+from .mdcos import MdCGSecure                                                        # noqa: E402
+from .security import Principal                                                      # noqa: E402
+
+try:
+    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+except AttributeError:
+    pass
+
+_HERE = os.path.dirname(os.path.abspath(__file__))
+_REPO = os.path.dirname(_HERE)
+_SELF = os.path.abspath(__file__)
+
+# 被测模块的**可替换引用**：变异模式会把其中一项换成 exec 出来的变异副本，
+# 断言组一律经本表取模块（不直接闭包捕获原模块），否则变异对断言不可见。
+MOD = {
+    "forgetting": forgetting,
+    "insight": insight,
+    "scrub": scrub,
+    "consolidate": consolidate,
+}
+
+_PASS: list = []
+_FAIL: list = []
+_OPEN: list = []
+
+
+def ok(cond, msg, extra=""):
+    (_PASS if cond else _FAIL).append(msg)
+    print(("  PASS " if cond else "  FAIL ") + msg
+          + (("  ← " + str(extra)) if (extra and not cond) else ""))
+    return bool(cond)
+
+
+def _cleanup(path) -> bool:
+    import gc
+    for _ in range(6):
+        shutil.rmtree(path, ignore_errors=True)
+        if not os.path.exists(path):
+            return True
+        gc.collect()
+        time.sleep(0.2)
+    return not os.path.exists(path)
+
+
+def _princ(role="designer", clearance="secret", can_admin=True):
+    spec = tokens.role_spec(role)
+    return Principal(tenant="default", actor="optb1-" + role,
+                     clearance=clearance, can_write=bool(spec["can_write"]),
+                     can_admin=can_admin, role=role,
+                     layers_allow=spec["layers_allow"],
+                     ops_allow=spec["ops_allow"], auth_mode="test")
+
+
+def _secured(tag: str):
+    """建一个临时库 + designer 身份；返回 (cg, tmpdir)。"""
+    d = tempfile.mkdtemp(prefix="optb1_%s_" % tag)
+    cg = MdCGSecure(os.path.join(d, "root"), principal=_princ())
+    _OPEN.append(cg)
+    return cg, d
+
+
+def _close_all():
+    for cg in _OPEN:
+        try:
+            cg.close()
+        except Exception:                      # noqa: BLE001 —— 清理面不得再抛
+            pass
+    _OPEN.clear()
+
+
+def _prime_cache(cg, nid):
+    """把读缓存填成「写前旧值」（模拟真实的「先读过、再写」时序）。"""
+    e = cg.index["nodes"][nid]
+    cg._read(e)                                # 装缓存（写前快照）
+    return e
+
+
+def _cache_matches_disk(cg, e) -> bool:
+    """同实例 `_read`（走读缓存）是否与穿透缓存的盘上真值一致。"""
+    cached = cg._read(e)
+    direct = readcache.direct_read(cg, e)
+    return (cached[0] or {}) == (direct[0] or {}) and \
+        (cached[1] or "") == (direct[1] or "")
+
+
+# ================================================================ G0 前置自证
+def g0():
+    print("== G0 隔离与前置自证 ==")
+    ok(readcache.enabled(), "G0a 读缓存默认开（C-1 的成立前提：未设 MDCG_READ_CACHE 时 enabled() 为真）")
+    ok(os.path.abspath(tokens.token_file()).lower().startswith(_TMP.lower()),
+       "G0b 令牌库落在守卫临时目录（绝不触真实凭据）",
+       "tok=%s" % tokens.token_file())
+    # 基线源自证（反「基线绑提交」）：变异加载器直接 open 当前工作区源文件，
+    # 读到的就是它此刻在盘上的内容——不含任何提交快照读取面。
+    _rel = os.path.join("md_cg", "consolidate.py")
+    _live = open(os.path.join(_REPO, _rel), encoding="utf-8").read()
+    _mut, _src = _load_mutated(_rel, "CCG_REQUIRED = nodefile.CCG_REQUIRED",
+                               "CCG_REQUIRED = ()")
+    ok(_mut is not None and _src == _live,
+       "G0c 变异基线源 = 当前工作区源码（非 git HEAD／提交快照）",
+       "lead=%s" % (_mut is not None))
+
+
+# ================================================================ G1 C-1a reinforce
+def g1():
+    print("== G1 C-1a forgetting.reinforce：写盘后标脏（写后读可见）==")
+    cg, d = _secured("reinforce")
+    try:
+        cg.add("n_re", "香蕉 optb1unique 强化正文", layer="knowledge",
+               importance=0.5)
+        cg.flush()
+        readcache.install(cg)
+        e = _prime_cache(cg, "n_re")
+        before = cg._read(e)[0].get("importance")
+        ok(before == 0.5, "G1a 前置：写前缓存快照 importance=0.5", before)
+        r = MOD["forgetting"].reinforce(cg, "n_re", delta=0.3)
+        ok(r is not None and r.get("importance") == 0.8,
+           "G1b 正对照：reinforce 写盘成功（返回值自认 0.8）", r)
+        ok("n_re" in cg._dirty,
+           "G1c 标脏：写盘后 cg._dirty 含该节点（不标脏则 path_gen 不推进）",
+           "dirty=%s" % list(cg._dirty))
+        ok(_cache_matches_disk(cg, e),
+           "G1d 同实例写后读与盘上真值逐位一致（读缓存已失效）",
+           "cached=%s direct=%s" % (cg._read(e)[0].get("importance"),
+                                    readcache.direct_read(cg, e)[0].get("importance")))
+    finally:
+        _close_all()
+        _cleanup(d)
+
+
+# ================================================================ G2 C-1b insight.verify
+def g2():
+    print("== G2 C-1b insight.verify：裁决写盘后标脏 ==")
+    cg, d = _secured("insight")
+    try:
+        cond = {"retrievability": 0.8, "outside_observer": True,
+                "cross_domain": ["存储", "网络"], "premise_questioned": True,
+                "pressure": "low", "continuity_turns": 3, "externalized": True,
+                "tone": "curious"}
+        ev = cg.insight(action="record",
+                        statement="optb1 探针事件：写后读判据（zzins）",
+                        conditions=cond)
+        nid = ev["node_id"]
+        cg.flush()
+        readcache.install(cg)
+        e = _prime_cache(cg, nid)
+        ok(cg._read(e)[0].get("insight_state") == "pending",
+           "G2a 前置：写前缓存快照 insight_state=pending",
+           cg._read(e)[0].get("insight_state"))
+        out = MOD["insight"].verify(
+            cg, node_id=nid, actor="designer", verdict="verified",
+            note="optb1 守卫",
+            evidence=[{"type": "v3", "ref": "optb1", "note": "n"}])
+        ok(bool(out.get("ok")) and out.get("state") == "verified",
+           "G2b 正对照：verify 裁决写盘成功（state=verified）", out)
+        ok(nid in cg._dirty,
+           "G2c 标脏：写盘后 cg._dirty 含该节点", "dirty=%s" % list(cg._dirty))
+        ok(_cache_matches_disk(cg, e),
+           "G2d 同实例写后读与盘上真值逐位一致（insight_state/importance/tags 同批可见）",
+           "cached=%s direct=%s" % (cg._read(e)[0].get("insight_state"),
+                                    readcache.direct_read(cg, e)[0].get("insight_state")))
+    finally:
+        _close_all()
+        _cleanup(d)
+
+
+# ================================================================ G3 C-1c scrub._apply_offset
+def g3():
+    print("== G3 C-1c scrub._apply_offset：校准写盘后标脏 ==")
+    cg, d = _secured("scrub")
+    try:
+        cg.add("n_cal", "# 功能名：校准探针\n# 正文：香蕉 校准 optb1\n",
+               layer="knowledge", importance=0.5, confidence=0.6)
+        cg.flush()
+        readcache.install(cg)
+        e = _prime_cache(cg, "n_cal")
+        ok(cg._read(e)[0].get("confidence") == 0.6,
+           "G3a 前置：写前缓存快照 confidence=0.6")
+        adj, skipped = MOD["scrub"]._apply_offset(cg, 0.2, min_evidence=0,
+                                                  actor="designer")
+        ok(adj == 1, "G3b 正对照：校准写盘成功（adjusted=1）",
+           "adjusted=%s skipped=%s" % (adj, skipped))
+        ok("n_cal" in cg._dirty,
+           "G3c 标脏：写盘后 cg._dirty 含该节点（本处原先连条目都不改、更不标脏）",
+           "dirty=%s" % list(cg._dirty))
+        ok(_cache_matches_disk(cg, e),
+           "G3d 同实例写后读与盘上真值逐位一致（confidence=0.8 可见）",
+           "cached=%s direct=%s" % (cg._read(e)[0].get("confidence"),
+                                    readcache.direct_read(cg, e)[0].get("confidence")))
+    finally:
+        _close_all()
+        _cleanup(d)
+
+
+# ================================================================ G4 C-7 升格门槛
+def g4():
+    print("== G4 C-7 consolidate.promote_memories：升格门槛接六要素真源 ==")
+    cg, d = _secured("c7")
+    try:
+        root = cg.root
+        weak = ("# 功能名：弱证据候选\n# 生效条件：问弱证据候选时\n# 子功能：x\n"
+                "# 执行：y\n# 不适用条件：无\n")          # 缺「验证方式」
+        strong = weak + "# 验证方式：编译器/静态检查通过\n"
+        cg.add("cand_weak", "# 源\n" + weak, layer="contextual",
+               merge_count=3, importance=0.8)
+        cg.add("cand_strong", "# 源\n" + strong, layer="contextual",
+               merge_count=3, importance=0.8)
+        cg.flush()
+
+        ccg_req = MOD["consolidate"].CCG_REQUIRED
+        ok(ccg_req is nodefile.CCG_REQUIRED,
+           "G4a 转发真源：consolidate.CCG_REQUIRED is nodefile.CCG_REQUIRED（非本地副本）",
+           "consolidate=%r nodefile=%r" % (ccg_req, nodefile.CCG_REQUIRED))
+        ok(set(ccg_req) == set(nodefile.CCG_MARKS) and len(ccg_req) == 6
+           and "验证方式" in ccg_req,
+           "G4b 要素集=六要素（含「验证方式」——缺它即弱证据）",
+           ccg_req)
+
+        rep = MOD["consolidate"].promote_memories(root, apply=False)
+        ids = [s["id"] for s in rep.get("samples") or []]
+        ok("cand_weak" not in ids and rep.get("skipped_incomplete") == 1,
+           "G4c 缺「验证方式」的候选被拒（不计入升格候选，计入 skipped_incomplete）",
+           "targeted=%s skipped_incomplete=%s samples=%s"
+           % (rep.get("targeted"), rep.get("skipped_incomplete"), ids))
+        ok("cand_strong" in ids,
+           "G4d 正对照：六要素齐全者仍被升格候选（门槛收紧不得误伤合格节点）",
+           "targeted=%s samples=%s" % (rep.get("targeted"), ids))
+    finally:
+        _close_all()
+        _cleanup(d)
+
+
+# ================================================================ G5 单点结构
+def g5():
+    print("== G5 单点结构（防副本回归）==")
+    p = os.path.join(_HERE, "consolidate.py")
+    src = open(p, encoding="utf-8").read()
+    ok("CCG_REQUIRED = nodefile.CCG_REQUIRED" in src,
+       "G5a consolidate.py 以转发形态接线真源（源码可见）")
+    code = "\n".join(l for l in src.splitlines() if not l.strip().startswith("#"))
+    ok('CCG_REQUIRED = ("生效条件"' not in code
+       and "CCG_REQUIRED = ('生效条件'" not in code,
+       "G5b 可执行行内不再有本地 4 元素字面量副本（副本回归即红）")
+    # 三处 C-1 写点的标脏在同源先例处也在位（对照面：证明修复方向是本仓既有范式）
+    mdsrc = open(os.path.join(_HERE, "mdcg.py"), encoding="utf-8").read()
+    ok(mdsrc.count("self._dirty[node_id] = e") >= 2,
+       "G5c 对照先例在位：mdcg.py 的 update_tags / verify 直写分支显式标脏",
+       mdsrc.count("self._dirty[node_id] = e"))
+
+
+# ================================================================ 变异表
+# 每条 = (名称, MOD 键, 源码锚点, 替换文本, 预期转红条数)。
+# 锚点必须逐字命中当前源码（找不到 → ANCHOR-MISS → 退出码 2，fail-closed）。
+_MUTATIONS = (
+    ("C-1a 删 forgetting.reinforce 的标脏",
+     "forgetting",
+     "        _dirty = getattr(cg, \"_dirty\", None)\n"
+     "        if isinstance(_dirty, dict):\n"
+     "            _dirty[node_id] = e\n",
+     "        pass  # MUT\n",
+     2),
+    ("C-1b 删 insight.verify 的标脏",
+     "insight",
+     "        _dirty = getattr(cg, \"_dirty\", None)\n"
+     "        if isinstance(_dirty, dict):\n"
+     "            _dirty[node_id] = ent\n",
+     "        pass  # MUT\n",
+     2),
+    ("C-1c 删 scrub._apply_offset 的标脏",
+     "scrub",
+     "            _dirty = getattr(cg, \"_dirty\", None)\n"
+     "            if isinstance(_dirty, dict):\n"
+     "                _dirty[nid] = e\n",
+     "            pass  # MUT\n",
+     2),
+    ("C-7 恢复本地 4 元素副本（撤掉转发）",
+     "consolidate",
+     "CCG_REQUIRED = nodefile.CCG_REQUIRED",
+     "CCG_REQUIRED = (\"生效条件\", \"子功能\", \"执行\", \"不适用条件\")",
+     3),
+)
+
+
+def _load_mutated(relpath: str, old: str, new: str):
+    """把 `relpath` 的源码做定点文本替换后 exec 成独立模块（不落盘、不改工作区）。"""
+    path = os.path.join(_REPO, relpath)
+    src = open(path, encoding="utf-8").read()
+    if old not in src:
+        return None, src
+    mut_src = src.replace(old, new, 1)
+    mod = types.ModuleType("md_cg._optb1_mut")
+    mod.__package__ = "md_cg"
+    mod.__file__ = path
+    exec(compile(mut_src, path, "exec"), mod.__dict__)      # noqa: S102 —— 定点变异
+    return mod, src
+
+
+_RELPATH = {
+    "forgetting": os.path.join("md_cg", "forgetting.py"),
+    "insight": os.path.join("md_cg", "insight.py"),
+    "scrub": os.path.join("md_cg", "scrub.py"),
+    "consolidate": os.path.join("md_cg", "consolidate.py"),
+}
+
+
+def _run_groups() -> int:
+    """跑全部断言组，返回失败数（变异核验复用）。"""
+    _PASS.clear()
+    _FAIL.clear()
+    for g in (g0, g1, g2, g3, g4, g5):
+        try:
+            g()
+        except Exception as exc:                            # noqa: BLE001
+            ok(False, "断言组 %s 抛异常：%s" % (g.__name__, exc))
+    _close_all()
+    return len(_FAIL)
+
+
+def _mutate_mode(list_only: bool = False) -> int:
+    print("!! 定点变异自证：逐条把修复点改回缺陷形态，套件必须按预期条数转红\n")
+    if list_only:
+        for name, key, old, new, exp in _MUTATIONS:
+            print("  %-40s %-12s expect_red=%d" % (name, key, exp))
+        return 0
+
+    import contextlib
+    import io
+    anchor_miss = []
+    bad = []
+    with contextlib.redirect_stdout(io.StringIO()):
+        clean = _run_groups()
+    print("  未变异基线：失败=%d（必须为 0）" % clean)
+    if clean:
+        bad.append("未变异基线即失败")
+
+    for name, key, old, new, expect in _MUTATIONS:
+        mod, src = _load_mutated(_RELPATH[key], old, new)
+        if mod is None:
+            print("  ANCHOR-MISS %s —— 锚点在 %s 当前源码里找不到"
+                  "（实现改了却没同步本表；基线不得静默漂移）"
+                  % (name, _RELPATH[key]))
+            anchor_miss.append(name)
+            continue
+        live = MOD[key]
+        MOD[key] = mod
+        try:
+            with contextlib.redirect_stdout(buf := io.StringIO()):
+                fails_extra = _run_groups()
+            detail = buf.getvalue()
+        finally:
+            MOD[key] = live
+        red = [l for l in detail.splitlines() if l.strip().startswith("FAIL ")]
+        verdict = "红" if fails_extra else "**仍全绿 = 该判据空转**"
+        mark = "OK  " if fails_extra == expect else "MISMATCH"
+        print("  %s %-40s 红项=%d 预期=%d  %s" % (mark, name, fails_extra, expect, verdict))
+        for l in red:
+            print("        " + l.strip()[5:])
+        if fails_extra != expect:
+            bad.append("%s（红=%d 预期=%d）" % (name, fails_extra, expect))
+
+    if anchor_miss:
+        print("\nANCHOR-MISS：%s" % "、".join(anchor_miss))
+        print("退出码 2（fail-closed）：变异表锚点漂移即判失败，不得静默跳过")
+        return 2
+    print("\n定点变异自证：%s" % ("PASS（每处判据都被打红且恰好命中预期项数）"
+                                   if not bad else "FAIL —— " + "、".join(bad)))
+    return 0 if not bad else 1
+
+
+def main() -> int:
+    if "--mutate" in sys.argv:
+        try:
+            return _mutate_mode("--list" in sys.argv)
+        finally:
+            _cleanup(_TMP)
+    try:
+        n_fail = _run_groups()
+        print("\nopt-batch1 守卫（md_cg 侧）：%d 通过，%d 失败" % (len(_PASS), n_fail))
+        return 0 if not n_fail else 1
+    finally:
+        _cleanup(_TMP)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_p1.py

@@ -157,13 +157,13 @@ def main():
     queries = ["能量守恒", "二分查找", "细胞呼吸", "贝塞尔不等式", "牛顿第二定律",
                "光合作用", "事务隔离", "内力与截面法", "熵增", "机会成本"]
     contents = {nid: (cg.get(nid) or {}).get("content", "")
-                for nid, e in cg.index["nodes"].items() if e["layer"] == "knowledge"}
+                for nid, e in list(cg.index["nodes"].items()) if e["layer"] == "knowledge"}
     t1 = t5 = 0
     n = 0
     blindspots = []
     print(f"  {'query':<14}{'真值集':>7}{'召回':>6}{'Top-1':>7}")
     for q in queries:
-        gold = [nid for nid, c in contents.items() if q in c]
+        gold = [nid for nid, c in list(contents.items()) if q in c]
         if not gold:
             blindspots.append(q)
             continue
@@ -251,10 +251,10 @@ def main():
     check("weakened → confidence 下调", post2 < pre2, f"{pre2} → {post2}")
     # falsified：add_rejected 按内容 hash 幂等，故断言「存在负记忆条目」而非计数增量
     cg.verify("p1_verify", "发现反例：条件不成立", "falsified")
-    neg_ids = [e.get("path") for e in cg.index["nodes"].values()
+    neg_ids = [e.get("path") for e in list(cg.index["nodes"].values())
                if e["layer"] == "rejected"]
     neg_hit = False
-    for p in neg_ids:
+    for p in list(neg_ids):
         full_p = os.path.join(ROOT, p)
         try:
             with open(full_p, encoding="utf-8") as f:
@@ -273,7 +273,7 @@ def main():
     # 「knowledge 层恰好 = 语料 + 本测试显式写入」就必须被显式守住——
     # 有残留节点会在这里打红，而不是被 rmtree 静默掩盖。
     explicit_knowledge = ("p1_ok", "p1_accept", "p1_defer", "p1_spot", "p1_reject")
-    n_know = sum(1 for e in cg.index["nodes"].values() if e["layer"] == "knowledge")
+    n_know = sum(1 for e in list(cg.index["nodes"].values()) if e["layer"] == "knowledge")
     check("重跑 ≡ 首跑：knowledge 层节点数不多不少（无残留污染）",
           n_know == corpus.EXPECTED_NODES + len(explicit_knowledge),
           f"{n_know} == {corpus.EXPECTED_NODES} + {len(explicit_knowledge)}")