@furongjun1999/dsh-memory 0.5.1 → 0.6.0

package/md_cg/mcp_server.py

@@ -2686,10 +2686,10 @@ def _export_call(cg, a):
 
 # 生效条件：act=(a.get("action") or "stat").strip().lower()，apply=bool(a.get("apply"))，mode=str(a.get("mode") or "").strip().lower()；principal 非 None 时对 act=="rollback"、act in ("importance","separate") 且 apply、act=="longterm" 且 apply、act=="prefeed" 且 a.get("write") 真且无写权、act in ("backfill","cap","exempt") 且 apply、act in ("backfill_rollback","cap_rollback","exempt_rollback")、act=="vision_evidence" 且 apply、act=="vision_evidence_rollback"、act=="refine" 且 apply 分别 require_admin；随后 act=="longterm" 且 mode in ("list","ls","show","read") 时仅以 action/mode/limit/snapshot_id 调 cg.maintain，否则以全部参数调 cg.maintain。
 def _maintain_call(cg, a):
-    """记忆维护（P1）：importance / longterm / prefeed / separate / rollback / stat / propagate。
+    """记忆维护（P1）：importance / longterm / prefeed / separate / rollback / stat / propagate / reload。
 
     权限**按 action 分档**（比整 op 收窄更贴合语义）：
-      · 只读（stat / history / longterm mode=list|show）→ 不额外拦截；
+      · 只读（stat / history / longterm mode=list|show / reload 读面代际刷新）→ 不额外拦截；
       · 写入侧闸门（prefeed write=True）→ 需 can_write；
       · 批量改写（importance / separate / longterm 的 apply，以及 rollback 本身
         即反向写入、无 dry-run 语义）→ require_admin。

package/md_cg/mdcg.py

@@ -906,10 +906,19 @@ class _DirtyDict(dict):
 # 同源）。中文/逗号无路径语义，P0-1 防线（..禁令+realpath 纵深闸）不变。
 _NODE_ID_RE = re.compile(r"^[A-Za-z0-9_.@\u4e00-\u9fff,-]{1,128}$")
 
+# P3（2026-09-26，DSH 在役库实测 None.md 缺陷）：空语义值的**字符串化污染形态**
+# 整串禁写——批次 24 前 add 无校验，`f"{node_id}.md"` 直拼，`add(None)` 直落
+# `None.md`（旧版直接源头）；批次 24 白名单堵住 None 本体后，字符串 "None"
+# （Python `str(None)`）/"null"（TS `String(null)`）形状合法仍放行（临时库实弹
+# 复现：add("None") → knowledge/orphan/None.md，经 _scan_nodes 收录进检索与
+# route 候选参与打分）。只拒**整串精确等值**（大小写敏感），不扩子串——
+# "NoneBot_1"/"nullify_test" 等合法 id 不受影响。
+_NODE_ID_FORBIDDEN = frozenset({"None", "null"})
+
 
 # 生效条件：构造须传入 root，经 os.path.abspath 后以 exist_ok=True 创建该目录及 LAYERS 各层子目录；autoflush 无论取值（默认 64）都原样赋给实例。
 class MdCG:
-# 生效条件：root 传参即被 os.path.abspath 绝对化并 makedirs(exist_ok=True) 建立 root 与模块级 LAYERS 各层目录，autoflush（默认 64，含 0 等假值）原样存入 self.autoflush，随后 _load_index() 载入索引、sweep_stale_temps(self.root) 清扫，并把 self 登记进模块级 _LIVE_CGS；
+# 生效条件：root 传参即被 os.path.abspath 绝对化并 makedirs(exist_ok=True) 建立 root 与模块级 LAYERS 各层目录，autoflush（默认 64，含 0 等假值）原样存入 self.autoflush，随后 _load_index() 载入索引并以 _index_signature() 记录 _index.json 签名到 self._index_sig（跨进程读面代际感知的基线，P1b-2）、sweep_stale_temps(self.root) 清扫，并把 self 登记进模块级 _LIVE_CGS；
     def __init__(self, root: str, autoflush: int = 64):
         self.root = os.path.abspath(root)
         os.makedirs(self.root, exist_ok=True)
@@ -928,6 +937,13 @@ class MdCG:
         self._dirty = _DirtyDict()
         self._log = None
         self.index = self._load_index()
+        # P1b-2（2026-09-26，DSH 在役复验）：索引只在本行装载一次，此后
+        # read/get/search 全走内存态——其它进程（review_cli autoflush=1）
+        # 写盘对常驻进程不可见（探针 dsh_restart_recheck_20260926：写后
+        # _index.json 已含探针、同进程 read 仍 null）。记录装载时的文件
+        # 签名作为基线，读路径入口经 _maybe_reload_index 按签名变化增量
+        # 重载；无变化路径只有一次 stat（微秒级）。
+        self._index_sig = self._index_signature()
         sweep_stale_temps(self.root)
         # 进程退出兜底登记（见模块级 _LIVE_CGS）：一次性脚本漏收尾时索引仍能落盘。
         _LIVE_CGS.add(self)
@@ -972,6 +988,62 @@ class MdCG:
         idx["buckets"] = self._count_buckets(idx["nodes"])
         return idx
 
