@furongjun1999/dsh-memory 0.6.1 → 0.7.1

package/md_cg/stgidx.py

@@ -0,0 +1,281 @@
+# -*- coding: utf-8 -*-
+"""stg 第 3 层：结构索引（装载期内存倒排 + 写路径增量维护）。
+
+设计稿：`docs/plans/stg条件化与结构索引_设计_v0.1.md`（2026-10-03 使用者签收）。
+本模块只放**结构与取数**：三张表的构建 / 增删 / 取子集 / 一致性自检。
+
+「何时构建、何时回退、回退怎么上报」的编排在读侧（`stg.py`）；
+「何时调增删钩」的编排在写侧（`mdcg._set_index_entry` / `mdcg._remove_index_entry`）。
+两处都只经本模块的单点，不另写第二份分类口径。
+
+三张表（**不变量：恒为快照 keys 的划分**，见 `verify`）：
+
+    · `by_session: {sid | None | _UNHASHABLE: [id, ...]}`——`None` = 无会话归属
+      （`unassigned` 兜底桶，语义与基线 ``fm.get("session") != sid`` 的等值比较一致）；
+    · `by_layer:   {layer | _UNHASHABLE: [id, ...]}`；
+    · `by_time:    [(t, id), ...]` 升序——`t` 取**观察轴区间起点**，经既有单点
+      `trust.time_window_of`（= `stg._interval` 同一实现，不引入第二套时间解析）；
+      无有效时间戳 → `untimed`；非有限值（NaN/±inf）→ `nonfinite`（见下）。
+    另加 `pos: {id: 物理位序}`——子集按**索引物理序**回排：基线 `_scan` 的候选序
+    就是快照物理序，等价性判据（flag 开/关逐位一致）要求取数面能复现它。
+
+**为什么 nonfinite 单列**（不并入 untimed）：基线里 NaN 时间戳节点并非「无时间」——
+`_interval` 对 `(nan, nan)` 判非 None，`time_relation` 落到最后一档 `overlaps`，于是
+NaN 节点**会**命中时间窗查询；`±inf` 则分别落 `after`/`before`（永不命中）。故 NaN 必须
+进时间窗查询的候选面（`subset` 对 time 维一并带上 nonfinite——保守超集，逐条精确判定
+仍在 `_scan` 侧），untimed 才与基线「跳过」语义对齐。
+
+不适用条件：非 stg 读侧（`cg(op=read)` 的候选收敛走 `apply_retrieval_gates`，与
+本索引不同维、不共用）；跨进程共享（本索引是**进程内**派生结构，各进程自建）。
+"""
+from __future__ import annotations
+
+import bisect
+import math
+
+from . import trust
+
+#: 不可哈希的 session/layer 值（脏盘面才可能出现的形态）统一归此哨兵键。
+#: 任何**具体会话/层**查询都查不到它——与基线 `!=` 等值比较同语义（脏值恒不等）。
+_UNHASHABLE = object()
+
+#: 维缺省哨兵（`None` 是**合法取值**：session=None 即 unassigned 桶，不可与「未给该维」混同）。
+MISSING = object()
+
+
+# 生效条件：value 可 hash 时原样返回，hash 抛 TypeError（list/dict 等）时返回模块级哨兵 _UNHASHABLE。
+def _hashable(value):
+    try:
+        hash(value)
+    except TypeError:
+        return _UNHASHABLE
+    return value
+
+
+# 生效条件：entry 为 dict 时以 trust.time_window_of(entry, "observed") 取观察轴两端点，两端均可判定则返回 float(起点)，任一端不可判定（None）或 entry 非 dict 时返回 None；不做第二套解析、不猜测。
+def time_of(entry):
+    """条目 → 观察轴区间**起点**（epoch 秒）；不可判定 → None。
+
+    与 `stg._interval` **同一单点**：`_scan` 把快照条目拼成 fm 后取到的区间，
+    与直接对条目取逐位一致——`_scan` 把 `time_window` 平铺进 `condition_space`
+    而 `time_window_of` 两种载体都读（见其「兼容两种载体形态」注释），
+    `temporal` 优先级与毫秒归一也同一份 `trust.parse_time`。
+    """
+    if not isinstance(entry, dict):
+        return None
+    s, e = trust.time_window_of(entry, "observed")
+    if s is None or e is None:
+        return None
+    return float(s)
+
+
+# 生效条件：index_obj 为含 dict 型 "nodes" 的快照（或顶层就是 dict）时返回按其**物理序**一次性构建的 StgIndex（O(N)，逐条经 add 分类）；"nodes" 缺失或非 dict 时返回 None（调用方据此回退并上报 reason，不静默）。
+def build(index_obj):
+    """快照 → 三张表（O(N)）；快照形态不可用返回 None。"""
+    nodes = index_obj.get("nodes") if isinstance(index_obj, dict) else None
+    if not isinstance(nodes, dict):
+        return None
+    ix = StgIndex(index_obj)
+    for nid in nodes:                      # 快照物理序（dict 插入序）→ pos 即此序
+        ix.add(nid, nodes[nid])
+    return ix
+
+
+# 生效条件：ix 为 StgIndex、nodes 为快照 nodes 映射时，逐项核对「三表恒为快照 keys 的划分」——pos 与快照键集双向相等、pos 序 == 快照物理序、by_session/by_layer 各桶两两不交且并集 == 键集、by_time ∪ nonfinite ∪ untimed 同上、by_time 升序且分类与条目实际 session/layer/时间逐条一致；返回不一致说明列表（空 = 不变量成立）。O(N)，守卫/审计用，不在取数热路径。
+def verify(ix, nodes):
+    """划分不变量自检：返回不一致说明列表（空 = 完好）。"""
+    bad = []
+    if ix.broken:
+        bad.append("broken：增量维护期已记不一致标记（写钩异常）")
+    ids = set(nodes)
+    if set(ix.pos) != ids:
+        bad.append("pos 键集与快照不等：多 %d / 缺 %d"
+                   % (len(set(ix.pos) - ids), len(ids - set(ix.pos))))
+    if sorted(ix.pos, key=ix.pos.get) != list(nodes):
+        bad.append("pos 序与快照物理序不一致（取数面无法复现基线候选序）")
+    if len(ix.pos) != len(nodes):
+        bad.append("len(pos)=%d ≠ len(nodes)=%d" % (len(ix.pos), len(nodes)))
+    for name, table in (("by_session", ix.by_session), ("by_layer", ix.by_layer)):
+        seen = []
+        for bucket, lst in table.items():
+            seen.extend(lst)
+            if len(set(lst)) != len(lst):
+                bad.append("%s[%r] 桶内重复 id" % (name, bucket))
+        if len(seen) != len(set(seen)):
+            bad.append("%s 有 id 落在多个桶（非划分）" % name)
+        if set(seen) != ids:
+            bad.append("%s 并集与快照键集不等（多 %d / 缺 %d）"
+                       % (name, len(set(seen) - ids), len(ids - set(seen))))
+    timed = [nid for _t, nid in ix.by_time]
+    sess_sets = {k: set(v) for k, v in ix.by_session.items()}
+    layer_sets = {k: set(v) for k, v in ix.by_layer.items()}
+    union = set(timed) | set(ix.nonfinite) | set(ix.untimed)
+    if len(timed) != len(set(timed)) or len(set(ix.nonfinite)) != len(ix.nonfinite) \
+            or len(set(ix.untimed)) != len(ix.untimed):
+        bad.append("by_time/nonfinite/untimed 有重复 id")
+    if union != ids:
+        bad.append("by_time ∪ nonfinite ∪ untimed 与快照键集不等（多 %d / 缺 %d）"
+                   % (len(union - ids), len(ids - union)))
+    if [t for t, _ in ix.by_time] != sorted(t for t, _ in ix.by_time):
+        bad.append("by_time 非升序")
+    for nid in ids:
+        e = nodes.get(nid)
+        sid, layer, bucket, _t0 = ix.cls.get(nid, (None, None, None, None))
+        if sid != _hashable((e or {}).get("session")):
+            bad.append("%s 的 by_session 分类与条目不符" % nid)
+        if layer != _hashable((e or {}).get("layer")):
+            bad.append("%s 的 by_layer 分类与条目不符" % nid)
+        t = time_of(e)
+        want = 0 if (t is not None and math.isfinite(t)) else (
+            1 if t is not None else 2)
+        if bucket != want:
+            bad.append("%s 的 by_time 分类与条目不符（t=%r）" % (nid, t))
+        # 「划分」不只要求并集相等，还要求 id 落在**其分类键对应的桶**里——
+        # 否则分桶键取错字段（如 by_layer 按 session 建）时并集仍相等、静默漏判。
+        if nid not in sess_sets.get(sid, ()):
+            bad.append("%s 不在其分类对应的 by_session 桶里" % nid)
+        if nid not in layer_sets.get(layer, ()):
+            bad.append("%s 不在其分类对应的 by_layer 桶里" % nid)
+        if bucket == 0 and nid not in timed:
+            bad.append("%s 应在 by_time 而不在" % nid)
+        if bucket == 1 and nid not in ix.nonfinite:
+            bad.append("%s 应在 nonfinite 而不在" % nid)
+        if bucket == 2 and nid not in ix.untimed:
+            bad.append("%s 应在 untimed 而不在" % nid)
+    return bad
+
+
+class StgIndex:
+    """快照的结构倒排（三张表 + 物理位序 + 每节点分类记录）。
+
+    维护纪律：增删只经 `add` / `remove`（写侧单点），取数只经 `subset`（读侧单点）。
+    `cls[nid] = (sid, layer, bucket, t)` 是**增量摘除**的依据（不必回扫桶猜分类）；
+    任一步异常 ⇒ `broken = True`（读侧据此回退全量并重建，绝不带着半张表取数）。
+    """
+
+    def __init__(self, index_obj):
+        self.index_obj = index_obj      # 强引用：读侧按 `is` 判代际（防 id 复用）
+        self.by_session = {}
+        self.by_layer = {}
+        self.by_time = []
+        self.untimed = []
+        self.nonfinite = []
+        self.pos = {}
+        self.cls = {}
+        self.broken = False
+        self._next_pos = 0
+
+    # 生效条件：nid 已在 pos 中时先摘旧分类（**位序不变**——与 dict 原地覆写保序同语义），否则分配下一个位序；随后按 entry 的 session/layer/时间重新分类一次（同键即幂等）；任一步异常置 broken=True（读侧回退重建）。
+    def add(self, nid, entry):
+        """增量增/改：与 `dict.__setitem__` 同序语义（已有键保位序、新键落尾）。"""
+        try:
+            if nid in self.pos:
+                self._unclassify(nid)       # 位序保留（dict 覆写不移动）
+            else:
+                self.pos[nid] = self._next_pos
+                self._next_pos += 1
+            self._classify(nid, entry)
+        except Exception:                   # noqa: BLE001  一致性存疑即标记，读侧回退
+            self.broken = True
+
+    # 生效条件：nid 不在 pos 中时无操作；在则摘分类并 pop 位序（位序**不回收**——后续新键恒得更大位序，与 dict 删后新增落尾一致）；任一步异常置 broken=True。
+    def remove(self, nid):
+        """增量删（不回收位序：新键恒落尾，与 dict 删除/追加语义同构）。"""
+        try:
+            if nid not in self.pos:
+                return
+            self._unclassify(nid)
+            self.pos.pop(nid, None)
+        except Exception:                   # noqa: BLE001
+            self.broken = True
+
+    def _classify(self, nid, entry):
+        e = entry if isinstance(entry, dict) else {}
+        sid, layer = _hashable(e.get("session")), _hashable(e.get("layer"))
+        t = time_of(e)
+        self.by_session.setdefault(sid, []).append(nid)
+        self.by_layer.setdefault(layer, []).append(nid)
+        if t is None:
+            bucket = 2
+            self.untimed.append(nid)
+        elif math.isfinite(t):
+            bucket = 0
+            bisect.insort(self.by_time, (t, nid))
+        else:
+            bucket = 1                  # NaN/±inf：见模块 docstring「为什么单列」
+            self.nonfinite.append(nid)
+        self.cls[nid] = (sid, layer, bucket, t)
+
+    def _unclassify(self, nid):
+        sid, layer, bucket, t = self.cls.pop(nid)
+        lst = self.by_session[sid]
+        lst.remove(nid)
+        if not lst:                     # 空桶不保留（表规模读数如实）
+            self.by_session.pop(sid, None)
+        lst = self.by_layer[layer]
+        lst.remove(nid)
+        if not lst:
+            self.by_layer.pop(layer, None)
+        if bucket == 0:
+            # 二分定位而非全表连比：(t, nid) 在升序表内唯一，命中即该位；
+            # 不在该位 ⇒ 状态已不可信，抛错由上层置 broken（绝不摘错条目）
+            i = bisect.bisect_left(self.by_time, (t, nid))
+            if i >= len(self.by_time) or self.by_time[i] != (t, nid):
+                raise KeyError(nid)
+            del self.by_time[i]
+        elif bucket == 1:
+            self.nonfinite.remove(nid)
+        else:
+            self.untimed.remove(nid)
+
+    # 生效条件：lo <= hi 时返回 t ∈ [lo, hi] 的 id 列表（**时间序**，调用方按 pos 回排）；lo > hi 返回空列表（区间为空——调用方在 inverted 查询上先回退，见 stg 侧）。
+    def range_ids(self, lo, hi):
+        """`by_time` 区间截取（二分）；返回时间序 id 列表。"""
+        if lo > hi:
+            return []
+        a = bisect.bisect_left(self.by_time, (lo,))
+        b = bisect.bisect_left(self.by_time, (hi,))
+        # 同 t 并列：把 t == hi 的尾巴一并纳入（不假设 id 字符上界，避免脆弱判据）
+        while b < len(self.by_time) and self.by_time[b][0] == hi:
+            b += 1
+        return [nid for _t, nid in self.by_time[a:b]]
+
+    # 生效条件：session/layer 为 MISSING 表示该维不参与（**注意 None 是合法维值**，不表示缺省），time_range 为 None 表示时间维不参与、否则为 (lo, hi)；无任何参与维时返回 (None, ())；否则返回 (候选 id 列表（**索引物理序**）, 实际服务的维名元组)——任一维在表中无键即得空列表（与基线等值比较同语义，非回退）。
+    def subset(self, session=MISSING, layer=MISSING, time_range=None):
+        """按维直取子集；返回 (ids | None, dims)。"""
+        dims, srcs = [], []
+        if session is not MISSING:
+            dims.append("session")
+            srcs.append(self.by_session.get(session, []))
+        if layer is not MISSING:
+            dims.append("layer")
+            srcs.append(self.by_layer.get(layer, []))
+        if time_range is not None:
+            dims.append("time")
+            lo, hi = time_range
+            # nonfinite 是保守超集（NaN 在基线上会命中时间窗，见模块 docstring）
+            srcs.append(self.range_ids(lo, hi) + list(self.nonfinite))
+        if not dims:
+            return None, ()
+        if len(srcs) > 1:
+            # 交集：三张表各自都是**物理序子序列**，除 time 外直接可用；
+            # time 先回排成物理序，再以最短表驱动（结果仍是物理序子序列）。
+            for i, d in enumerate(dims):
+                if d == "time":
+                    srcs[i] = sorted(srcs[i], key=self.pos.__getitem__)
+            k = min(range(len(srcs)), key=lambda i: len(srcs[i]))
+            driver = srcs[k]
+            others = [set(srcs[i]) for i in range(len(srcs)) if i != k]
+            return ([nid for nid in driver if all(nid in o for o in others)],
+                    tuple(dims))
+        ids = srcs[0]
+        if dims[0] == "time":
+            ids = sorted(ids, key=self.pos.__getitem__)
+        return list(ids), tuple(dims)
+
+    # 生效条件：恒返回表规模读数 dict——nodes=pos 条数、sessions/layers=两张表的**非空桶**数、timed=by_time 条数、untimed/nonfinite=两表条数；只读、无副作用。
+    def size(self):
+        """表规模读数（meta 用）。"""
+        return {"nodes": len(self.pos), "sessions": len(self.by_session),
+                "layers": len(self.by_layer), "timed": len(self.by_time),
+                "untimed": len(self.untimed), "nonfinite": len(self.nonfinite)}

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()}