@furongjun1999/dsh-memory 0.6.1 → 0.7.1

package/md_cg/test_n204_n205_n226_n227_n228_n229_exit_gates.py

@@ -16,7 +16,7 @@
   ③ N226 `md_cg/provenance.py:427`（`_node_digest` 直读 cg.index）+`539-543`：
      `cg(op="edges", expand_nodes=true)` 的端点摘要与边拓扑零可见性闸，两端都
      不可见的边照返回、`aggregates.sample` 亦回 `child->parent`（同库同身份的
-     `stg.timeline` stg.py:133/172 早已接线 `_readable`——本处是漏网出口）。
+     `stg.timeline` stg.py:144/238 早已接线 `_readable`——本处是漏网出口）。
   ④ N227 `md_cg/evolution.py:265/332` × `mdcos.py:3261`（health_os 挂
      evolution.summary）× `mcp_server.py:3071-3072/2125/3288-3292`：演化台账
      （`_evolution/ledger.md`）出口无可见性/身份闸，且工具面粗粒度 op 映射

package/md_cg/test_n212_n213_n224_generation_gates.py

@@ -362,11 +362,14 @@ def main():
     check("3c 阳性对照：共享档（internal/S1）仍在候选中（闸未误伤）",
           _ctrl is not None and any(e is _ctrl for e in _cands),
           "cand=%d" % len(_cands), live=True)
-    # ③d 第三序面（本批首手实测：本条同时钉住 _open_content 的解密出口闸）：
-    # 本进程**未 flush** 的陈旧条目在重载时被 _dirty 重放盖过盘上更新条目
-    # ⇒ 判据说 internal/S1、盘面已是 private/S2 ⇒ search 的正文水合把密文解成
-    # 明文返回（实测修复前 A.search 返回该节点且 content = 私密档明文）。
-    print("\n【③d】陈旧 _dirty 条目遮蔽他进程更新条目时的正文水合")
+    # ③d 第三序面（本批首手实测：本条同时钉住 _open_content 的解密出口闸）。
+    # **N230（2026-10-01，P0-3）改判**：本组原 setup 断言「A 内存条目仍是本地未
+    # 落盘版本（`_dirty` 重放遮蔽盘上真值）」，即把**旧盖新**当既定行为钉住。
+    # N230 修复后该遮蔽不再发生——重载取回的是他进程写下的更新条目，本实例这条
+    # 陈旧 `_dirty` 被逐字见证判为陈旧、**跳过重放**（新记录必须能盖住旧记录）。
+    # 故 setup 断言改为「收敛到盘面真值（private/S2）」；下游两条（`get` 同闸拒绝、
+    # 正文水合不泄明文）语义不变，且在新语义下更强：索引侧密级也已是 private。
+    print("\n【③d】他进程更新条目必须盖过本实例陈旧 _dirty 条目（N230）")
     a6 = _reflect(R6, "S1")
     a6.add("n213_d", INTERNAL_BODY, layer="contextual")        # 故意不 flush
     b6 = _reflect(R6, "S2")
@@ -375,9 +378,12 @@ def main():
     b6.flush()
     a6._maybe_reload_index()
     _e6 = a6.index["nodes"].get("n213_d") or {}
-    check("3d setup：A 内存条目仍是本地未落盘版本（_dirty 重放遮蔽盘上真值）",
-          _e6.get("sensitivity") == "internal" and _e6.get("session") == "S1",
-          "sens=%r sess=%r" % (_e6.get("sensitivity"), _e6.get("session")))
+    check("3d setup：A 重载后条目**收敛到盘面真值**（N230：旧不得盖新）",
+          _e6.get("sensitivity") == "private" and _e6.get("session") == "S2"
+          and a6._dirty_replay_superseded >= 1,
+          "sens=%r sess=%r superseded=%r"
+          % (_e6.get("sensitivity"), _e6.get("session"),
+             getattr(a6, "_dirty_replay_superseded", None)))
     check("3d A.get 同闸拒绝",
           a6.get("n213_d") is None,
           repr((a6.get("n213_d") or {}).get("content") or "")[:50], live=True)

package/md_cg/test_n214_n215_n221_n222_write_face_gates.py