+# 生效条件：以 os.stat(self.index_path) 返回 (st_mtime_ns, st_size) 二元组；文件不存在或 stat 抛 OSError 时返回 None（stat 异常静默——签名探测绝不阻塞读）；
+    def _index_signature(self):
+        """_index.json 文件签名（P1b-2 跨进程读面代际的廉价哨兵）。
+
+        只 stat 一次（微秒级、无 open 无解析）；(mtime_ns, size) 二元组在
+        NTFS 100ns / ext4 ns 粒度下足以识别「他进程写快照」。None = 快照
+        不存在（空库或写方尚未 compact），与他进程首次落快照的 None→非 None
+        变化同样可判。
+        """
+        try:
+            st = os.stat(self.index_path)
+            return (st.st_mtime_ns, st.st_size)
+        except OSError:
+            return None
+
+# 生效条件：stat 对比 _index_signature() 与 self._index_sig，相等（含双侧 None）即返回 False 不做任何事；不等则调 _load_index() 重载，OSError/ValueError 时静默放弃并返回 False（重载失败不阻塞读，沿用旧内存态）；成功后把 self._dirty 重放回新索引（None=tombstone pop、否则覆盖，与 _load_index 的日志重放同语义——本实例未 flush 的写入不得因重载从检索面消失）并重算 buckets，替换 self.index、刷新 self._index_sig、返回 True；
+    def _maybe_reload_index(self):
+        """读路径入口的索引代际感知（P1b-2）：签名变化才重载。
+
+        语义边界（读码定案）：
+        · flush() 只追加 _index_log 分片、不改 _index.json（见 flush 注释）
+          → 签名不变 → 自身写入/落账**永不**触发重载（无自重载循环）；
+        · compact_index / rebuild_index 写 _index.json 后已主动刷新签名，
+          同理不触发；
+        · 他进程只有写出新快照（compact/rebuild，典型在 close）才改变签名
+          → 此时重载并重放分片日志（_load_index 既有行为），写入可见；
+          仅追加日志、尚无新快照的存活写方不在本探测面内（显式触发可用
+          maintain action=reload，但日志记录只有在快照重写时才会并入）；
+        · 本实例 _dirty 未 flush 的条目在重载后**重放回内存索引**——
+          _stage 双写 index+_dirty 的「检索看得到未落盘写入」语义保持。
+        """
+        sig = self._index_signature()
+        if sig == self._index_sig:
+            return False
+        try:
+            idx = self._load_index()
+        except (OSError, ValueError):
+            return False                # 重载失败不阻塞读：沿用旧内存态
+        for nid, e in self._dirty.items():
+            if e is None:
+                idx["nodes"].pop(nid, None)
+            else:
+                idx["nodes"][nid] = e
+        idx["buckets"] = self._count_buckets(idx["nodes"])
+        self.index = idx
+        self._index_sig = sig
+        # 旧索引代里的派生缓存一并失效：query 结果缓存（hotcache，默认关）
+        # 缓存的是旧候选池上的结果；解析读缓存（readcache，默认开）按 path
+        # 缓存解析产物——他进程重写同 path 节点时旧产物陈旧。重载是稀疏
+        # 事件（签名变化才有），此处清缓存不构成热路径开销。
+        from . import hotcache as _hc
+        _hc.invalidate(self)
+        from . import readcache as _rc
+        _rc.clear(self)
+        return True
+
 # 生效条件：遍历 LAYERS 各层目录树（os.walk，不读文件内容），对每个可达目录记录其相对 root 的正斜杠路径到 os.stat().st_mtime_ns 的映射；stat 抛 OSError 的目录跳过；返回该映射。
     def _dir_fingerprint(self):
         """盘面目录树 mtime 指纹——检测「快照写入后盘面有增删」的廉价哨兵。
@@ -1014,7 +1086,7 @@ class MdCG:
                 buckets[b] = buckets.get(b, 0) + 1
         return buckets
 
-# 生效条件：os.path.exists(self.index_path) 为真、JSON 可解析且 "schema" 等于 SCHEMA 时以该快照为基底；快照不存在用空骨架 {"schema":SCHEMA,"nodes":{},"buckets":{}}（不重扫目录）；快照损坏（ValueError/OSError）或 schema 不符时降级以 self._scan_nodes() 全库扫描结果为基底（宁重扫勿清池）；基底确定后对 index_log_dir 逐条重放（无 id 跳过、e 为 None 则 pop、否则覆盖），落盘并清空日志后替换 self.index 并返回 idx；
+# 生效条件：os.path.exists(self.index_path) 为真、JSON 可解析且 "schema" 等于 SCHEMA 时以该快照为基底；快照不存在用空骨架 {"schema":SCHEMA,"nodes":{},"buckets":{}}（不重扫目录）；快照损坏（ValueError/OSError）或 schema 不符时降级以 self._scan_nodes() 全库扫描结果为基底（宁重扫勿清池）；基底确定后对 index_log_dir 逐条重放（无 id 跳过、e 为 None 则 pop、否则覆盖），落盘并清空日志后替换 self.index、刷新 _index.json 签名（P1b-2 自写不自载）并返回 idx；
     def compact_index(self):
         with FileLock(self.index_path):
             idx = {"schema": SCHEMA, "nodes": {}, "buckets": {}}
@@ -1064,6 +1136,9 @@ class MdCG:
             atomic_write(self.index_path, json.dumps(idx, ensure_ascii=False))
             ShardedLog.clear(self.index_log_dir)
         self.index = idx
+        # P1b-2：自己写了快照 → 主动刷新签名，防止后续读路径把自己的
+        # compact 误判为「他进程写入」而做一次无谓重载（自写自载循环）。
+        self._index_sig = self._index_signature()
         return idx
 
 # 生效条件：self._dirty 非空时才在 FileLock(index_path) 下（必要时新建 ShardedLog）逐条 append、清空 _dirty 并关闭分片句柄；self._dirty 为空时立即返回、不写任何记录；
@@ -1220,7 +1295,7 @@ class MdCG:
         # 排序后重建序恒定（增量路径另由 cut_by_relevance 的 nid 终键兜住）。
         return {k: nodes[k] for k in sorted(nodes)}
 
-# 生效条件：每次调用都以 self._scan_nodes() 的结果重建 nodes 与 buckets 并附 _dir_fingerprint()，在 FileLock 下 atomic_write 覆盖 index_path 并 ShardedLog.clear(index_log_dir)，随后替换 self.index、清空 _dirty 并返回 idx（无 .md 时也照样覆盖为空索引）；
+# 生效条件：每次调用都以 self._scan_nodes() 的结果重建 nodes 与 buckets 并附 _dir_fingerprint()，在 FileLock 下 atomic_write 覆盖 index_path 并 ShardedLog.clear(index_log_dir)，随后替换 self.index、刷新 _index.json 签名（P1b-2 自写不自载）、清空 _dirty 并返回 idx（无 .md 时也照样覆盖为空索引）；
     def rebuild_index(self):
         nodes = self._scan_nodes()
         idx = {"schema": SCHEMA, "nodes": nodes,
@@ -1230,6 +1305,8 @@ class MdCG:
             atomic_write(self.index_path, json.dumps(idx, ensure_ascii=False))
             ShardedLog.clear(self.index_log_dir)
         self.index = idx
+        # P1b-2：rebuild 同 compact——写完快照即刷新签名（自写不自载）。
+        self._index_sig = self._index_signature()
         # broad=True：rebuild 以盘面扫描为准——ccgc/crosscheck/backfill 等
         # 「直写文件 + rebuild 收尾」的写方不经 _dirty 标脏，其文件改写对
         # 读缓存的可见性靠这一整池失效兜底（flush 的 clear 则不失效，见
@@ -1251,7 +1328,7 @@ class MdCG:
 
     # ---------- 写 ----------
 
-# 生效条件：node_id/content 必填；node_id 不匹配 _NODE_ID_RE（^[A-Za-z0-9_.@-]{1,128}$）或含 ".."、或落盘 realpath 越出 self.root 时抛 ValueError（P0-1 白名单+纵深闸）；layer 不在 LAYERS 内、或 verification_basis 非 None 且不在 VERIFICATION_BASIS 内时抛 ValueError；consistency 为真且 _cons.check 判 REJECT 时，on_conflict="reject" 抛 ConsistencyError、on_conflict="defer" 返回 None，verdict 为 BLINDSPOT 且 on_conflict="defer" 同样返回 None，其余情形完成写盘/入索引后返回 node_id。
+# 生效条件：node_id/content 必填；node_id 不匹配 _NODE_ID_RE（^[A-Za-z0-9_.@-]{1,128}$）或含 ".."、或整串精确等值于 _NODE_ID_FORBIDDEN（"None"/"null"，空语义值字符串化污染形态，P3 None.md 缺陷禁写）、或落盘 realpath 越出 self.root 时抛 ValueError（P0-1 白名单+纵深闸）；layer 不在 LAYERS 内、或 verification_basis 非 None 且不在 VERIFICATION_BASIS 内时抛 ValueError；consistency 为真且 _cons.check 判 REJECT 时，on_conflict="reject" 抛 ConsistencyError、on_conflict="defer" 返回 None，verdict 为 BLINDSPOT 且 on_conflict="defer" 同样返回 None，其余情形完成写盘/入索引后返回 node_id。
     def add(self, node_id: str, content: str, layer: str = "knowledge",
             tags=None, condition_space=None, importance: float = 0.5,
             confidence: float = 0.6, edges=None, verification_basis: str = None,
@@ -1310,6 +1387,11 @@ class MdCG:
             raise ValueError(
                 f"非法 node_id：{node_id!r}（须匹配 {_NODE_ID_RE.pattern} "
                 f"且不含 '..'——node_id 会拼进落盘路径，穿越/绝对路径一律拒绝）")
+        if nid_s in _NODE_ID_FORBIDDEN:
+            raise ValueError(
+                f"非法 node_id：{node_id!r}（空语义值的字符串化污染形态 "
+                f"{sorted(_NODE_ID_FORBIDDEN)} 禁写——会落盘成 None.md 参与检索"
+                f"（DSH 在役库实测缺陷 P3）；fail-closed，如为合法业务 id 请改名）")
         if verification_basis is not None and verification_basis not in VERIFICATION_BASIS:
             raise ValueError(f"未知验证基底：{verification_basis}（允许：{VERIFICATION_BASIS}）")
         # 写保护：self/anchor 层、protected 标记、importance≥0.7 的**既有**节点
@@ -1969,6 +2051,7 @@ class MdCG:
 # 生效条件：遍历 self.index["nodes"] 中 layer=="goals" 的节点，_goal_entry 取不到者跳过；status 为假值时不过滤、否则仅保留 status 相等者；按 (-priority, -created_at) 降序，limit 为真值时截断 out[:limit]，否则返回全量；
     def list_goals(self, status=None, limit=None):
         """列出目标，按 (priority, created_at) 降序。status 过滤 active/done/dropped。"""
+        self._maybe_reload_index()      # P1b-2：读面代际感知（goal=list/active 链）
         out = []
         for nid, e in self.index["nodes"].items():
             if e.get("layer") != "goals":
@@ -2233,6 +2316,7 @@ class MdCG:
 
 # 生效条件：index["nodes"].get(node_id) 为假值时回落 self._dirty.get(node_id)，仍为假值返回 None；打开 root 下 e["path"] 抛 OSError 返回 None；_open_content 返回 None（无密钥/身份不符）返回 None；否则返回 {id, frontmatter, content, path}；
     def get(self, node_id: str):
+        self._maybe_reload_index()      # P1b-2：读面代际感知（他进程写快照后可见）
         e = self.index["nodes"].get(node_id) or self._dirty.get(node_id)
         if not e:
             return None
@@ -2436,6 +2520,7 @@ class MdCG:
         q = unify_query(q)
         if not q:
             return [], {"tier": None, "reason": "empty_query", "scanned": 0}
+        self._maybe_reload_index()      # P1b-2：读面代际感知（空查询早退后、读索引前）
         pool_cfg = pooling.resolve(pooling.from_env(pools))
         now = time.time() if validity else None      # 统一取一次 now，保判定口径一致
 

package/md_cg/mdcos.py

@@ -764,6 +764,7 @@ class MdCGOS(MdCG):
         q = unify_query(q)
         if not q:
             return [], {"tier": None, "reason": "empty_query", "scanned": 0}
+        self._maybe_reload_index()      # P1b-2：读面代际感知（route/read/search 链）
         pool_cfg = pooling.resolve(pooling.from_env(pools))
         entries = self._candidates(layer=layer, roles=roles, include_work=include_work,
                                    session=session, branch=branch, validity=validity,
@@ -1308,6 +1309,10 @@ class MdCGOS(MdCG):
         q = unify_query(q)
         if not q:
             return [], {"tier": None, "reason": "empty_query", "paths": {}}
+        # P1b-2：读面代际感知——必须在热路径 query 缓存查询**之前**：旧索引
+        # 代里缓存的命中结果对新写入不可见（静默错答），重载成功时
+        # _maybe_reload_index 已顺带失效 hotcache/readcache。
+        self._maybe_reload_index()
         # 热路径：query 结果缓存命中即返回（不改 RRF 核心）
         # 时间算子**显式启用时绕开缓存**：缓存键不含时间参数，命中会返回
         # 未按本次窗口过滤的结果（静默错答比慢更贵）。
@@ -2237,6 +2242,16 @@ class MdCGOS(MdCG):
             if item.get("verify"):
                 extra["verify"] = item["verify"]
                 extra["verify_hash"] = expect
+            # 归因保留（P1，2026-09-26，DSH 端在役实测：5 个裁决节点 writer 全被
+            # designer-cli 覆盖、会话 id 各自随机）：提案记录的 actor 是 propose
+            # 时库端快照的原始写入者身份（见 propose rec 的 "actor"/"session" 字段，
+            # 非裁决期客户端输入，不可伪造面）。accept/edit 落盘若不显式带上，
+            # _attribution 的 setdefault 会把 writer 缺省成裁决者——原始写入者
+            # 就此不可追溯。writer 保留原值（提案 extra 里已带 writer 的存量提案
+            # 不覆盖，向后兼容）；裁决者身份不丢失，改记 reviewer 字段。
+            if item.get("actor"):
+                extra.setdefault("writer", item["actor"])
+                extra.setdefault("reviewer", self.actor)
             nid = self.add(item["id"], content, layer=layer, tags=tags,
                            condition_space=item.get("condition_space"), **extra)
             # 索引增量收尾（2026-09-16 取证）：add 只把条目放进本进程内存 _dirty，
@@ -2672,7 +2687,7 @@ class MdCGOS(MdCG):
     #       召回热路径，只在显式调用时工作。
 
     MAINTAIN_ACTIONS = ("stat", "history", "importance", "longterm",
-                        "prefeed", "separate", "rollback",
+                        "prefeed", "separate", "rollback", "reload",
                         "backfill", "backfill_rollback", "backfill_history",
                         "cap", "cap_rollback", "cap_history",
                         "exempt", "exempt_rollback", "exempt_history",
@@ -2717,7 +2732,7 @@ class MdCGOS(MdCG):
                        "discard": "已丢弃（不写）", "defer": "留待复核（不写不并）"}.get(dec, "")
         return out
 
-# 生效条件：act 取 str(action or "stat") 去空白并 lower 后按分支分派（importance / longterm / prefeed / separate / stat 等）；未识别 act 走 stat 兜底；只读与写层 action 库层不鉴权，apply 类批量改写由 MCP 分发层 require_admin 把守；
+# 生效条件：act 取 str(action or "stat") 去空白并 lower 后按分支分派（reload / importance / longterm / prefeed / separate / stat 等，reload 只触发 _maybe_reload_index 并返回 {"reloaded": bool}）；未识别 act 走 stat 兜底；只读与写层 action 库层不鉴权，apply 类批量改写由 MCP 分发层 require_admin 把守；
     def maintain(self, action="stat", layer=None, limit=None, apply=False,
                  min_delta=None, max_rows=None, force=False, keep=None,
                  mode=None, snapshot_id=None, batch=None, entry_ids=None,
@@ -2728,8 +2743,15 @@ class MdCGOS(MdCG):
 
         只读 action（stat/history/longterm 预演）与写层 action（prefeed）不受
         管理权限约束；apply 类批量改写由 MCP 分发层 `require_admin` 把守。
+
+        reload（P1b-2，DSH 建议 2）：显式触发 _maybe_reload_index（签名变化
+        才真重载），返回 {"reloaded": bool} 供外部探活常驻进程的读面代际。
         """
         act = str(action or "stat").strip().lower()
