@furongjun1999/dsh-memory 0.6.1 → 0.7.0

package/md_cg/sustain.py

@@ -70,6 +70,31 @@ DEFAULT_HEAL_INTERVAL = 300.0     # 自愈巡检 5min
 DEFAULT_SCRUB_INTERVAL = 3600.0   # 记忆自净（抽查/去污染/校准）1h
 DEFAULT_EVOLVE_INTERVAL = 7200.0  # 演化巡检（固化/重要性候选盘点）2h；只读
 DEFAULT_TIDY_INTERVAL = 21600.0   # 整理巡检（contextual 同构组聚合）6h
+
+# ---- 四档 `auto_*` 缺省的**单一真源**（P0-2，2026-10-01）--------------------
+# 为什么要有这张表：同一组缺省此前在**三处**各写一份——op 路径
+# （mcp_server.py 的 `_sustain_call` start 分支）、env 路径（`_start_sustain`）
+# 与 `SustainLoop.__init__` 形参。三份必然漂移，且已经漂了：`auto_tidy` 在
+# op 路径是 `False`、在 env 路径是 `"1"`（True）——同一个 `(root,name)` 走哪条
+# 入口得到相反的整理语义，是**对外可见的缺省不一致**。
+# 纪律：改缺省只改这里；调用点只许经 `auto_default` / `auto_from_env` /
+# `auto_from_args` 读取，**不得再写第二处字面量**（守卫 test_auto_defaults.py 钉死）。
+#
+# ⚠ 本轮**对外可见的缺省变更**（P0-2 裁决值 = 开）：`auto_tidy` 由 op 路径原
+# 字面量 `False` 收敛为 `True`，取 env 路径（生产路径：常驻 serve 自启）既有值
+# ——该动作确定性、永不删除节点、可逆可审计（见 `_tick_tidy` 说明），op 路径的
+# `False` 是唯一错位项。**opt-out：`MDCG_AUTO_TIDY=0`（env 路径）／显式传
+# `auto_tidy=false`（op 路径——显式入参仍优先于本表）。**
+AUTO_DEFAULTS = {"auto_heal": True, "auto_scrub": False,
+                 "auto_evolve": False, "auto_tidy": True}
+#: 各 `auto_*` 的 env 覆盖键（env 路径入口照此读；即各档的 opt-out 名）。
+AUTO_ENVS = {"auto_heal": "MDCG_SUSTAIN_AUTOHEAL",
+             "auto_scrub": "MDCG_AUTO_SCRUB",
+             "auto_evolve": "MDCG_AUTO_EVOLVE",
+             "auto_tidy": "MDCG_AUTO_TIDY"}
+#: 关断字面量——与两入口既有口径逐字一致的三写法（`0` / `false` / `False`）。
+AUTO_OFF_VALUES = ("0", "false", "False")
+
 DEFAULT_WARN_FACTOR = 2.5         # 2.5× 心跳间隔 → 警告
 DEFAULT_DEAD_FACTOR = 3.5         # 3.5× → 失联
 DEFAULT_WORKING_FACTOR = 2.0      # 任务执行中阈值 ×2
@@ -78,6 +103,39 @@ ACCESS_LOG_COMPACT_LINES = 500    # 访问日志超过该行数即折叠（否
 _POLL = 0.2                       # 循环轮询步长（常驻进程 CPU 可忽略）
 
 
+# 生效条件：name 为 AUTO_DEFAULTS 的键时返回该档缺省的 bool（真源表取值，无副作用）；键不存在时抛 KeyError（不做静默回落——拼错档名即为编程错误）。
+def auto_default(name: str) -> bool:
+    """`auto_*` 缺省的真源读取（无环境、无入参）。"""
+    return bool(AUTO_DEFAULTS[name])
+
+
+# 生效条件：name 为 AUTO_DEFAULTS 的键时，从 environ（缺省 os.environ）按 AUTO_ENVS[name] 取名取值，缺键时回落「真源缺省对应的字面量」（真值→"1"、假值→"0"）；取值经 str() 后不属于 AUTO_OFF_VALUES 即为真。返回 bool。
+def auto_from_env(name: str, environ=None) -> bool:
+    """env 路径（常驻 serve 自启）的 `auto_*` 读取器。
+
+    与改动前的逐处字面量**同义**：`os.environ.get(<键>, <默认>) not in
+    ("0", "false", "False")`——默认字面量由真源表推出，不再各写一份。
+    """
+    env = os.environ if environ is None else environ
+    return str(env.get(AUTO_ENVS[name],
+                       "1" if AUTO_DEFAULTS[name] else "0")) not in AUTO_OFF_VALUES
+
+
+# 生效条件：args 为 dict 且含 name 键时返回 bool(args[name])（显式传 None 亦为 False——与改动前 `bool(a.get(name, <默认>))` 逐字同义）；args 非 dict 或缺该键时回落 auto_default(name)。
+def auto_from_args(name: str, args, environ=None) -> bool:
+    """op 路径（工具面 `sustain action=start`）的 `auto_*` 读取器。
+
+    判据是**键在不在**而不是值真假：`{"auto_tidy": False}` 与
+    `{"auto_tidy": None}` 都按「显式给了」处理（前者关、后者按 bool(None)=False
+    关），缺键才回落真源缺省——与改动前 `a.get(name, default)` 的语义一字不差。
+    `environ` 仅为签名对齐 `auto_from_env`（op 路径不读 env；保留位以免调用点
+    两边形参不一致）。
+    """
+    if isinstance(args, dict) and name in args:
+        return bool(args[name])
+    return auto_default(name)
+
+
 # --------------------------------------------------------------------------
 # 心跳
 # --------------------------------------------------------------------------