@@ -98,6 +98,13 @@ for _k in ("MDCG_TOKEN", "MDCG_TENANT", "MDCG_CLEARANCE", "MDCG_SESSION",
            "PYTHONIOENCODING", "PYTHONUTF8"):
     os.environ.pop(_k, None)
 
+# 三档自治批次②（2026-10-02）**夹具隔离**：本守卫考的不是档位面（档位守卫 =
+# md_cg/test_autonomy_modes.py），故显式置 full 档——回到改动前「动作直落」的
+# 行为，使本文件的断言意图（合并/覆写/软删真的发生）逐条不变；env 键名从唯一
+# 真源表取（本文件不构成第二处字面量）。
+from . import autonomy_modes as _autonomy_modes          # noqa: E402
+os.environ[_autonomy_modes.AUTONOMY_ENV_KEYS["mode"]] = "full"
+
 from . import forgetting, mcp_server, protect, scrub, tokens, writelimit  # noqa: E402
 from .datapath import aux_root                                # noqa: E402
 from .mdcos import MdCGSecure                                 # noqa: E402

package/md_cg/test_n230_dirty_replay.py

@@ -0,0 +1,375 @@
+# -*- coding: utf-8 -*-
+"""N230 `_dirty` 重放遮蔽守卫（P0-3：新记录必须能盖住旧记录，旧不得盖新）。
+
+缺陷（材料自编 N226，`docs/eval/缺陷挖掘_自主迭代_v25.md:132/:178` 记为**留档未修**）：
+
+    站点 `md_cg/mdcg.py` 的 `_maybe_reload_index`（改动前 :1353-1357）——
+    `for nid, e in self._dirty.items(): … idx["nodes"][nid] = e` **无条件**把本实例
+    未 flush 的 `_dirty` 条目盖回重载后的索引上，没有任何时序/代际比较。
+
+**探针实跑复现（2026-10-01，独立 tempfile 沙箱）**：
+
+    ① A = MdCG(R, autoflush=1000)；A.add("x_node", 正文=OLD) ⇒ A._dirty 含 x_node（未 flush）
+    ② B = MdCG(R, autoflush=1)；B.add("x_node", 正文=NEW)；B.close() ⇒ 盘面与快照都是 NEW
+    ③ A._maybe_reload_index() 返回 **True**（确实重载了），但重载后
+       A.index["nodes"]["x_node"]["content_hash"] **仍是 OLD**；新建读者实例 C 读到 NEW
+       ⇒ 索引与盘面撕裂（检索面按旧值给候选/桶/指纹）
+
+**修法（本轮）**：给 `_dirty` 引入「**落盘逐字见证**」——标脏时记下节点文件的
+`(st_mtime_ns, st_size)`；重放前再 stat 一次，失配 ⇒ 本实例这条已被盘面更新盖过
+⇒ **跳过重放**（放行盘面）。证不出陈旧（无 path / stat 失败 / 未挂 root）时照旧
+重放——「本实例未落盘写入不因重载从检索面消失」这条既有不变量一并保留。
+tombstone（`None`）语义**一字不改**（`_unstage` 立即 flush，不跨重载存活）。
+
+断言分组：
+
+  G0 前置——站点在位：`_dirty_entry_superseded` / `_note_witness` 各一处；`_dirty.root` 已挂。
+  G1 **红基线可出示**（探针三步复现）——旧记录**不得**盖住盘面新记录：A 重载后
+     必须收敛到 NEW（= 新建读者实例 C 的读数），且 `_dirty_replay_superseded ≥ 1`。
+  G2 不变量保持——他进程只动**别的**节点时，本实例未 flush 的写入必须仍在检索面
+     上（`_dirty_replay_superseded == 0`，该条目仍在 index 且哈希不变）。
+  G3 tombstone 语义一字不改——`_dirty[nid]=None` 在重载时仍 pop 掉该条目。
+  G4 见证判据的判别力（正/负对照）——`_dirty_entry_superseded` 的四条边界逐一断言。
+  G5 单点结构（静态）——`for nid, e in self._dirty.items():` 的重放体内**必须**
+     经过 `_dirty_entry_superseded`（副本回归/裸赋值回归即红）。
+
+运行：python -X utf8 -m md_cg.test_n230_dirty_replay
+      python -X utf8 -m md_cg.test_n230_dirty_replay --head-baseline  # 红基线自证
+      python -X utf8 -m md_cg.test_n230_dirty_replay --mutate         # 定点变异自证
+      python -X utf8 -m md_cg.test_n230_dirty_replay --mutate --list
+
+退出码（fail-closed）：0 = 全绿；1 = 有断言失败 / 变异未按预期转红；
+2 = ANCHOR-MISS（变异锚点在当前源码里找不到——实现改了却没同步本表）。
+
+**基线纪律**：`--head-baseline` 把 `_dirty_entry_superseded` 换回「恒 False」
+（= 改动前的无条件重放），G1 必须转红；若不红，说明 G1 没有判别力。
+"""
+from __future__ import annotations
+
+import contextlib
+import io
+import os
+import shutil
+import sys
+import tempfile
+import types
+
+from .mdcg import MdCG
+
+_PASS = []
+_FAIL = []
+_SKIP = []
+_SRC = {}
+_TMP = tempfile.mkdtemp(prefix="mdcg_n230_")
+_GEN = [0]
+_REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+BODY = "# 功能名：%s\n# 生效条件：全时窗\n# 子功能：s\n# 执行：%s\n" \
+       "# 验证方式：test\n# 不适用条件：无\n"
+
+
+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 ""))
+
+
+def _rel_text(rel: str) -> str:
+    if rel in _SRC:
+        return _SRC[rel]
+    with open(os.path.join(_REPO, rel), encoding="utf-8") as f:
+        return f.read()
+
+
+def _sandbox(name: str) -> str:
+    _GEN[0] += 1
+    d = os.path.join(_TMP, "gen%d_%s" % (_GEN[0], name))
+    os.makedirs(d, exist_ok=True)
+    return d
+
+
+def _disk_body(root: str, nid: str) -> str:
+    p = os.path.join(root, "knowledge", "orphan", nid + ".md")
+    return open(p, encoding="utf-8").read()
+
+
+# ---------------------------------------------------------------- G0
+def g0():
+    print("== G0 站点在位（前置）==")
+    src = _rel_text("md_cg/mdcg.py")
+    ok(src.count("def _dirty_entry_superseded") == 1,
+       "G0a mdcg.py 内 `_dirty_entry_superseded` 恰一处定义")
+    ok(src.count("def _note_witness") == 1,
+       "G0b mdcg.py 内 `_note_witness` 恰一处定义")
+    ok("self._dirty.root = self.root" in src,
+       "G0c MdCG.__init__ 把数据根交给脏集（见证要靠它拼绝对路径）")
+    r = _sandbox("g0")
+    cg = MdCG(r, autoflush=1000)
+    ok(cg._dirty.root == cg.root and os.path.isabs(cg._dirty.root),
+       "G0d 实例构造后 _dirty.root = 数据根", cg._dirty.root)
+    ok(cg._dirty_replay_superseded == 0,
+       "G0e 读数 _dirty_replay_superseded 初始为 0")
+    cg.close()
+
+
+# ---------------------------------------------------------------- G1
+def _probe_repro():
+    """探针三步复现（返回值供 G1 逐条断言）。"""
+    r = _sandbox("g1")
+    a = MdCG(r, autoflush=1000)
+    a.add("x_node", BODY % ("x", "OLD"), layer="knowledge",
+          verification_basis="test")
+    witness = dict(a._dirty.staged_stat)
+    b = MdCG(r, autoflush=1)
+    b.add("x_node", BODY % ("x", "NEW"), layer="knowledge",
+          verification_basis="test")
+    b.close()                                   # 他进程写出新盘面 + 新快照
+    reloaded = a._maybe_reload_index()
+    c = MdCG(r, autoflush=1000)                 # 新建读者实例（只读盘面）
+    out = {"root": r, "a": a, "c": c, "reloaded": reloaded,
+           "a_hash": (a.index["nodes"].get("x_node") or {}).get("content_hash"),
+           "c_hash": (c.index["nodes"].get("x_node") or {}).get("content_hash"),
+           "superseded": a._dirty_replay_superseded,
+           "witness": witness, "dirty": list(a._dirty),
+           "disk": _disk_body(r, "x_node")}
+    return out
+
+
+def g1():
+    print("== G1 红基线可出示：旧记录不得盖住盘面新记录（探针复现）==")
+    R = _probe_repro()
+    ok(R["witness"].get("x_node") is not None,
+       "G1 前置：A 标脏时记下了逐字见证 (mtime_ns, size)", R["witness"])
+    ok(R["reloaded"] is True,
+       "G1a 前置：重载确已发生（_maybe_reload_index() == True）", R["reloaded"])
+    ok("执行：NEW" in R["disk"],
+       "G1b 前置：盘面真值是 NEW", R["disk"].splitlines()[3])
+    ok(R["c_hash"] is not None and R["a_hash"] == R["c_hash"],
+       "G1c **新盖旧**：A 重载后条目 == 新建读者实例 C 的条目（收敛到盘面）",
+       {"A": R["a_hash"], "C": R["c_hash"]})
+    ok(R["superseded"] >= 1,
+       "G1d 可判读数：至少 1 条被判「已被盘面更新盖过」而跳过重放",
+       R["superseded"])
+    ok(R["a"]._dirty.get("x_node") is not None,
+       "G1e 该条仍在 _dirty（本实例确实还没 flush——不是靠 flush 凑的绿）",
+       list(R["a"]._dirty))
+    R["a"].close(); R["c"].close()
+
+
+# ---------------------------------------------------------------- G2
+def g2():
+    print("== G2 不变量保持：他进程只动别的节点时，未落盘写入不消失 ==")
+    r = _sandbox("g2")
+    a = MdCG(r, autoflush=1000)
+    a.add("y_node", BODY % ("y", "MINE"), layer="knowledge",
+          verification_basis="test")
+    a_hash = a.index["nodes"]["y_node"]["content_hash"]
+    b = MdCG(r, autoflush=1)
+    b.add("z_node", BODY % ("z", "OTHER"), layer="knowledge",
+          verification_basis="test")
+    b.close()
+    reloaded = a._maybe_reload_index()
+    ok(reloaded is True, "G2 前置：重载确已发生（他进程改了签名）", reloaded)
+    ok(a._dirty_replay_superseded == 0,
+       "G2a y_node 未被判陈旧（盘面上没人动它）——见证失配才是陈旧",
+       a._dirty_replay_superseded)
+    e = a.index["nodes"].get("y_node")
+    ok(e is not None and e.get("content_hash") == a_hash,
+       "G2b **不变量保持**：本实例未 flush 的 y_node 仍在检索面上且哈希不变",
+       {"present": e is not None})
+    ok(a.index["nodes"].get("z_node") is not None,
+       "G2c 他进程的 z_node 也可见（重载不该只保一边）")
+    a.close(); b.close()
+
+
+# ---------------------------------------------------------------- G3
+def g3():
+    print("== G3 tombstone 语义一字不改 ==")
+    r = _sandbox("g3")
+    c = MdCG(r, autoflush=1000)
+    c.add("tomb_node", BODY % ("t", "X"), layer="knowledge",
+          verification_basis="test")
+    c.flush()                              # 入日志；_dirty 清空
+    ok("tomb_node" in c.index["nodes"], "G3 前置：节点已在索引里")
+    c.index["nodes"].pop("tomb_node", None)
+    c._dirty["tomb_node"] = None           # 不经 _unstage（那条路立即 flush）
+    ok(c._dirty.get("tomb_node") is None and "tomb_node" in c._dirty,
+       "G3a 前置：_dirty 里有该 nid 的 tombstone（值 None）")
+    c._index_sig = None                    # 强制签名失配 → 下次读面必然重载
+    ok(c._maybe_reload_index() is True, "G3b 前置：已重载")
+    ok("tomb_node" not in c.index["nodes"],
+       "G3c tombstone 仍被重放 pop 掉（本修复不碰 tombstone 语义）")
+    c.close()
+
+
+# ---------------------------------------------------------------- G4
+def g4():
+    print("== G4 见证判据的判别力（正/负对照）==")
+    r = _sandbox("g4")
+    c = MdCG(r, autoflush=1000)
+    c.add("w_node", BODY % ("w", "V1"), layer="knowledge",
+          verification_basis="test")
+    ok(c._dirty_entry_superseded("w_node") is False,
+       "G4a 负对照：标脏后盘面未动 → 不判陈旧（未落盘写入照旧重放）")
+    import time as _t
+    _t.sleep(0.01)
+    with open(os.path.join(r, c._dirty["w_node"]["path"]), "w",
+              encoding="utf-8", newline="\n") as f:
+        f.write(BODY % ("w", "V2"))
+    ok(c._dirty_entry_superseded("w_node") is True,
+       "G4b 正对照：盘面被改写 → 判陈旧（旧不得盖新）")
+    os.remove(os.path.join(r, c._dirty["w_node"]["path"]))
+    ok(c._dirty_entry_superseded("w_node") is True,
+       "G4c 正对照：文件被删掉（标脏时在）→ 判陈旧")
+    c._dirty.staged_stat.pop("w_node", None)
+    ok(c._dirty_entry_superseded("w_node") is False,
+       "G4d 无见证（证不出陈旧）→ 不判陈旧——不变量优先于覆盖面")
+    c._dirty.staged_stat["nopath"] = (1, 1)
+    c._dirty["nopath"] = {"layer": "knowledge"}       # 无 path 的条目
+    ok(c._dirty_entry_superseded("nopath") is False,
+       "G4e 条目无 path → 不判陈旧（无见证可查）")
+    ok(c._dirty.root == r and c._dirty.staged_stat.get("w_node") is None,
+       "G4f 移除文件的那次 stat 失败**不登记**见证（staged_stat 无该键）")
+    c.close()
+
+
+# ---------------------------------------------------------------- G5
+def g5():
+    print("== G5 单点结构（静态：重放体必须过判据）==")
+    src = _rel_text("md_cg/mdcg.py")
+    i = src.index("for nid, e in self._dirty.items():")
+    body = src[i:i + 900]
+    ok("self._dirty_entry_superseded(nid)" in body,
+       "G5 重放循环体内经过 `_dirty_entry_superseded`（副本回归即红）")
+    ok("superseded += 1" in body and "continue" in body,
+       "G5a 判为陈旧即 `continue`（跳过重放，不是只记账）")
+    # 可执行行里不得再有无条件覆盖的裸赋值形态
+    code = "\n".join(l for l in body.splitlines()
+                     if not l.strip().startswith("#"))
+    ok(code.count('idx["nodes"][nid] = e') == 1,
+       "G5b 重放体里 `idx[\"nodes\"][nid] = e` 恰一处（在判据之后）")
+    ok("self._dirty_replay_superseded = superseded" in src,
+       "G5c 跳过条数落在可判读数 `_dirty_replay_superseded` 上")
+
+
+_GROUPS = (g0, g1, g2, g3, g4, g5)
+
+
+def _run_groups() -> int:
+    _PASS.clear()
+    _FAIL.clear()
+    for g in _GROUPS:
+        try:
+            g()
+        except Exception as exc:                       # noqa: BLE001
+            ok(False, "断言组 %s 抛异常：%s" % (g.__name__, exc))
+            import traceback
+            print(traceback.format_exc()[-900:])
+    return len(_FAIL)
+
+
+# ---------------------------------------------------------------- 变异表
+# 锚点 = (名字, rel, old, new)。每次变异必须让套件**转红**：
+#   M1 重放体恢复无条件覆盖（= 改动前形态）→ G1c/G1d/G5 红
+#   M2 判据恒 False（见证照记但不采信）→ G1c/G1d 红
+#   M3 见证完全不登记 → 判据永远拿不到见证 ⇒ 同 M2
+_MUTATIONS = (
+    ("重放体恢复无条件覆盖（改动前形态）", "md_cg/mdcg.py",
+     "            if self._dirty_entry_superseded(nid):\n"
+     "                superseded += 1\n                continue",
+     "            if False:\n                superseded += 1\n                continue"),
+    ("判据恒 False（见证不采信）", "md_cg/mdcg.py",
+     "        return (cur.st_mtime_ns, cur.st_size) != st",
+     "        return False"),
+    ("见证完全不登记", "md_cg/mdcg.py",
+     "        self.staged_stat[k] = (st.st_mtime_ns, st.st_size)",
+     "        self.staged_stat.pop(k, None)"),
+)
+
+
+def _exec_module(name: str, rel: str, text: str):
+    ns = {"__name__": name, "__package__": "md_cg",
+          "__file__": os.path.join(_REPO, rel)}
+    exec(compile(text, rel, "exec"), ns)               # noqa: S102 —— 基线自证用
+    m = types.ModuleType(name)
+    m.__dict__.update(ns)
+    return m
+
+
+def _mutate_mode(list_only: bool = False) -> int:
+    print("!! 定点变异自证：逐条把判据改回「改动前/失效」形态，套件必须转红\n")
+    if list_only:
+        for name, rel, _o, _n in _MUTATIONS:
+            print("  %-34s [%s]" % (name, rel))
+        return 0
+    anchor_miss, bad = [], []
+    with contextlib.redirect_stdout(io.StringIO()):
+        clean = _run_groups()
+    print("  未变异基线：失败=%d（必须为 0）" % clean)
+    if clean:
+        bad.append("未变异基线即失败")
+
+    for name, rel, old, new in _MUTATIONS:
+        src = _rel_text(rel)
+        if old not in src:
+            print("  ANCHOR-MISS %s —— 锚点在 %s 源码里找不到（实现改了却没同步"
+                  "本表）" % (name, rel))
+            anchor_miss.append(name)
+            continue
+        mut_src = src.replace(old, new, 1)
+        _SRC[rel] = mut_src
+        try:
+            mut = _exec_module("md_cg._n230_mut", rel, mut_src)
+            globals()["MdCG"] = mut.MdCG
+            with contextlib.redirect_stdout(buf := io.StringIO()):
+                reds = _run_groups()
+            detail = buf.getvalue()
+        finally:
+            globals()["MdCG"] = _REAL_MdCG
+            _SRC.pop(rel, None)
+        red_lines = [l for l in detail.splitlines()
+                     if l.strip().startswith("FAIL ")]
+        verdict = "红" if reds else "**仍全绿 = 该判据空转**"
+        print("  %s %-34s 红项=%d  %s"
+              % ("OK    " if reds else "MISS  ", name, reds, verdict))
+        for l in red_lines[:5]:
+            print("        " + l.strip()[5:])
+        if not reds:
+            bad.append(name)
+
+    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
+
+
+_REAL_MdCG = MdCG
+
+
+def main() -> int:
+    try:
+        if "--mutate" in sys.argv:
+            return _mutate_mode("--list" in sys.argv)
+        if "--head-baseline" in sys.argv:
+            print("!! 红基线模式：_dirty_entry_superseded 换回「恒 False」"
+                  "（= 改动前的无条件重放），G1 应当转红\n")
+            MdCG._dirty_entry_superseded = lambda self, nid: False
+            n = _run_groups()
+            print("\n== 红基线判定：应有失败 ==")
+            print("红基线失败数 = %d（>0 才算断言有判别力）" % n)
+            for f in _FAIL:
+                print("   红:", f)
+            return 0 if n else 1
+        n = _run_groups()
+        print("\nN230 `_dirty` 重放遮蔽守卫：%d 通过，%d 失败，%d 跳过"
+              % (len(_PASS), n, len(_SKIP)))
+        return 0 if not n else 1
+    finally:
+        shutil.rmtree(_TMP, ignore_errors=True)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_p2_mcp.py

@@ -12,6 +12,14 @@ import subprocess
 import sys
 import tempfile
 
+# 三档自治批次②（2026-10-02）**夹具隔离**：本守卫考的不是档位面（档位守卫 =
+# md_cg/test_autonomy_modes.py），故显式置 full 档——回到改动前「动作直落」的
+# 行为（本套的 forget/restore/review_decide 用例都假定软删真的发生），使断言
+# 意图逐条不变。子进程继承本进程 environ，故被拉起的 MCP server 同档。
+# env 键名从唯一真源表取（本文件不构成第二处字面量）。
+from md_cg import autonomy_modes as _autonomy_modes
+os.environ[_autonomy_modes.AUTONOMY_ENV_KEYS["mode"]] = "full"
+
 PASS = FAIL = 0
 FAILS = []