+        if act == "reload":
+            # 探活/显式刷新：无副作用面（签名未变时是零开销 stat + False）。
+            return {"ok": True, "op": "maintain", "action": "reload",
+                    "reloaded": bool(self._maybe_reload_index())}
         if act == "importance":
             return weights.recalc(self, layer=layer, limit=limit, apply=apply,
                                   min_delta=(weights.APPLY_DELTA if min_delta is None

package/md_cg/review_cli.py

@@ -14,7 +14,7 @@
 
 用法（root 须与待裁决部署一致：--root 或环境变量 MDCG_ROOT）：
   python -m md_cg.review_cli list
-  python -m md_cg.review_cli accept  <pid> --reason "实跑测试证据"
+  python -m md_cg.review_cli accept  <pid> --session <会话id> --reason "实跑测试证据"
   python -m md_cg.review_cli reject  <pid> --reason "内容有误"
   python -m md_cg.review_cli edit    <pid> --content "修正后内容" --reason "..."
   python -m md_cg.review_cli merge   <pid> --into <已有节点id> --reason "..."
@@ -27,6 +27,21 @@ noop 语义：**已评估、判定不改变任何现有记忆**——只留痕
 「评估过了、无需改动」而非「否掉这条候选」，故不可借 noop 绕过 accept 门控。
 
 裁决留痕：decisions.jsonl + 审计 md 节点（由 review_decide 内部完成）。
+
+落盘归因（P1 修复，2026-09-26，DSH 端在役实测回告）：
+  · 会话：--session（各子命令通用）缺省取环境变量 MDCG_SESSION，仍无则维持
+    现状随机会话并 stderr 告警一行。同一批裁决传同一 session，落盘节点的
+    frontmatter.session 才稳定一致（此前每次随机 sess_<uuid12>，同批 5 节点
+    5 个会话 id）。
+  · 写入者：accept/edit 落盘节点的 frontmatter.writer 保留**提案原始写入者**
+    （propose 时库端快照的 actor，如 dsh-memory）；裁决者身份不丢失，记入
+    frontmatter.reviewer（designer-cli）。
+  · DSH 前置条件（环境侧自行核对，本 CLI 不校验）：MCP 写入面对 DSH 形态会话
+    id（session-<8>-<4>-<4>-<4>-<12>）有 `_normalize_session` 防编造校验
+    （md_cg/mcp_server.py）——会话目录须真存在于 MDCG_DSH_SESSIONS_ROOT 或
+    ~/.dsh/sessions 之下，否则该会话在 MCP 面降级为 anonymous。本 CLI 直构
+    Principal 不经该校验，但若裁决的会话 id 与 MCP 面共用，请先确认目录在位，
+    否则两侧归因对不上。
 """
 import argparse
 import json
@@ -57,12 +72,38 @@ def _root(args):
     return root
 
 
-# 生效条件：args 就绪时先构造写死权限的 Principal(actor="designer-cli", clearance="secret", can_write=True, can_admin=True, role="designer", auth_mode="local-cli")，再以 _root(args) 取到的存储根返回 MdCGSecure(root, principal=p)。
+# 生效条件：args 的 session 属性为真值（含 getattr 缺省 None 回落）或环境变量 MDCG_SESSION 去空白后非空时返回该值（前者优先），两者皆无返回 None。
+def _session_of(args):
+    """裁决会话归属：--session > 环境变量 MDCG_SESSION > None（随机 + 告警）。"""
+    s = str(getattr(args, "session", None)
+            or os.environ.get("MDCG_SESSION", "") or "").strip()
+    return s or None
+
+
+# 生效条件：args 就绪时先经 _session_of 取裁决会话归属，取到 None 时向 stderr 告警一行（缺省随机会话、同批裁决请传同一 --session）后维持现状；随后构造写死权限的 Principal(actor="designer-cli", clearance="secret", can_write=True, can_admin=True, role="designer", auth_mode="local-cli", session=<上述归属>)，再以 _root(args) 取到的存储根返回 MdCGSecure(root, principal=p, autoflush=1)。
 def _cg(args):
+    session = _session_of(args)
+    if session is None:
+        # P1 归因（2026-09-26，DSH 端在役实测）：缺省随机会话会让同一批裁决
+        # 得到互不相同的落盘归属（5 节点 5 个 sess_* 实录）。不拒绝、告警一行
+        # 后维持现状（向后兼容）；要稳定归属请显式传同一 --session。
+        sys.stderr.write("警告：未指定 --session / 环境变量 MDCG_SESSION，"
+                         "本次裁决落盘使用随机会话 id——同一批裁决请传同一 "
+                         "--session 以稳定归属。\n")
     p = Principal(actor="designer-cli", clearance="secret",
                   can_write=True, can_admin=True, role="designer",
-                  auth_mode="local-cli")
-    return MdCGSecure(_root(args), principal=p)
+                  auth_mode="local-cli", session=session)
+    # 索引可见性（P1b，2026-09-26）：autoflush=1 —— 与 mcp_server.py:3695-3702
+    # 同款（server 级兜底 2026-09-16 已修），本处是同一兜底的**第二落点**，
+    # DSH 端在役实测 read null 后补齐。根因：缺省 autoflush=64 时写入先经
+    # _stage 入内存 _dirty，攒够阈值才 flush() 落分片日志 `_index_log/`；
+    # 本 CLI 正常退出有 main 的 finally cg.close() 与库层 atexit 双兜底
+    # （mdcg.py _LIVE_CGS），但兜底刻意只覆盖正常退出——被 kill / 崩溃时
+    # 两者都不执行，裁决节点停在内存索引、日志从未落，盘面文件在而索引
+    # 链路断，在役旧读面 `_load_index` 盲信既有快照即 read null。逐条落
+    # 日志后任意退出形态下写入对其它进程立即可见（review_decide 自身的
+    # 显式 flush 只覆盖其目标/审计节点，且与节点文件落盘之间仍有窗口）。
+    return MdCGSecure(_root(args), principal=p, autoflush=1)
 
 
 # 生效条件：rec 支持 .get 时，取 rec.get("content") 为假值则取 rec.get("statement")、再为假值则取空串，把其中的换行替换为空格，并按 width（缺省 66）切片后仅当 len(text) > width 才追加 "…"，返回该字符串。
@@ -131,6 +172,10 @@ def main(argv=None):
         description="灵枢审核队列裁决（designer 权限）")
     common = argparse.ArgumentParser(add_help=False)
     common.add_argument("--root", help="存储根目录（默认环境变量 MDCG_ROOT）")
+    common.add_argument("--session", default=None,
+                        help="裁决会话 id（落盘归属 frontmatter.session；缺省取"
+                             "环境变量 MDCG_SESSION，仍无则随机会话并 stderr 告警。"
+                             "同一批裁决传同一值即得同一归属）")
     sub = ap.add_subparsers(dest="cmd", required=True)
 
     sub.add_parser("list", help="列出待审条目", parents=[common])

package/md_cg/test_index_crossprocess_reload.py

@@ -0,0 +1,301 @@
+# -*- coding: utf-8 -*-
+"""md_cg · 常驻进程索引跨进程重载守卫（P1b-2 读面缓存代际，DSH 端在役复验）
+
+缺陷（修复前）：`MdCG.__init__` 仅启动时 `self.index = self._load_index()`
+一次（mdcg.py），此后 read/get/search 全走内存态——其它进程（review_cli
+autoflush=1）写盘对常驻进程不可见。复验证据链（dsh_restart_recheck_20260926，
+时间戳锁死）：22:13:16 常驻进程装载快照(14135 节点) → 22:14:37 review_cli
+写入 → 22:14:43 磁盘 _index.json 已含探针 → 同常驻进程 read 仍 null、旁路
+新进程可读。
+
+修复：__init__ 记录 _index.json 签名 (st_mtime_ns, st_size)；读路径入口
+（get / search（基类与 MdCGOS）/ search_rrf（热缓存查询之前）/ list_goals）
+单点调 _maybe_reload_index()——签名变化才重载（一次 stat 微秒级）；自身
+flush 只追加 _index_log 分片不改 _index.json（签名不变正合适）、compact/
+rebuild 写快照后主动刷签名（自写不自载）；maintain action=reload 显式探活。
+
+守卫（六组，全部临时库 + 哑主密钥，绝不触真实 ~/.mdcg）：
+  ① 红转绿（同解释器双实例，复刻 DSH 形态）：A 建库常驻 → B 独立实例
+    add+close（compact 落快照=review_cli 退出同款）→ 盘面快照已含探针 →
+    A 禁用 reload 时 read null（修前病灶形态）→ 恢复后 read/search 命中
+    （修复生效）→ C 实例 forget+close → A read 归 null（tombstone 重放）。
+  ② 旁路新进程可读（subprocess 全新解释器 _load_index+read）——修前已绿，
+    钉住「盘面账本正确」，防两层兜底（批次39 指纹自愈）未来被移除时复发。
+  ③ 自身写入零重载：A' 写入+flush+compact+rebuild 全程真实重载次数 0
+    （自写不自载循环防线）；连续读 N 次=签名探测 N 次、重载 0 次。
+  ④ maintain reload 动作在位：MAINTAIN_ACTIONS 登记 + {"reloaded": bool}
+    返回（他进程写入后 True 且读面可见；幂等二调 False）。
+  ⑤ goal=list 链路跨进程可见（list_goals 接线腿，active_goals 同源）。
+  ⑥ 性能粗测：无跨进程写入时接线态 vs 重载桩空转态逐读耗时对照（宽松
+    上界断言防「重载被改成无条件」的性能回归；绝对数字只打印不作硬门）。
+
+如实边界：② 在修复前的 HEAD 上已绿（旁路进程本就走全新 _load_index）；
+修复前红的正是 ① 的常驻读面——本守卫以「禁用 reload → null」复现该形态，
+并以 ③ 的计数桩钉住接线与自写不自载两道防线。
+
+运行：python -m md_cg.test_index_crossprocess_reload
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+
+from .mdcos import MdCGSecure
+from .security import Principal
+
+PASS = FAIL = 0
+FAILS = []
+
+REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+DUMMY_KEY = "ab" * 32          # 哑主密钥：本进程与子进程绝不触真实 ~/.mdcg
+
+READ_CHILD = r'''
+import sys
+sys.path.insert(0, sys.argv[2])
+from md_cg.mdcos import MdCGSecure
+from md_cg.security import Principal
+p = Principal(actor="p1b2-reader", clearance="internal", can_write=True,
+              can_admin=True, role="designer", auth_mode="test")
+cg = MdCGSecure(sys.argv[1], principal=p)
+try:
+    print("READ " + " ".join("1" if cg.get(nid) is not None else "0"
+                             for nid in sys.argv[3].split(",")))
+finally:
+    cg.close()
+'''
+
+
+def check(name, cond, detail=""):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  [PASS] {name}" + (f"  · {detail}" if detail else ""))
+    else:
+        FAIL += 1
+        FAILS.append(name)
+        print(f"  [FAIL] {name}  · {detail}")
+
+
+def _principal(**kw):
+    d = dict(actor="p1b2", clearance="internal", can_write=True,
+             can_admin=True, role="designer", auth_mode="test")
+    d.update(kw)
+    return Principal(**d)
+
+
+def _spawn_read(root, ids):
+    """独立子进程全新 _load_index + read（旁路读面）。"""
+    env = dict(os.environ)
+    env["MDCG_MASTER_KEY"] = DUMMY_KEY
+    env["PYTHONUTF8"] = "1"
+    env["PYTHONIOENCODING"] = "utf-8"
+    env["PYTHONPATH"] = REPO + os.pathsep + env.get("PYTHONPATH", "")
+    return subprocess.run(
+        [sys.executable, "-X", "utf8", "-c", READ_CHILD, root, REPO, ids],
+        capture_output=True, text=True, encoding="utf-8", errors="replace",
+        env=env, cwd=REPO)
+
+
+def _snapshot_ids(root):
+    """盘面 _index.json 的节点 id 集（复验证据链 22:14:43 的观察点）。"""
+    p = os.path.join(root, "_index.json")
+    if not os.path.exists(p):
+        return None
+    with open(p, encoding="utf-8") as f:
+        return set(json.load(f).get("nodes") or {})
+
+
+def _counting(cg):
+    """给 _maybe_reload_index 挂计数桩，返回 (计数 dict, 解挂函数)。"""
+    calls = {"probe": 0, "reload": 0}
+    orig = cg._maybe_reload_index
+
+    def counted():
+        calls["probe"] += 1
+        r = orig()
+        if r:
+            calls["reload"] += 1
+        return r
+
+    cg._maybe_reload_index = counted
+    return calls, (lambda: setattr(cg, "_maybe_reload_index", orig))
+
+
+def main():
+    roots = []
+    # 纪律：哑主密钥先行——进程内任何 MdCGSecure 构造都不得触真实
+    # ~/.mdcg/master.key（_init_crypto 的 env 回落链，mdcos.py）。
+    os.environ["MDCG_MASTER_KEY"] = DUMMY_KEY
+    try:
+        # ---------- ① 红转绿：常驻 A + 独立写方 B（DSH 形态复刻） ----------
+        print("\n【①】常驻 A 建库 → 独立 B add+close（compact 落快照）→ 红转绿")
+        root1 = tempfile.mkdtemp(prefix="p1b2_1_")
+        roots.append(root1)
+        a = MdCGSecure(root1, principal=_principal())
+        a.add("seed_node_1", "# 功能名：种子节点\n# 正文：常驻 A 的初始记忆",
+              layer="knowledge")
+        a.flush()                      # 只追加 _index_log 分片，不动 _index.json
+        check("A 自身 flush 不改 _index.json 签名（分片追加不改快照）",
+              a._index_sig == a._index_signature())
+        b = MdCGSecure(root1, principal=_principal(actor="writer_b"))
+        b.add("reload_probe_1", "# 功能名：跨进程探针\n# 正文：B 写入的探针节点",
+              layer="knowledge")
+        b.close()                      # close → compact：写 _index.json（review_cli 退出同款）
+        ids = _snapshot_ids(root1)
+        check("盘面 _index.json 已含 B 的探针（复验证据链 22:14:43 形态）",
+              ids is not None and "reload_probe_1" in ids,
+              "snapshot_ids=%s" % (sorted(ids or [])[:8]))
+        # 红形态：修前无 _maybe_reload_index → 常驻 A 读不到
+        orig_reload = a._maybe_reload_index
+        a._maybe_reload_index = lambda: False
+        red = a.get("reload_probe_1")
+        a._maybe_reload_index = orig_reload
+        check("红（修前病灶形态）：禁用 reload 时常驻 A read 探针 null",
+              red is None, repr(red)[:80])
+        fired = a._maybe_reload_index()
+        check("绿：_maybe_reload_index 签名变化触发重载", fired is True)
+        green = a.get("reload_probe_1")
+        check("绿：常驻 A read 探针命中", green is not None,
+              repr(green)[:80])
+        res, _meta = a.search("跨进程探针")
+        check("绿：常驻 A search（route/read 链路）命中探针",
+              any(n.get("id") == "reload_probe_1" for n, _s, _q in res),
+              str([n.get("id") for n, _s, _q in res])[:120])
+        # 删除可见性：C 实例 forget → tombstone 经重放对 A 生效
+        c = MdCGSecure(root1, principal=_principal(actor="writer_c"))
+        fr = c.forget("reload_probe_1", reason="P1b-2 tombstone 腿")
+        c.close()
+        check("C forget 成功（ok=True）", isinstance(fr, dict) and fr.get("ok"),
+              str(fr)[:80])
+        check("绿：常驻 A read 已删节点归 null（tombstone 重放）",
+              a.get("reload_probe_1") is None)
+        a.close()
+
+        # ---------- ② 旁路新进程可读（修前已绿，钉住盘面账本） ----------
+        print("\n【②】旁路全新子进程 read（_load_index 直读盘面）")
+        root2 = tempfile.mkdtemp(prefix="p1b2_2_")
+        roots.append(root2)
+        w = MdCGSecure(root2, principal=_principal(actor="writer_2"))
+        w.add("bypass_probe", "# 功能名：旁路探针\n# 正文：新进程应立即可见",
+              layer="knowledge")
+        w.close()
+        r2 = _spawn_read(root2, "bypass_probe,missing_node")
+        line = (r2.stdout or "").strip().splitlines()[-1] if (r2.stdout or "").strip() else ""
+        check("旁路新进程 read：探针 1 / 缺失 0（READ 1 0）",
+              line == "READ 1 0",
+              "stdout=%r stderr=%r" % ((r2.stdout or "")[:80], (r2.stderr or "")[:200]))
+
+        # ---------- ③ 自身写入零重载 + 自写不自载 ----------
+        print("\n【③】自身写入/flush/compact/rebuild 全程零真实重载")
+        root3 = tempfile.mkdtemp(prefix="p1b2_3_")
+        roots.append(root3)
+        a2 = MdCGSecure(root3, principal=_principal())
+        a2.add("own_seed", "# 功能名：自有种子\n# 正文：own seed", layer="knowledge")
+        a2.flush()
+        calls, uncount = _counting(a2)
+        for i in range(3):
+            a2.add("own_%d" % i, "# 功能名：自写%d\n# 正文：own write %d" % (i, i),
+                   layer="knowledge")
+        a2.flush()
+        for i in range(3):
+            a2.get("own_%d" % i)
+        a2.search("自写")
+        a2.list_goals()
+        check("自身写入+flush+读全程：重载 0 次（写路径不接、flush 不改签名）",
+              calls["reload"] == 0, str(calls))
+        check("接线在位：读路径确经签名探测（3×get+1×search+1×list_goals=5 次）",
+              calls["probe"] >= 5, str(calls))
+        a2.compact_index()
+        check("compact 后签名已主动刷新（自写不自载前提）",
+              a2._index_sig == a2._index_signature())
+        a2.get("own_0")
+        a2.rebuild_index()
+        a2.get("own_0")
+        check("compact/rebuild 后紧接读：重载仍 0 次", calls["reload"] == 0,
+              str(calls))
+        uncount()
+        a2.close()
+
+        # ---------- ④ maintain reload 动作 ----------
+        print("\n【④】maintain action=reload 显式探活")
+        from .mdcos import MdCGOS
+        check('"reload" 已登记 MAINTAIN_ACTIONS', "reload" in MdCGOS.MAINTAIN_ACTIONS,
+              str(MdCGOS.MAINTAIN_ACTIONS))
+        a3 = MdCGSecure(root3, principal=_principal())
+        out0 = a3.maintain(action="reload")
+        check("幂等：签名未变时 reloaded=False",
+              isinstance(out0, dict) and out0.get("reloaded") is False,
+              str(out0)[:120])
+        bw = MdCGSecure(root3, principal=_principal(actor="writer_4"))
+        bw.add("maintain_probe", "# 功能名：维护探针\n# 正文：maintain reload 腿",
+               layer="knowledge")
+        bw.close()
+        out1 = a3.maintain(action="reload")
+        check("他进程写快照后 maintain reload 返回 reloaded=True",
+              isinstance(out1, dict) and out1.get("reloaded") is True,
+              str(out1)[:120])
+        check("探活后读面立即可见新节点", a3.get("maintain_probe") is not None)
+        a3.close()
+
+        # ---------- ⑤ goal=list 链路（list_goals 接线腿） ----------
+        print("\n【⑤】goal 跨进程可见（list_goals / active_goals）")
+        root4 = tempfile.mkdtemp(prefix="p1b2_4_")
+        roots.append(root4)
+        a4 = MdCGSecure(root4, principal=_principal())
+        check("常驻 A' 初始无目标", a4.list_goals() == [])
+        gw = MdCGSecure(root4, principal=_principal(actor="writer_5"))
+        gid = gw.add_goal("跨进程目标探针：P1b-2 list_goals 接线腿", priority=0.9)
+        gw.close()
+        gl = a4.list_goals()
+        check("goal=list 经 list_goals 重载后可见",
+              any(g.get("id") == gid for g in gl),
+              str([g.get("id") for g in gl])[:120])
+        ag = a4.active_goals()
+        check("active_goals 同源可见",
+              any(g.get("id") == gid for g in ag))
+        a4.close()
+
+        # ---------- ⑥ 性能粗测：无跨进程写入时逐读开销 ----------
+        print("\n【⑥】性能粗测（无跨进程写入，接线态 vs 重载桩空转态）")
+        N = 300
+        a2c = MdCGSecure(root3, principal=_principal())
+        for _ in range(5):
+            a2c.get("own_0")
+        t0 = time.perf_counter()
+        for _ in range(N):
+            a2c.get("own_0")
+        t_on = (time.perf_counter() - t0) / N * 1e6
+        orig = a2c._maybe_reload_index
+        a2c._maybe_reload_index = lambda: False
+        for _ in range(5):
+            a2c.get("own_0")
+        t0 = time.perf_counter()
+        for _ in range(N):
+            a2c.get("own_0")
+        t_off = (time.perf_counter() - t0) / N * 1e6
+        a2c._maybe_reload_index = orig
+        a2c.close()
+        print("       接线态 %.1f µs/读 · 桩空转态 %.1f µs/读 · 增幅 %.1f%%"
+              % (t_on, t_off, (t_on - t_off) / max(t_off, 1e-9) * 100))
+        check("性能上界：接线态 ≤ 桩空转态×3 + 30µs（stat 微秒级；宽松防抖）",
+              t_on <= t_off * 3 + 30.0,
+              "on=%.1f off=%.1f" % (t_on, t_off))
+    finally:
+        for r_ in roots:
+            shutil.rmtree(r_, ignore_errors=True)
+
+    print("\n" + "=" * 64)
+    print(f"PASS={PASS}  FAIL={FAIL}")
+    if FAILS:
+        print("失败项：" + "；".join(FAILS))
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())