@@ -944,7 +1002,7 @@ def watermarks(cg) -> dict:
 # 常驻循环
 # --------------------------------------------------------------------------
 
-# 生效条件：传入 cg 即构造实例并把 self.cg 指向它，name/beat_interval/heal_interval/auto_heal/scrub_interval/auto_scrub/evolve_interval/auto_evolve/tidy_interval/auto_tidy 用各默认值（DEFAULT_* 与 False/True）经 float()/bool() 落为 self 属性，ledger 为假值（默认 None）时回落 SessionLedger(cg.root)，d 经 net_dir(d) 赋值，其余运行态字段初始化为 False/None/空列表/空 Event/Lock
+# 生效条件：传入 cg 即构造实例并把 self.cg 指向它，name/beat_interval/heal_interval/auto_heal/scrub_interval/auto_scrub/evolve_interval/auto_evolve/tidy_interval/auto_tidy 用各默认值（DEFAULT_* 与 AUTO_DEFAULTS 真源表）经 float()/bool() 落为 self 属性，ledger 为假值（默认 None）时回落 SessionLedger(cg.root)，d 经 net_dir(d) 赋值，其余运行态字段初始化为 False/None/空列表/空 Event/Lock
 class SustainLoop:
     """常驻自维持循环：后台线程周期心跳 + 周期巡检 + 必要时自愈。
 
@@ -952,18 +1010,31 @@ class SustainLoop:
     让对端立刻看到「正常下线」而不是「失联」。
     """
 
-# 生效条件：传入 cg 时按 name 与各 DEFAULT_* 默认值初始化——self.d=net_dir(d)（d 假值时回落 MDCG_SUSTAIN_DIR/~/ .mdcg/sustain）、self.ledger=ledger or SessionLedger(cg.root)（ledger 假值时新建），beat/heal/scrub/evolve/tidy 间隔 float() 化、auto_heal/auto_scrub/auto_evolve/auto_tidy bool() 化后存为实例属性；
+# 生效条件：传入 cg 时按 name 与各 DEFAULT_* / AUTO_DEFAULTS 真源表默认值初始化——self.d=net_dir(d)（d 假值时回落 MDCG_SUSTAIN_DIR/~/ .mdcg/sustain）、self.ledger=ledger or SessionLedger(cg.root)（ledger 假值时新建），beat/heal/scrub/evolve/tidy 间隔 float() 化、auto_heal/auto_scrub/auto_evolve/auto_tidy bool() 化后存为实例属性；
     def __init__(self, cg, name: str = "md_cg", *,
                  beat_interval: float = DEFAULT_BEAT_INTERVAL,
                  heal_interval: float = DEFAULT_HEAL_INTERVAL,
-                 auto_heal: bool = True, d: str = None,
+                 # 四档 `auto_*` 缺省取自**单一真源**（P0-2）：本形参默认值与
+                 # 两个入口读取的是同一张表，`SustainLoop(cg)` 与
+                 # `sustain action=start` / `_start_sustain` 三面同值。
+                 auto_heal: bool = AUTO_DEFAULTS["auto_heal"], d: str = None,
                  ledger: SessionLedger = None,
                  scrub_interval: float = DEFAULT_SCRUB_INTERVAL,
-                 auto_scrub: bool = False,
+                 auto_scrub: bool = AUTO_DEFAULTS["auto_scrub"],
                  evolve_interval: float = DEFAULT_EVOLVE_INTERVAL,
-                 auto_evolve: bool = False,
+                 auto_evolve: bool = AUTO_DEFAULTS["auto_evolve"],
                  tidy_interval: float = DEFAULT_TIDY_INTERVAL,
-                 auto_tidy: bool = False):
+                 auto_tidy: bool = AUTO_DEFAULTS["auto_tidy"],
+                 # 第六档：睡眠周期（§三 九步 / §4.7）。四个缺省一律取自
+                 # `md_cg/sleep.py` 的 **env 表单一真源**（SLEEP_ENV_DEFAULTS +
+                 # sleep_env 族读取器）——本处**不写第二份缺省字面量**；两个
+                 # 入口（`_start_sustain` / op 路径）同样只经那些读取器。
+                 sleep_interval: float = None,
+                 auto_sleep: bool = None,
+                 sleep_merge: str = None,
+                 sleep_window: str = None,
+                 sleep_scrub_apply: bool = None):
+        from . import sleep as _sleep
         self.cg = cg
         self.name = name
         self.beat_interval = float(beat_interval)
@@ -977,6 +1048,22 @@ class SustainLoop:
         self.auto_evolve = bool(auto_evolve)
         self.tidy_interval = float(tidy_interval)
         self.auto_tidy = bool(auto_tidy)
+        # 第六档睡眠周期：值全来自 sleep 模块的真源读取器（缺省见 §4.7 表）。
+        self.sleep_interval = float(_sleep.sleep_interval()
+                                    if sleep_interval is None
+                                    else sleep_interval)
+        self.auto_sleep = bool(_sleep.sleep_enabled() if auto_sleep is None
+                               else auto_sleep)
+        self.sleep_merge = (_sleep.sleep_merge_mode() if sleep_merge is None
+                            else str(sleep_merge))
+        self.sleep_window = (_sleep.sleep_window() if sleep_window is None
+                             else str(sleep_window))
+        self.sleep_scrub_apply = bool(_sleep.sleep_scrub_apply()
+                                      if sleep_scrub_apply is None
+                                      else sleep_scrub_apply)
+        self.last_sleep = None
+        self.sleeps = []
+        self.sleep_round = 0
         self.task_running = False
         self.beats = 0
         self.last_beat = None
@@ -1032,13 +1119,14 @@ class SustainLoop:
         clear_stamp(self.name, self.d)
         return self
 
-# 生效条件：self._stop 未置位期间轮询，按 beat_interval/heal_interval/scrub_interval/evolve_interval/tidy_interval 到期分别执行 beat 与 _tick_heal/_tick_scrub/_tick_evolve/_tick_tidy，各 tick 抛出的异常被吞掉不中断循环，末尾以 _stop.wait(_POLL) 休眠；
+# 生效条件：self._stop 未置位期间轮询，按 beat_interval/heal_interval/scrub_interval/evolve_interval/tidy_interval/**sleep_interval（第六档）** 到期分别执行 beat 与 _tick_heal/_tick_scrub/_tick_evolve/_tick_tidy/_tick_sleep，各 tick 抛出的异常被吞掉不中断循环，末尾以 _stop.wait(_POLL) 休眠；
     def _run(self):
         next_beat = time.time() + self.beat_interval
         next_heal = time.time() + self.heal_interval
         next_scrub = time.time() + self.scrub_interval
         next_evolve = time.time() + self.evolve_interval
         next_tidy = time.time() + self.tidy_interval
+        next_sleep = time.time() + self.sleep_interval
         while not self._stop.is_set():
             now = time.time()
             if now >= next_beat:
@@ -1071,13 +1159,20 @@ class SustainLoop:
                 except Exception:
                     pass                       # 整理巡检失败不中断常驻
                 next_tidy = now + self.tidy_interval
+            if now >= next_sleep:
+                try:
+                    self._tick_sleep()
+                except Exception:
+                    pass                       # 睡眠周期失败不中断常驻
+                next_sleep = now + self.sleep_interval
             self._stop.wait(_POLL)
 
-# 生效条件：以 apply=self.auto_tidy 调 writelimit.tidy_contextual(self.cg, actor="sustain_tidy")，把 t/scanned/groups/members/applied_count/auto_tidy 记入 self.last_tidy 与 tidys（仅保留最近 20 条），随后调 _tick_conformance()；auto_tidy=False（默认）时只盘点不落盘；
+# 生效条件：以 apply=self.auto_tidy 调 writelimit.tidy_contextual(self.cg, actor="sustain_tidy")，把 t/scanned/groups/members/applied_count/auto_tidy 记入 self.last_tidy 与 tidys（仅保留最近 20 条），随后调 _tick_conformance()；auto_tidy 为假时只盘点不落盘；
     def _tick_tidy(self):
         """整理巡检（contextual 流水治理·读侧）：同构组聚合 + 成员降权。
 
-        确定性动作、永不删节点；`auto_tidy=False`（默认）只盘点不落盘。
+        确定性动作、永不删节点；`auto_tidy` 为假时只盘点不落盘。缺省值取自
+        模块级真源 `AUTO_DEFAULTS`（P0-2；缺省为 True，opt-out 见该表注释）。
         治理对象：单日批次流水（「批次247收官记忆」×163 那类同模板写入）
         —— 写入侧限流（writelimit.check）拦增量，本巡检收敛存量。
         """
@@ -1109,6 +1204,41 @@ class SustainLoop:
             self.last_conformance = {"ok": False, "verdict": "BLINDSPOT",
                                      "error": f"{type(e).__name__}: {e}"}
 
+# 生效条件：self.sleep_round 自增 1 后以 enabled=self.auto_sleep / merge_mode=self.sleep_merge / scrub_apply=self.sleep_scrub_apply / window=self.sleep_window / round_index=self.sleep_round 调 sleep.run_cycle(self.cg)，把 t/batch/round/candidates/merged/skipped/conflicts/九步名与其 skipped 明细/auto_sleep/merge_mode 记入 last_sleep 与 sleeps（保留最近 20 条）；auto_sleep 为假时 run_cycle 只记账不迭代；
+    def _tick_sleep(self):
+        """睡眠周期（第六档 tick）：§3.1 九步显式化 + §4.4 副本迭代与周期合并。
+
+        **只在副本上迭代**（物化 → 影子迭代 → 对账四闸 → 语义重放 + git 合并），
+        主库真源面在非合并阶段逐字节不变。四个开关全取 `md_cg/sleep.py` 的 §4.7
+        env 表真源：`MDCG_SLEEP`（总开关，缺省开）、`MDCG_SLEEP_MERGE`（缺省
+        auto＝自动走四阶段，冲突仍挂起）、`MDCG_SLEEP_WINDOW`（缺省 23:00-07:00，
+        **窗口外只记账不迭代**）、`MDCG_SLEEP_SCRUB_APPLY`（缺省 **关**——第④步
+        缺省只在副本上盘点、不落盘）。
+
+        ⑤权重刷新与衰减 / ⑥索引重建两步本轮是**显式 no-op 占位**（台账里标
+        `skipped: "未接线"`），故本轮**不动检索读数**。
+        """
+        from . import sleep as _sleep
+        self.sleep_round += 1
+        r = _sleep.run_cycle(self.cg, enabled=self.auto_sleep,
+                             merge_mode=self.sleep_merge,
+                             scrub_apply=self.sleep_scrub_apply,
+                             window=self.sleep_window,
+                             round_index=self.sleep_round)
+        steps = list(r.get("steps") or [])
+        rec = {"t": r.get("t"), "batch": r.get("batch"), "round": r.get("round"),
+               "candidates": r.get("candidates"),
+               "merged": r.get("merged"), "skipped": r.get("skipped"),
+               "conflicts": r.get("conflicts"),
+               "steps": [s.get("step") for s in steps],
+               "steps_skipped": ["%s:%s" % (s.get("step"), s.get("skipped"))
+                                 for s in steps if s.get("skipped")],
+               "auto_sleep": self.auto_sleep, "merge_mode": self.sleep_merge}
+        self.last_sleep = rec
+        with self._lock:
+            self.sleeps.append(rec)
+            self.sleeps = self.sleeps[-20:]
+
 # 生效条件：恒以 evolution_candidates(self.cg) 只读盘点并记入 last_evolve 与 evolves（保留最近 20 条）；仅当 self.auto_evolve 为真且 ev["importance_drift"]["n"] 为真时才额外执行 weights.recalc(self.cg, apply=True, actor="sustain_evolve")，其异常写入 rec["applied"]；
     def _tick_evolve(self):
         """演化巡检（G7）：盘点固化/重要性候选 —— 让「有能力」变成「有驱动」。
@@ -1206,6 +1336,13 @@ class SustainLoop:
                 "evolves": self.evolves[-5:],
                 "last_tidy": self.last_tidy,
                 "tidys": self.tidys[-5:],
+                "sleep_interval": self.sleep_interval,
+                "auto_sleep": self.auto_sleep,
+                "sleep_merge": self.sleep_merge,
+                "sleep_window": self.sleep_window,
+                "sleep_scrub_apply": self.sleep_scrub_apply,
+                "last_sleep": self.last_sleep,
+                "sleeps": self.sleeps[-5:],
                 "last_conformance": self.last_conformance,
                 "peers": peers(self.d),
                 "sessions": self.ledger.summary()}

package/md_cg/test_auto_defaults.py

@@ -0,0 +1,424 @@
+# -*- coding: utf-8 -*-
+"""`auto_*` 四档缺省「单一真源」守卫（P0-2，2026-10-01）。
+
+契约（设计稿 `docs/plans/睡眠与自迭代_功能优化设计_v0.4.md` §八 P0-2 / §4.7）：
+
+    同一 `(root, name)` 的两条入口必须得到**同一组** `auto_*` 取值；
+    缺省只许有**一份定义**（`sustain.AUTO_DEFAULTS` + 三个读取器），
+    两个调用点不得再写第二处字面量。
+
+改动前实测（探针读数，逐条引 `path:line`）：
+
+    op 路径（工具面 `sustain action=start`）   `auto_tidy=bool(a.get("auto_tidy", False))`
+                                              → **False**（mcp_server.py:1639）
+    env 路径（常驻 serve 自启 `_start_sustain`）`auto_tidy=os.environ.get("MDCG_AUTO_TIDY","1") not in (...)`
+                                              → **True**（mcp_server.py:3595-3596）
+    另三项 auto_heal/auto_scrub/auto_evolve 两入口一致（True / False / False）；
+    `SustainLoop.__init__` 形参另有一份 `auto_tidy=False`（sustain.py:966）——
+    即「单一真源尚未成立，全仓 auto_tidy 缺省字面量至少两处」。
+
+**本轮对外可见的缺省变更（裁决值 = 开）**：`auto_tidy` 缺省由 False 收敛为
+**True**（取 env 路径既有值）；opt-out = `MDCG_AUTO_TIDY=0`（env 路径）／
+显式 `auto_tidy=false`（op 路径）。另三项**逐项未变**（G4 钉死，防「顺手改多了」）。
+
+断言分组：
+
+  G0 隔离与基线自证——库根/状态根/辅助根/心跳目录全落守卫临时目录（绝不碰在役
+     库与 `~/.mdcg`）；断言真源表与三个读取器在位。
+  G1 真源表与读取器——四项值、键集、env 键映射、关断字面量固定；`auto_default`
+     逐项一致；`auto_from_env` 的缺省字面量**由表推出**（真值→"1"、假值→"0"，
+     与改动前两处字面量同义）。
+  G2 三面同源读数（端到端，真起循环）——env 路径（`_start_sustain`）、op 路径
+     （`_sustain_call` 的 start 分支）、构造面（`SustainLoop(cg)`）三面在同一档上
+     取值相同且**都等于真源表**；并验两侧 opt-out / 显式入参仍优先。
+  G3 单一真源（静态）——带引号字面量 `"MDCG_AUTO_TIDY"` 在生产源码里恰 1 处
+     （在 `AUTO_ENVS`）；`mcp_server.py` 内 `a.get("auto_*"` /
+     `os.environ.get("MDCG_AUTO_*"` / `os.environ.get("MDCG_SUSTAIN_AUTOHEAL"` 零命中；
+     两入口各恰好一处读取器调用。（`md_cg/test_*.py` 不在判据面内：本守卫自己的
+     变异表就含这些字面量，属红基线工具面。）
+  G4 对外可见变更的披露面——`auto_tidy` 缺省为 True 且 op 路径无参即得 True；
+     另三项缺省与本轮前逐项相同；opt-out 名取自 `AUTO_ENVS` 而非硬编码。
+
+运行：python -X utf8 -m md_cg.test_auto_defaults
+      python -X utf8 -m md_cg.test_auto_defaults --mutate         # 定点变异自证
+      python -X utf8 -m md_cg.test_auto_defaults --mutate --list  # 只列变异表
+
+退出码（fail-closed）：0 = 全绿；1 = 有断言失败 / 变异未按预期转红；
+2 = ANCHOR-MISS（变异锚点在当前源码里找不到——实现改了却没同步本表，
+锚点漂移必须硬失败，不得静默跳过）。
+
+**基线纪律**：本守卫**不以 git HEAD 为基线源**——「改动前形态」由在当前工作区
+源码上做**定点文本变异**（`_MUTATIONS`）复现，锚点漂移即退出码 2。
+"""
+from __future__ import annotations
+
+import contextlib
+import io
+import os
+import shutil
+import sys
+import tempfile
+import types
+
+from . import mcp_server as MCP
+from . import sustain
+
+_PASS = []
+_FAIL = []
+_SKIP = []
+#: 变异模式下供静态组读取的**源码文本**（rel → text）；未变异时读盘。
+_SRC = {}
+
+_REAL_SUSTAIN = sustain
+_REAL_MCP = MCP
+
+
+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 skip(msg):
+    _SKIP.append(msg)
+    print("  SKIP " + msg)
+
+
+def _repo_root() -> str:
+    return os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+
+def _rel_text(rel: str) -> str:
+    """源码文本：变异模式下取变异后的文本，否则读盘。"""
+    if rel in _SRC:
+        return _SRC[rel]
+    with open(os.path.join(_repo_root(), rel), encoding="utf-8") as f:
+        return f.read()
+
+
+def _md_cg_py_texts():
+    d = os.path.join(_repo_root(), "md_cg")
+    return {"md_cg/" + fn: _rel_text("md_cg/" + fn)
+            for fn in sorted(os.listdir(d)) if fn.endswith(".py")}
+
+
+# ---------------------------------------------------------------- 沙箱
+_TMP = tempfile.mkdtemp(prefix="mdcg_autodef_")
+_SAVED = {}
+_GEN = [0]
+
+
+def _sandbox_env():
+    """把四条根全钉进守卫临时目录；原值留待还原（绝不碰在役库 / ~/.mdcg）。"""
+    for k in ("MDCG_ROOT", "MDCG_AUX_ROOT", "MDCG_STATE_ROOT", "MDCG_SUSTAIN_DIR",
+              "MDCG_SUBSTAIN", "MDCG_SUSTAIN", "MDCG_SUSTAIN_NAME",
+              "MDCG_AUTO_TIDY", "MDCG_AUTO_SCRUB", "MDCG_AUTO_EVOLVE",
+              "MDCG_SUSTAIN_AUTOHEAL"):
+        _SAVED[k] = os.environ.get(k)
+    os.environ["MDCG_ROOT"] = os.path.join(_TMP, "cg")
+    os.environ["MDCG_AUX_ROOT"] = os.path.join(_TMP, "aux")
+    os.environ["MDCG_STATE_ROOT"] = os.path.join(_TMP, "state")
+    os.environ["MDCG_SUSTAIN_DIR"] = os.path.join(_TMP, "sustain")
+    os.environ["MDCG_SUBSTAIN"] = "0"
+    os.environ.pop("MDCG_SUSTAIN", None)
+    for k in ("MDCG_AUTO_TIDY", "MDCG_AUTO_SCRUB", "MDCG_AUTO_EVOLVE",
+              "MDCG_SUSTAIN_AUTOHEAL"):
+        os.environ.pop(k, None)
+
+
+def _restore_env():
+    for k, v in _SAVED.items():
+        if v is None:
+            os.environ.pop(k, None)
+        else:
+            os.environ[k] = v
+
+
+def _cg(name="cg"):
+    """每轮 `_run_groups` 用**全新根**：`sustain.ensure_loop` 按 (root,name) 复用
+    实例，同一根跨轮复用会让变异轮读到上一轮的循环（假绿）。"""
+    from .mdcos import MdCGOS
+    root = os.path.join(_TMP, "gen%d" % _GEN[0], name)
+    os.makedirs(root, exist_ok=True)
+    return MdCGOS(root)
+
+
+# ---------------------------------------------------------------- G0
+def g0():
+    print("== G0 隔离与基线自证 ==")
+    ok(hasattr(_REAL_SUSTAIN, "AUTO_DEFAULTS"),
+       "G0a sustain.AUTO_DEFAULTS 存在（缺省真源表）")
+    ok(all(hasattr(_REAL_SUSTAIN, n)
+           for n in ("auto_default", "auto_from_env", "auto_from_args")),
+       "G0b 三个读取器（auto_default / auto_from_env / auto_from_args）均在位")
+    ok(os.environ["MDCG_ROOT"].startswith(_TMP)
+       and os.environ["MDCG_AUX_ROOT"].startswith(_TMP),
+       "G0c 沙箱：库根与辅助根都在守卫临时目录内", os.environ["MDCG_ROOT"])
+
+
+# ---------------------------------------------------------------- G1
+_EXPECT = {"auto_heal": True, "auto_scrub": False,
+           "auto_evolve": False, "auto_tidy": True}
+
+
+def g1():
+    print("== G1 真源表与读取器 ==")
+    S = globals()["sustain"]
+    ok(dict(S.AUTO_DEFAULTS) == _EXPECT,
+       "G1 真源表四项与裁决值一致（含 auto_tidy=True——本轮唯一的对外可见变更）",
+       S.AUTO_DEFAULTS)
+    ok(set(S.AUTO_ENVS) == set(S.AUTO_DEFAULTS),
+       "G1a env 键映射与真源表同键集", sorted(S.AUTO_ENVS))
+    ok(S.AUTO_ENVS["auto_tidy"] == "MDCG_AUTO_TIDY",
+       "G1b auto_tidy 的 env 键名 = MDCG_AUTO_TIDY（opt-out 名）")
+    ok(tuple(S.AUTO_OFF_VALUES) == ("0", "false", "False"),
+       "G1c 关断字面量与改动前两入口逐字一致（0 / false / False）",
+       S.AUTO_OFF_VALUES)
+    for k, v in _EXPECT.items():
+        ok(S.auto_default(k) is v,
+           "G1d auto_default(%s) 与表一致 = %r" % (k, v))
+    for k, v in _EXPECT.items():
+        ok(S.auto_from_env(k, {}) is v,
+           "G1e auto_from_env(%s) 空环境下回落真源缺省 %r（默认字面量由表推出）"
+           % (k, v))
+    for k in _EXPECT:
+        for off in ("0", "false", "False", "FALSE ", ""):
+            got = S.auto_from_env(k, {S.AUTO_ENVS[k]: off})
+            want = off not in S.AUTO_OFF_VALUES
+            ok(got is want,
+               "G1f auto_from_env(%s) 取 %r → %r（关断口径不变）" % (k, off, want),
+               got)
+    ok(S.auto_from_env("auto_tidy", {"MDCG_AUTO_TIDY": "1"}) is True,
+       "G1g 显式 1 仍为开（开态仍可达）")
+
+
+# ---------------------------------------------------------------- G2
+def g2():
+    print("== G2 三面同源读数（端到端，真起循环）==")
+    S = globals()["sustain"]
+    M = globals()["MCP"]
+    cg = _cg("cg_g2")
+    os.environ.pop("MDCG_AUTO_TIDY", None)
+    os.environ["MDCG_SUSTAIN_NAME"] = "env_edge"
+    lp = M._start_sustain(cg)
+    ok(lp is not None, "G2 env 路径确已起循环（前置）")
+    ok(lp.auto_tidy is True,
+       "G2a env 路径（_start_sustain）无 env 覆盖时 auto_tidy=True（生产路径既有值）",
+       lp.auto_tidy)
+    os.environ["MDCG_AUTO_TIDY"] = "0"
+    os.environ["MDCG_SUSTAIN_NAME"] = "env_off"
+    lp2 = M._start_sustain(cg)
+    ok(lp2 is not None and lp2.auto_tidy is False,
+       "G2b env 路径 opt-out：MDCG_AUTO_TIDY=0 → auto_tidy=False",
+       (lp2.auto_tidy if lp2 else None))
+    os.environ.pop("MDCG_AUTO_TIDY", None)
+    ti = {"beat_interval": 3600, "heal_interval": 3600, "scrub_interval": 3600,
+          "evolve_interval": 3600, "tidy_interval": 3600}
+    r = M._sustain_call(cg, dict({"action": "start", "name": "op_default"}, **ti))
+    opl = S.get_loop(cg, "op_default")
+    ok("loop" in r and opl is not None, "G2c op 路径确已起循环（前置）", r)
+    ok(opl is not None and opl.auto_tidy is True,
+       "G2d op 路径（sustain action=start）不传参时 auto_tidy=True——**本轮的缺省变更**",
+       (opl.auto_tidy if opl else None))
+    M._sustain_call(cg, dict({"action": "start", "name": "op_off",
+                              "auto_tidy": False}, **ti))
+    opl2 = S.get_loop(cg, "op_off")
+    ok(opl2 is not None and opl2.auto_tidy is False,
+       "G2e op 路径显式 auto_tidy=false → False（显式入参优先于真源表）",
+       (opl2.auto_tidy if opl2 else None))
+    M._sustain_call(cg, dict({"action": "start", "name": "op_face"}, **ti))
+    env_face = S.get_loop(cg, "env_edge")
+    op_face = S.get_loop(cg, "op_face")
+    ctor_face = S.SustainLoop(cg, name="ctor_face",
+                              d=os.environ["MDCG_SUSTAIN_DIR"])
+    ok(env_face is not None and op_face is not None,
+       "G2f 前置：env / op 两面循环都在册")
+    for k in _EXPECT:
+        trio = (getattr(env_face, k), getattr(op_face, k), getattr(ctor_face, k))
+        ok(trio[0] == trio[1] == trio[2] == _EXPECT[k],
+           "G2g 三面同值 %s：env/op/构造 = %r，真源 = %r" % (k, trio, _EXPECT[k]))
+    S.stop_all()
+
+
+# ---------------------------------------------------------------- G3
+def g3():
+    print("== G3 单一真源（静态）==")
+    texts = _md_cg_py_texts()
+    prod = {rel: t for rel, t in texts.items()
+            if not os.path.basename(rel).startswith("test_")}
+    quoted = sorted((rel, t.count('"MDCG_AUTO_TIDY"')) for rel, t in prod.items()
+                    if t.count('"MDCG_AUTO_TIDY"'))
+    ok(quoted == [("md_cg/sustain.py", 1)],
+       "G3 带引号字面量 \"MDCG_AUTO_TIDY\" 在生产源码里恰 1 处（在 AUTO_ENVS）",
+       quoted)
+    pats = ('os.environ.get("MDCG_AUTO_TIDY"', 'a.get("auto_tidy"',
+            'a.get("auto_heal"', 'a.get("auto_scrub"', 'a.get("auto_evolve"',
+            'os.environ.get("MDCG_AUTO_SCRUB"',
+            'os.environ.get("MDCG_AUTO_EVOLVE"',
+            'os.environ.get("MDCG_SUSTAIN_AUTOHEAL"')
+    bad = [(rel, p, t.count(p)) for rel, t in prod.items()
+           for p in pats if t.count(p)]
+    ok(not bad, "G3a 生产源码里零命中「缺省字面量」形态（^ 见 detail）", bad)
+    s = _rel_text("md_cg/sustain.py")
+    ok("AUTO_DEFAULTS = {" in s, "G3b 真源表在 sustain.py 定义")
+    ok(s.count("auto_tidy: bool = AUTO_DEFAULTS[") == 1,
+       "G3c SustainLoop 形参默认值引用真源表（不写第二处字面量）")
+    m = _rel_text("md_cg/mcp_server.py")
+    ok(m.count('auto_tidy=sustain.auto_from_args("auto_tidy", a)') == 1,
+       "G3d op 路径恰一处经 auto_from_args 读 auto_tidy")
+    ok(m.count('auto_tidy=sustain.auto_from_env("auto_tidy")') == 1,
+       "G3e env 路径恰一处经 auto_from_env 读 auto_tidy")
+    ok('"auto_tidy", False' not in m and 'auto_tidy=False)' not in m,
+       "G3f mcp_server.py 内不再有 auto_tidy 的 False 缺省字面量")
+
+
+# ---------------------------------------------------------------- G4
+def g4():
+    print("== G4 变更披露面（防顺手改多了）==")
+    S = globals()["sustain"]
+    ok(S.AUTO_DEFAULTS["auto_tidy"] is True,
+       "G4 裁决值 = 开：auto_tidy 真源缺省为 True")
+    ok(S.AUTO_DEFAULTS["auto_heal"] is True
+       and S.AUTO_DEFAULTS["auto_scrub"] is False
+       and S.AUTO_DEFAULTS["auto_evolve"] is False,
+       "G4a 另三项缺省与本轮前逐项相同（heal=True / scrub=False / evolve=False）",
+       S.AUTO_DEFAULTS)
+    ok(S.AUTO_ENVS["auto_tidy"] == "MDCG_AUTO_TIDY",
+       "G4b opt-out env 名（自真源读）= MDCG_AUTO_TIDY")
+    ok(S.auto_from_args("auto_tidy", {"auto_tidy": None}) is False,
+       "G4c 显式传 None（键在）→ False，与改动前 bool(a.get(name, default)) 同义")
+    ok(S.auto_from_args("auto_tidy", {"other": 1}) is True,
+       "G4d 缺键才回落真源缺省（True）")
+
+
+_GROUPS = (g0, g1, g2, g3, g4)
+
+
+# ---------------------------------------------------------------- 变异表
+# 锚点 = (名字, 模式, rel, old, new, 预期红项数下限)。
+#   "mod" = 改**可执行实现**（exec 成模块并换进 `sys.modules`，供 `from . import` 面读到）
+#   "src" = 只改**源码文本**（静态组 G3 读 `_SRC`，不 exec）
+# 「改动前形态」的复现即在这里：
+#   M1 把真源表里的 auto_tidy 改回 False（= 旧的 op 路径字面量）
+#   M2 让 op 路径读取器不回落真源（= 旧的「另一处字面量」）
+#   M3 把 env 路径改回旧的手写 env 读取（= 旧 env 路径形态 + 第二处字面量）
+_MUTATIONS = (
+    ("真源表 auto_tidy 改回 False（旧 op 路径值）", "mod", "md_cg/sustain.py",
+     '"auto_evolve": False, "auto_tidy": True}',
+     '"auto_evolve": False, "auto_tidy": False}', 1),
+    ("op 路径读取器不回落真源（旧「另一处字面量」）", "mod", "md_cg/sustain.py",
+     "        return bool(args[name])\n    return auto_default(name)",
+     "        return bool(args[name])\n    return False", 1),
+    ("env 路径改回手写 env 读取（第二处 MDCG_AUTO_TIDY 字面量）", "src",
+     "md_cg/mcp_server.py",
+     'auto_tidy=sustain.auto_from_env("auto_tidy"))',
+     'auto_tidy=os.environ.get("MDCG_AUTO_TIDY", "1") not in ("0", "false", "False"))',
+     1),
+)
+
+
+def _run_groups() -> int:
+    _GEN[0] += 1
+    _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()[-800:])
+    for mod in (globals().get("sustain"), _REAL_SUSTAIN):
+        try:
+            mod.stop_all()
+        except Exception:                              # noqa: BLE001
+            pass
+    return len(_FAIL)
+
+
+def _exec_module(name: str, rel: str, text: str):
+    ns = {"__name__": name, "__package__": "md_cg",
+          "__file__": os.path.join(_repo_root(), 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, kind, rel, _o, _n, exp in _MUTATIONS:
+            print("  %-46s [%s] expect_red>=%d  (%s)" % (name, kind, exp, 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, kind, rel, old, new, expect 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
+        live = None
+        try:
+            if kind == "mod":
+                live = sys.modules["md_cg.sustain"]
+                mut = _exec_module("md_cg._autodef_mut", rel, mut_src)
+                sys.modules["md_cg.sustain"] = mut
+                globals()["sustain"] = mut
+            with contextlib.redirect_stdout(buf := io.StringIO()):
+                reds = _run_groups()
+            detail = buf.getvalue()
+        finally:
+            if live is not None:
+                sys.modules["md_cg.sustain"] = live
+                globals()["sustain"] = _REAL_SUSTAIN
+            _SRC.pop(rel, None)
+        red_lines = [l for l in detail.splitlines()
+                     if l.strip().startswith("FAIL ")]
+        verdict = "红" if reds else "**仍全绿 = 该判据空转**"
+        mark = "OK  " if reds >= expect else "MISMATCH"
+        print("  %s %-46s 红项=%d 预期>=%d  %s"
+              % (mark, name, reds, expect, verdict))
+        for l in red_lines[:6]:
+            print("        " + l.strip()[5:])
+        if reds < expect:
+            bad.append("%s（红=%d 预期>=%d）" % (name, reds, 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:
+    _sandbox_env()
+    try:
+        if "--mutate" in sys.argv:
+            return _mutate_mode("--list" in sys.argv)
+        n = _run_groups()
+        print("\nauto_* 缺省单一真源守卫：%d 通过，%d 失败，%d 跳过"
+              % (len(_PASS), n, len(_SKIP)))
+        return 0 if not n else 1
+    finally:
+        try:
+            _REAL_SUSTAIN.stop_all()
+        except Exception:                              # noqa: BLE001
+            pass
+        _restore_env()
+        shutil.rmtree(_TMP, ignore_errors=True)
+
+
+if __name__ == "__main__":
+    sys.exit(main())