@furongjun1999/dsh-memory 0.5.0 → 0.6.0

package/md_cg/mdcos.py

@@ -36,7 +36,7 @@ from . import (nodefile, routing, chain, subgraph, forgetting, protect,
                self_state, predict, evolution, weights, pooling,
                writelimit, reach, trust, roleviews)
 from .fsutil import (FileLock, atomic_write, append_jsonl, read_jsonl,
-                     count_jsonl)
+                     read_jsonl_tail, count_jsonl, publish)
 from .security import (Principal, TenantRegistry, AccessDenied,
                        SENSITIVITY_ORDER, DEFAULT_SENSITIVITY, _rank)
 
@@ -326,6 +326,27 @@ class MdCGOS(MdCG):
         os.makedirs(self.trash_dir, exist_ok=True)
         self._audit_writes = 0        # 进程内写入计数（轮转探测节流，稳态零 stat）
         self._audit_index = None      # 归档索引缓存（懒加载）
+        # 审核队列增量对账缓存（issue #32）：inbox/decisions 均为 append-only
+        # （写点全在 strict 锁内经 append_jsonl，无轮转/截断），propose 的
+        # 幂等对账从「每条全量重读 O(M+D)」改为「stat 尾部增量」——跨进程
+        # append 由 stat 自动并入，无需显式失效。
+        self._inbox_idx = {}          # phash → [(pid, node_id)] 文件序
+        self._inbox_idx_size = -1     # 已并入的 inbox 字节偏移（扫描水位）
+        self._inbox_idx_mtime = -1
+        self._pid_st = {}             # pid → 最新裁决记录
+        self._pid_st_size = -1        # 已并入的 decisions 字节偏移
+        self._pid_st_mtime = -1
+        # review 治理面全记录增量缓存（issue #35）：review_stats/review_list/
+        # review_decide/_cascade_dedup/verify_review_record 单次调用内曾各自
+        # 全量重读同一 jsonl（inbox 2 遍 + decisions 1-4 遍）——改为 stat 尾部
+        # 增量的全记录缓存（与 _pid_status 同款对账），调用方内存线性扫。
+        # 注意：缓存列表为内部状态，调用方只读不得变更。
+        self._inbox_recs = []         # inbox 全记录（文件序）
+        self._inbox_recs_size = -1
+        self._inbox_recs_mtime = -1
+        self._dec_recs = []           # decisions 全记录（文件序）
+        self._dec_recs_size = -1
+        self._dec_recs_mtime = -1
         # 热缓存挂载（issue #28，2026-09-23）：读侧（search_rrf）与失效侧
         # （writepipe）早已接好，唯独无人调 attach——生产恒 None，重复 query
         # 无法命中。默认关（env 未设 → get(self) 恒 None，零变更纪律）；
@@ -336,10 +357,14 @@ class MdCGOS(MdCG):
             _hc.attach(self)
         # 检索读缓存挂载（issue #31 P2，批次 21）：MdStore 理论落地——节点
         # 文件解析产物常驻（567 池实测 572 次 open/查询 → 缓存后 ~0），写失
-        # 效走 _dirty 代际哨兵（所有写路径必然标脏，无漏挂面）。默认关
-        # （MDCG_READ_CACHE=1 显式启用，零变更纪律）。
-        if os.environ.get("MDCG_READ_CACHE") == "1":
-            from . import readcache as _rc
+        # 效走 _dirty 代际哨兵（所有写路径必然标脏，无漏挂面）。
+        # 默认**开**（issue #31 后续修复）：生产检索入口（本类 search →
+        # _read_many）默认态每查询全池 open+2×realpath+frontmatter 解析，
+        # 3300 池实测 ~602ms/查询、万级外推 ~2s+（O(n) 线性）；开关早已
+        # 存在但默认关 → 生产恒不装配。MDCG_READ_CACHE=0 显式关闭（opt-out
+        # 退出阀：跨进程改写须本进程立即可见 / 内存受限的部署回到旧行为）。
+        from . import readcache as _rc
+        if _rc.enabled():
             _rc.install(self)
 
     # ================= 6. payload-free 审计 =================
@@ -457,7 +482,7 @@ class MdCGOS(MdCG):
             name = "_audit.%06d.jsonl" % self._next_shard_seq()
             dst = os.path.join(self.audit_archive, name)
             try:
-                os.replace(self.audit_log, dst)
+                publish(self.audit_log, dst)   # Windows 短重试：AV 短锁不误判抢输
             except OSError:
                 return None                    # 抢输（文件已被移走）→ 让位，不报错
             scale = self._audit_count_shard(dst, size)   # 分档：有界扫描 / 只读量级
@@ -580,10 +605,22 @@ class MdCGOS(MdCG):
         """在父类 add 之上：写入 role（frontmatter + 索引），默认 role=None（知识）。"""
         if role is not None:
             kw["role"] = role
+        # 会话归属必须落 frontmatter：本文件 session 过滤的文档即写「frontmatter.session，
+        # 写入时自动落盘」，但父类 add 的 fm 固定字典里没有该键、_stage 只把它放进索引 →
+        # 实际只有索引带归属，任何 rebuild_index() 都会抹掉（实测 73 节点里 56 个无
+        # frontmatter.session，而 _audit.jsonl 的 add 事件却 152/152 都记了 session：
+        # 写入口径与落盘口径脱钩）。与 role 同款：显式给就尊重，否则取 self.session
+        # （MdCGSecure 由 principal.session 注入，mcp_server 按请求切换 cg.session）。
+        _sess = kw.get("session") or getattr(self, "session", None)
+        if _sess and not kw.get("session"):
+            kw["session"] = _sess
         nid = super().add(node_id, content, layer=layer, **kw)
         e = self.index["nodes"].get(nid)
         if e is not None and role is not None:
             e["role"] = role
+        if e is not None and _sess:
+            e["session"] = _sess
+        if e is not None and (role is not None or _sess):
             self._dirty[nid] = e
         self._audit("add", nid, layer=layer, role=role,
                     payload_hash=_sig(content))
@@ -727,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,
@@ -758,6 +796,12 @@ class MdCGOS(MdCG):
         if context is not None:
             ctx = context if isinstance(context, dict) else {}
             route_bucket = routing.bucket_dir(routing.route_key(ctx, ctx.get("tags")))
+            # 与 MdCG.search 同一纪律（X2）：无域信号时不施加桶约束，否则 route_key
+            # 回落的 orphan 会被当成真桶，下面 T0/T1 阶段读到该桶并因 valid>=min_results
+            # 直接 return，**全量阶梯永不执行** —— 标了 domain: 的节点整片不可见。
+            # 本覆写才是生产路径（MdCGSecure → 本类）：缺此条则 MCP 端依旧丢召回。
+            if route_bucket == routing.ORPHAN:
+                route_bucket = None
         big_domain = routing.big_domain_classify(terms)
         big_scores = routing.big_domain_score_breakdown(terms)
         # S1/S1b/S2 收敛 + S4 审计——与 MdCG.search 共享同一实现（issue #25：
@@ -771,9 +815,15 @@ class MdCGOS(MdCG):
             stat["gates"] = gates
         neg_coverage = self._neg_coverage(terms) if include_neg else []
 
-# 生效条件：对 docs 调 self._score 后，若其中分数 >0 的条数达到（search 作用域内的）min_results 就返回 self._emit(scored, k, tier, stat, route_bucket, record, len(docs), ...)，否则返回 None。
-        def try_stage(docs, tier):
-            scored = self._score(docs, q, qb, pool_cfg)
+# 生效条件：scored 为 None 时对 docs 调 self._score(docs, q, qb, pool_cfg)，非 None 时直接以之为打分结果；分数 >0 的条数达到（search 作用域内的）min_results 就返回 self._emit(scored, k, tier, stat, route_bucket, record, len(docs), ...)，否则返回 None。
+        def try_stage(docs, tier, scored=None):
+            # P2-4 回移（v7 N51 留档修复，缺陷迭代第 14 轮）：支持传入已打分
+            # 结果——此前 T2/T3 均为「打分截断后又对 picked 重打」（600 池实测
+            # _score 4 调 [0,0,600,500]=1100 文档，500/1100≈45% 冗余）。与基类
+            # try_stage（mdcg.py P2-4，批次 31）同模板；_score 在单次 search 内
+            # 是纯函数（docs/q/qb/pool_cfg 均不变），透传不改变任何分值与输出。
+            if scored is None:
+                scored = self._score(docs, q, qb, pool_cfg)
             valid = sum(1 for _, s in scored if s > 0)
             if valid >= min_results:
                 return self._emit(scored, k, tier, stat, route_bucket, record,
@@ -781,6 +831,22 @@ class MdCGOS(MdCG):
                                   big_domain, big_scores, pool_cfg)
             return None
 
+        def _prescored(docs, scored_all):
+            """P2-4 透传形态：按 node_id 键表把 docs 映射回已打分的
+            (card, score) 原对（恰为 _score 对该 docs 的输出，picked 序）。
+
+            键口径：scored 元素是 (card, score)，card["id"] = fm.get("id")
+            or e["path"]，恰为 doc_key(doc)[0]（V21-6 取 [0] 作键同源）——
+            **不可**对 scored 元素调 pooling.doc_key（其形参是 (entry, fm,
+            content) 三元组；基类 reach 分支旧模板即此形态错误，MDCG_REACH=1
+            时 KeyError: 1，见 mdcg.py 同修）。**不可**自组 (doc, score) 对
+            （_emit 排序键读 x[0]["frontmatter"]，x[0] 须是 card dict）。
+            docs 必为 scored_all 的子序列（cut_by_relevance 只选不造），
+            键表必命中。
+            """
+            smap = {c.get("id"): (c, s) for c, s in scored_all}
+            return [smap[pooling.doc_key(d)[0]] for d in docs]
+
         if route_bucket:
             in_bucket = [e for e in entries if e.get("bucket") == route_bucket]
             if in_bucket:
@@ -819,11 +885,15 @@ class MdCGOS(MdCG):
             stat["cap"] = GLOBAL_CAP
             # 与 T2 **无条件**同序调用（不可按 cap 短路：cut_by_relevance 还会写
             # 池账 pool_taken/cands/lost，短路会让 meta.pools.taken 缺失 → test_p43(13) 红）
-            hits_r, _rep = cut_by_relevance(hits_r, self._score(hits_r, q, qb, pool_cfg),
+            scored_r = self._score(hits_r, q, qb, pool_cfg)
+            hits_r, _rep = cut_by_relevance(hits_r, scored_r,
                                             GLOBAL_CAP, pools=pool_cfg,
                                             key_of=pooling.doc_key, stat=stat)
             pooling.record_audit(stat, _rep)
-            out = try_stage(hits_r, TIER_GLOBAL_LIKE)
+            # P2-4：打分结果经 scored 透传，不再对同一 hits_r 二次 _score
+            # （与基类 reach 分支同模板）。
+            out = try_stage(hits_r, TIER_GLOBAL_LIKE,
+                            scored=_prescored(hits_r, scored_r))
             if out:
                 return out
             # 收敛阶段未产出结果 → 继续走下方全量 T2/T3；此时必须**改写 reach 审计**，
@@ -844,22 +914,27 @@ class MdCGOS(MdCG):
                 or (semantic_on() and d[1].get("semantic"))]
         stat["pre_cap"] = len(hits)
         stat["cap"] = GLOBAL_CAP
-        hits, _rep = cut_by_relevance(hits, self._score(hits, q, qb, pool_cfg),
+        scored_h = self._score(hits, q, qb, pool_cfg)
+        hits, _rep = cut_by_relevance(hits, scored_h,
                                       GLOBAL_CAP, pools=pool_cfg,
                                       key_of=pooling.doc_key, stat=stat)
         pooling.record_audit(stat, _rep)
-        out = try_stage(hits, TIER_GLOBAL_LIKE)
+        # P2-4：截断打分结果透传，T2 腿不再对 hits 二次 _score。
+        out = try_stage(hits, TIER_GLOBAL_LIKE,
+                        scored=_prescored(hits, scored_h))
         if out:
             return out
 
         stat["pre_cap"] = len(docs_all)
         stat["cap"] = GLOBAL_CAP
-        picked, _rep = cut_by_relevance(docs_all,
-                                        self._score(docs_all, q, qb, pool_cfg),
+        scored_a = self._score(docs_all, q, qb, pool_cfg)
+        picked, _rep = cut_by_relevance(docs_all, scored_a,
                                         GLOBAL_CAP, pools=pool_cfg,
                                         key_of=pooling.doc_key, stat=stat)
         pooling.record_audit(stat, _rep)
-        scored = self._score(picked, q, qb, pool_cfg)
+        # P2-4：T3 不再对 picked 重打（600 池实测此腿冗余 500 文档/查询，
+        # GLOBAL_CAP=500 截断后 picked ⊆ docs_all，键表回填即得终榜打分）。
+        scored = _prescored(picked, scored_a)
         return self._emit(scored, k, TIER_GLOBAL_SCAN, stat, route_bucket,
                           record, len(picked), judge,
                           context, neg_coverage, big_domain, big_scores, pool_cfg)
@@ -915,6 +990,16 @@ class MdCGOS(MdCG):
             return []
         ctx = context if isinstance(context, dict) else {}
         b = routing.bucket_dir(routing.route_key(ctx, ctx.get("tags")))
+        # 「无域信号」等价于「没声明条件」：条件桶路此时必须**弃权**，不能把
+        # route_key 回落的 orphan 当成一个真桶去硬过滤——否则凡是被标了 domain:
+        # （因而落在 cond_* 目录）的节点，对这条查询就整片不可见。
+        # 实测（带 context 但不含 domain / observation_position）：弃权前只扫
+        # orphan 桶 10 个节点、目标节点召回丢失（T1_bucket_scan/scanned=10）；
+        # 弃权后由词法/实体/图路正常召回（T2_global_like/scanned=75）。
+        # 与上面 context is None 的既有早返回同构，也贴合 test_p0 的
+        # 「桶路由平均 recall@10 ≥ 0.9（加 context 不丢召回）」不变量。
+        if b == routing.ORPHAN:
+            return []
         inb = [e for e in entries if e.get("bucket") == b]
         if not inb:
             return []
@@ -939,7 +1024,7 @@ class MdCGOS(MdCG):
                              "content": c, "path": e["path"]}, 1.0))
         return out
 
-# 生效条件：当 seeds 非空时，仅取前 5 个种子，从每个种子节点的 frontmatter.edges 取 target（dict 取 target，否则 str(edge)），若 target 在 entries 映射中且不在 seed_ids 中则读取并追加分数 s*0.5；seeds 为空返回 []；depth 默认 1 但本段未使用；
+# 生效条件：当 seeds 非空时，仅取前 5 个种子，种子的 edges 取法为：其 id 在 entries 的 path 文件名映射（by_id）中时经 self._read(e_seed) 读 frontmatter（读缓存覆盖——get 裸 open 不在缓存包装面），不在映射中（fm.id≠文件名等形态）时回落 self.get(n["id"])（旧口径，冷路径）；从 edges 取 target（dict 取 target，否则 str(edge)），若 target 在 entries 映射中且不在 seed_ids 中则读取并追加分数 s*0.5；seeds 为空返回 []；depth 默认 1 但本段未使用；
     def _path_graph(self, query, entries, seeds, depth=1):
         """图扩展路径：从词法种子沿 edges 一跳扩展。"""
         if not seeds:
@@ -951,10 +1036,24 @@ class MdCGOS(MdCG):
             by_id[nid] = e
         out = []
         for n, s in seeds[:5]:
-            node = self.get(n["id"])
-            if not node:
-                continue
-            for edge in (node["frontmatter"].get("edges") or []):
+            # 种子读改走 self._read（v9:92/v13 留档修复，缺陷迭代第 14 轮）：
+            # get 裸 open+nodefile.loads，不在 readcache.install 的包装面
+            #（只包 cg._read）——search_rrf 默认 paths 含 graph，每查询固定
+            # ≤5 次盘读（40 池实测 Q2 增量恰 5，graph 零产出也在边循环前
+            # 发生）；边目标（下方 self._read）早已同形。种子只要 frontmatter
+            # 的 edges（content 不解封不用），种子来自 lexical（entries/
+            # _candidates 派生，MdCGSecure._candidates 已过 _readable）——
+            # 绕过 get 的读隔离门无损失，图路扩展产物本由
+            # MdCGSecure.search_rrf 终态二次过滤兜底。by_id 不含（fm.id≠
+            # 文件名等形态）回落 get 保旧口径。
+            e_seed = by_id.get(n["id"])
+            if e_seed is not None:
+                fm_s, _c = self._read(e_seed)
+                edges = (fm_s or {}).get("edges") or []
+            else:
+                node = self.get(n["id"])
+                edges = ((node or {}).get("frontmatter") or {}).get("edges") or []
+            for edge in edges:
                 tid = edge.get("target") if isinstance(edge, dict) else str(edge)
                 if tid in by_id and tid not in seed_ids:
                     e = by_id[tid]
@@ -1210,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 核心）
         # 时间算子**显式启用时绕开缓存**：缓存键不含时间参数，命中会返回
         # 未按本次窗口过滤的结果（静默错答比慢更贵）。
@@ -1228,6 +1331,9 @@ class MdCGOS(MdCG):
             "judge": bool(judge), "judge_ranking": bool(judge_ranking),
             "goal_text": goal_text, "context": context,
             "early_stop_threshold": early_stop_threshold,
+            # 进程级开关也改口径（v14 只补了参数面）：MDCG_SEMANTIC /
+            # MDCG_EN_ATOMS / MDCG_UNIFY_QUERY 等不入键即跨口径命中（2026-09-24 修复）。
+            "env_switch": _hc.env_switch_key(),
         }
         # 不可稳定进键的参数（自定义可调用 query_expand）：非默认即**绕行**
         # 缓存（读+写双侧闭合）——fail-closed，宁可不用缓存也不串味。
@@ -1631,17 +1737,18 @@ class MdCGOS(MdCG):
         """
         phash = _sig(content)
         with FileLock(self.inbox_log, strict=True):
+            # 增量对账（issue #32）：原实现每条全量 read_jsonl(inbox) +
+            # read_jsonl(decisions)（锁内 O(M+D)/条、批量 O(M²)，旧格式行
+            # 逐条重算 sha1）；改走 stat 尾部增量索引——文件序与覆盖语义
+            # 与原全量扫描逐位一致（同 phash 按文件序取，已裁决优先 break）。
+            ph_idx = self._inbox_phash_index()
             st = self._pid_status()
             dup = None
-            for r in read_jsonl(self.inbox_log):
-                # 存量记录无 payload_hash 字段 → 现算兼容（对账覆盖旧账）
-                rh = r.get("payload_hash") or _sig(r.get("content") or "")
-                if rh != phash:
-                    continue
-                s = st.get(r.get("pid")) or {}
-                dup = {"pid": r.get("pid"),
+            for pid, nid in ph_idx.get(phash, ()):
+                s = st.get(pid) or {}
+                dup = {"pid": pid,
                        "status": s.get("status") or "pending",
-                       "node_id": r.get("id")}
+                       "node_id": nid}
                 if dup["status"] in ("accepted", "rejected"):
                     break          # 已裁决的最有信息量，优先返回
             if dup:
@@ -1675,14 +1782,135 @@ class MdCGOS(MdCG):
                     "dup_of": None, "dup_status": None}
         return pid
 
-# 生效条件：当 self.decisions_log 可被 read_jsonl 读取时，仅 r.get("pid") 为真值的记录写入 st[r["pid"]]，后出现记录覆盖先出现记录，返回 pid → 最新一条裁决记录的字典；
+# 生效条件：stat decisions_log 失败（OSError）时把 _pid_st 置空 dict、两扫描键置 -1 并返回空 dict；size 与 mtime_ns 均与缓存键一致时直接返回 _pid_st（零解析）；缓存键为 -1（首装）或当前 size 小于已扫描偏移（外部非合作重写/回退）时经 read_jsonl_tail(path, 0) 全量重建 _pid_st，否则经 read_jsonl_tail 从已扫描偏移起增量并入，逐条把 r.get("pid") 为真值的记录写入 _pid_st（后并入覆盖先并入）；水位存 read_jsonl_tail 返回的真实 EOF 偏移（end 为 None 时回落 stat size），mtime_ns 存读前 stat 值，返回 _pid_st。
     def _pid_status(self):
-        """pid → 最新一条裁决记录（多轮再审批时取最后一轮）。"""
-        st = {}
-        for r in read_jsonl(self.decisions_log):
+        """pid → 最新一条裁决记录（多轮再审批时取最后一轮）。
+
+        增量缓存（issue #32）：原实现每调用全量 read_jsonl(decisions_log)
+        （json.loads 逐条），propose 对账每条 O(D)、批量 O(M×D)。append-only
+        契约下改为 stat 尾部对账：size/mtime 未变零解析；size 增长只解析
+        新增字节；size 回退/首装全量重建兜底。mtime 单变 size 不变（touch
+        类）走增量窗口=0 行，结果不变。跨进程 append 由 stat 自动并入。
+        水位口径（竞态修复）：存 read_jsonl_tail 返回的**真实 EOF 偏移**，
+        不存读前 stat 的 size——stat→read 窗口内的并发 append 本轮已并入，
+        水位偏小会让下一轮重读同一段（本缓存是 dict 后写覆盖不受损，但与
+        列表型缓存共用同一口径）。
+        边界（与检索读缓存同款诚实声明）：外部**非 append 形态**重写文件
+        （同 size 改内容）不在合作写者协议内，不保证可见。
+        """
+        try:
+            sti = os.stat(self.decisions_log)
+            size, mtime = sti.st_size, sti.st_mtime_ns
+        except OSError:
+            self._pid_st, self._pid_st_size, self._pid_st_mtime = {}, -1, -1
+            return self._pid_st
+        if size == self._pid_st_size and mtime == self._pid_st_mtime:
+            return self._pid_st                    # 无新内容（零解析）
+        full = self._pid_st_size < 0 or size < self._pid_st_size
+        if full:
+            self._pid_st = {}
+        src, end = read_jsonl_tail(self.decisions_log,
+                                   0 if full else self._pid_st_size)
+        for r in src:
             if r.get("pid"):
-                st[r["pid"]] = r
-        return st
+                self._pid_st[r["pid"]] = r
+        self._pid_st_size = size if end is None else end
+        self._pid_st_mtime = mtime
+        return self._pid_st
+
+# 生效条件：stat inbox_log 失败（OSError）时把 _inbox_idx 置空 dict、两扫描键置 -1 并返回空 dict；size 与 mtime_ns 均与缓存键一致时直接返回 _inbox_idx（零解析）；缓存键为 -1（首装）或当前 size 小于已扫描偏移时经 read_jsonl_tail(path, 0) 全量重建，否则经 read_jsonl_tail 增量并入，逐条以 r.get("payload_hash") 或（缺键时）_sig(r.get("content") or "") 为 ph 把 (r.get("pid"), r.get("id")) 追加进 _inbox_idx[ph]（文件序）；水位存 read_jsonl_tail 返回的真实 EOF 偏移（end 为 None 时回落 stat size），mtime_ns 存读前 stat 值，返回 _inbox_idx。
+    def _inbox_phash_index(self):
+        """inbox 的 phash → [(pid, node_id)]（文件序）增量索引（propose 对账用）。
+
+        与 _pid_status 同款 stat 尾部对账（issue #32）。存量旧格式行
+        （无 payload_hash）在**并入时**现算一次 _sig（此后常驻，不再
+        每条 propose 重算——旧路径每条重算 M 次 sha1）。
+        水位口径（竞态修复，同 _pid_status）：存真实 EOF 偏移，不存读前
+        stat 的 size——窗口内并发 append 不得在下轮重复并入。
+        """
+        try:
+            sti = os.stat(self.inbox_log)
+            size, mtime = sti.st_size, sti.st_mtime_ns
+        except OSError:
+            self._inbox_idx, self._inbox_idx_size, self._inbox_idx_mtime = \
+                {}, -1, -1
+            return self._inbox_idx
+        if size == self._inbox_idx_size and mtime == self._inbox_idx_mtime:
+            return self._inbox_idx                    # 无新内容（零解析）
+        full = self._inbox_idx_size < 0 or size < self._inbox_idx_size
+        if full:
+            self._inbox_idx = {}
+        src, end = read_jsonl_tail(self.inbox_log,
+                                   0 if full else self._inbox_idx_size)
+        for r in src:
+            ph = r.get("payload_hash") or _sig(r.get("content") or "")
+            self._inbox_idx.setdefault(ph, []).append(
+                (r.get("pid"), r.get("id")))
+        self._inbox_idx_size = size if end is None else end
+        self._inbox_idx_mtime = mtime
+        return self._inbox_idx
+
+# 生效条件：stat inbox_log 失败（OSError）时把 _inbox_recs 置空列表、两扫描键置 -1 并返回它；size 与 mtime_ns 均与缓存键一致时直接返回 _inbox_recs（零解析）；缓存键为 -1（首装）或当前 size 小于已扫描偏移时以 read_jsonl_tail(path, 0) 全量重建，否则以 read_jsonl_tail(offset) 结果 extend 增量并入；水位存 read_jsonl_tail 返回的真实 EOF 偏移（end 为 None 时回落 stat size），mtime_ns 存读前 stat 值，返回 _inbox_recs（内部缓存，调用方只读不得变更）。
+    def _inbox_records(self):
+        """inbox 全记录（文件序）增量缓存——review 治理面单次调用共用一次解析。
+
+        与 _pid_status 同款 stat 尾部对账（issue #35）：原 review_decide 线性
+        扫 inbox 找 pid、_cascade_dedup 再全量读一遍（2 遍/调用）；改走本
+        缓存后稳态零解析，调用方在内存列表上线性扫（万条 ~1ms 级，无 IO）。
+        水位口径（竞态修复）：存 read_jsonl_tail 返回的**真实 EOF 偏移**，
+        不存读前 stat 的 size——stat→read 窗口内的并发 append 本轮已并入，
+        水位偏小会让下一轮 extend 重读同一条（review_list 重复 pid、
+        _cascade_dedup 连写两条 reject），且稳态 size 只增、永不自愈。
+        """
+        try:
+            sti = os.stat(self.inbox_log)
+            size, mtime = sti.st_size, sti.st_mtime_ns
+        except OSError:
+            self._inbox_recs, self._inbox_recs_size, self._inbox_recs_mtime = \
+                [], -1, -1
+            return self._inbox_recs
+        if size == self._inbox_recs_size and mtime == self._inbox_recs_mtime:
+            return self._inbox_recs                    # 无新内容（零解析）
+        full = self._inbox_recs_size < 0 or size < self._inbox_recs_size
+        if full:
+            self._inbox_recs = []
+        src, end = read_jsonl_tail(self.inbox_log,
+                                   0 if full else self._inbox_recs_size)
+        self._inbox_recs.extend(src)
+        self._inbox_recs_size = size if end is None else end
+        self._inbox_recs_mtime = mtime
+        return self._inbox_recs
+
+# 生效条件：stat decisions_log 失败（OSError）时把 _dec_recs 置空列表、两扫描键置 -1 并返回它；size 与 mtime_ns 均与缓存键一致时直接返回 _dec_recs（零解析）；缓存键为 -1（首装）或当前 size 小于已扫描偏移时以 read_jsonl_tail(path, 0) 全量重建，否则以 read_jsonl_tail(offset) 结果 extend 增量并入；水位存 read_jsonl_tail 返回的真实 EOF 偏移（end 为 None 时回落 stat size），mtime_ns 存读前 stat 值，返回 _dec_recs（内部缓存，调用方只读不得变更）。
+    def _decisions_records(self):
+        """decisions 全记录（文件序）增量缓存——review 治理面单次调用共用一次解析。
+
+        issue #35：原 review_stats 全量读 decisions 统计、verify_review_record
+        全量线性扫找单条 pid（每调用 1 遍整文件 json.loads）；改走本缓存后
+        稳态零解析，调用方内存线性扫。与 _pid_status（pid→最新）互补：
+        本缓存保全量记录（多轮裁决历史、by_decision 统计口径）。
+        水位口径（竞态修复，同 _inbox_records）：存真实 EOF 偏移——窗口内
+        并发 append 不得在下一轮重复 extend（review_stats 计数虚高/翻倍、
+        永不自愈）。
+        """
+        try:
+            sti = os.stat(self.decisions_log)
+            size, mtime = sti.st_size, sti.st_mtime_ns
+        except OSError:
+            self._dec_recs, self._dec_recs_size, self._dec_recs_mtime = \
+                [], -1, -1
+            return self._dec_recs
+        if size == self._dec_recs_size and mtime == self._dec_recs_mtime:
+            return self._dec_recs                    # 无新内容（零解析）
+        full = self._dec_recs_size < 0 or size < self._dec_recs_size
+        if full:
+            self._dec_recs = []
+        src, end = read_jsonl_tail(self.decisions_log,
+                                   0 if full else self._dec_recs_size)
+        self._dec_recs.extend(src)
+        self._dec_recs_size = size if end is None else end
+        self._dec_recs_mtime = mtime
+        return self._dec_recs
 
 # 生效条件：实例已构建（内部先读 _pid_status()）；返回其 status ∈ TERMINAL_DECISION_STATUS（accepted/rejected/noop）的 pid 集合，status=="needs_reapproval" 视为未关闭、不计入；
     def _closed_pids(self):
@@ -1695,7 +1923,9 @@ class MdCGOS(MdCG):
         """待审核候选（含被红队打回、待再审批的条目）。"""
         st = self._pid_status()
         out = []
-        for r in read_jsonl(self.inbox_log):
+        # issue #35：走全记录增量缓存（稳态零解析）——review_stats 链路单次
+        # 调用共用一次解析；rec=dict(r) 复制，不改内部缓存。
+        for r in self._inbox_records():
             s = st.get(r.get("pid")) or {}
             if s.get("status") in TERMINAL_DECISION_STATUS:
                 continue
@@ -1716,7 +1946,9 @@ class MdCGOS(MdCG):
         视图复用 review_list/_closed_pids，避免在此复制第二份终态判定逻辑。
         """
         by = {}
-        for r in read_jsonl(self.decisions_log):
+        # issue #35：走全记录增量缓存（稳态零解析）——原每次全量逐行
+        # json.loads，与 review_list/_closed_pids 链路重复解析同一文件。
+        for r in self._decisions_records():
             d = str(r.get("decision") or "").strip() or "unknown"
             by[d] = by.get(d, 0) + 1
         return {"records": sum(by.values()), "by_decision": by,
@@ -1845,7 +2077,9 @@ class MdCGOS(MdCG):
         closed = []
         with FileLock(self.decisions_log, strict=True):
             st = self._pid_status()
-            for r in read_jsonl(self.inbox_log):
+            # issue #35：走全记录增量缓存（稳态零解析）——原与 review_decide
+            # 开头的找 pid 扫描重复全量读同一 inbox（2 遍/调用）。
+            for r in self._inbox_records():
                 bpid = r.get("pid")
                 if not bpid or bpid == pid or bpid in st:
                     continue     # 自己 / 已有裁决记录（含 needs_reapproval）跳过
@@ -1896,7 +2130,9 @@ class MdCGOS(MdCG):
             return {"ok": False, "error": "node_not_found"}
         fm = node.get("frontmatter") or {}
         pid, rnd = fm.get("pid"), fm.get("round")
-        src = next((r for r in read_jsonl(self.decisions_log)
+        # issue #35：走全记录增量缓存后内存线性扫（稳态零解析）——原每次
+        # 全量逐行 json.loads 整份 decisions 只为找一条 pid+round。
+        src = next((r for r in self._decisions_records()
                     if r.get("pid") == pid
                     and int(r.get("round") or 0) == int(rnd or 0)), None)
         if not src:
@@ -1911,10 +2147,11 @@ class MdCGOS(MdCG):
                 "verify_hash": src.get("verify_hash"),
                 "source": "hippocampus/decisions.jsonl"}
 
-# 生效条件：decision 须为 DECISION_ACTIONS（"accept"/"reject"/"edit"/"merge"/"noop"）之一（否则 raise ValueError），inbox_log 中须有 pid 匹配记录（否则 {'ok': False, 'error': 'pid_not_found'}），且 pid 不在 self._closed_pids() 中（否则 'already_decided'）；edits 为真值且含 "verify"、或 redteam 为真值且含 "verify" 时返回 'verify_readonly'；last_status=="needs_reapproval" 时须 redteam.verdict 归一化为 "pass" 且 round_no>last_round（否则 'reapproval_required' / 'round_not_advanced'）；rt_v=="reject" 或（decision=="reject" 且 rt_issues 非空）时记 needs_reapproval 不落节点；decision=="accept" 且 rt_v 为空且 _redteam_required() 为真时返回 'redteam_required'；其余 accept/edit 按 item（edit 时用 edits.get 覆盖 content/tags/layer）add+flush 落节点，merge 须 merge_into 或 item.extra.merge_into 指向的节点存在（否则 'merge_target_not_found'）后追加内容并 rebuild_index，reject 与 noop 只记裁决（status 分别为 "rejected"/"noop"）；最后统一 _record_decision + _cascade_dedup + flush 后返回 result。
+# 生效条件：decision 须为 DECISION_ACTIONS（"accept"/"reject"/"edit"/"merge"/"noop"）之一（否则 raise ValueError），inbox_log 中须有 pid 匹配记录（否则 {'ok': False, 'error': 'pid_not_found'}），且 pid 不在 self._closed_pids() 中（否则 'already_decided'）；edits 为真值且含 "verify"、或 redteam 为真值且含 "verify" 时返回 'verify_readonly'；last_status=="needs_reapproval" 时须 redteam.verdict 归一化为 "pass" 且 round_no>last_round（否则 'reapproval_required' / 'round_not_advanced'）；rt_v=="reject" 或（decision=="reject" 且 rt_issues 非空）时记 needs_reapproval 不落节点；decision=="accept" 且 rt_v 为空且 _redteam_required() 为真时返回 'redteam_required'；其余 accept/edit 按 item（edit 时用 edits.get 覆盖 content/tags/layer）add+flush 落节点，merge 须 merge_into 或 item.extra.merge_into 指向的节点存在（否则 'merge_target_not_found'），且写入前经与 add 同款双闸（N131，2026-09-25：principal 在位先 require_layer_write(目标层, 目标敏感度)——与 MdCGSecure.add 同序同错型；再 protect.guard_write(override=override)——self/anchor 层、immutable 标记，拒绝抛 ProtectionError/AccessDenied 且提案留 pending 不落库）后追加内容并定向索引 upsert（_node_entry 同源条目写入 index/_dirty）+flush，reject 与 noop 只记裁决（status 分别为 "rejected"/"noop"）；最后统一 _record_decision + _cascade_dedup + flush 后返回 result。
     def review_decide(self, pid: str, decision: str, edits: dict = None,
                       merge_into: str = None, reason: str = "",
-                      redteam: dict = None, issues=None):
+                      redteam: dict = None, issues=None,
+                      override: bool = False):
         """审核裁决：accept / reject / edit / merge / noop。
 
         accept  → 按 inbox 原样写入
@@ -1936,7 +2173,9 @@ class MdCGOS(MdCG):
         """
         if decision not in DECISION_ACTIONS:
             raise ValueError(f"未知裁决：{decision}")
-        item = next((r for r in read_jsonl(self.inbox_log)
+        # issue #35：走全记录增量缓存后内存线性扫（稳态零解析）——原每次
+        # 全量逐行 json.loads 整份 inbox 只为找一条 pid。
+        item = next((r for r in self._inbox_records()
                      if r.get("pid") == pid), None)
         if not item:
             return {"ok": False, "error": "pid_not_found"}
@@ -2003,13 +2242,24 @@ 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，
             # 未达 autoflush(64) 阈值时进程退出即永久丢失——裁决进程（review_cli /
             # MCP op=review）通常只写 1~2 条，不 flush 则「节点在盘上但索引无条目」，
             # 其他进程与重载后的长驻进程都检索不到，只能靠某次全量 rebuild 偶然救回。
-            # merge 分支绕开 add 直写节点文件，故其收尾同为索引重建（同因不同法）。
+            # merge 分支同样直写节点文件，其收尾已改为同款定向 upsert+flush
+            # （issue #34，见 else 分支注释）。
             self.flush()
             result.update(ok=True, node_id=nid)
         else:  # merge
@@ -2017,6 +2267,22 @@ class MdCGOS(MdCG):
             tgt = self.get(target) if target else None
             if not tgt:
                 return {"ok": False, "error": "merge_target_not_found"}
+            # 写保护（N131，2026-09-25）：merge = 对目标节点的一次**覆写**
+            # （_write_node 追加正文），与 accept/edit 的 add 落点同受写保护——
+            # 此前直写绕过双闸，orchestr forbidden「anchor/self/goals/knowledge
+            # 层」被打穿。与 add 同序同错型：principal 层写闸在先（对照
+            # MdCGSecure.add），引擎级 guard_write 在后（对照基类 add :1311）；
+            # 闸必须在 _record_decision 之前抛出——审计节点写入本就在其
+            # try/except 内，闸放那里会被吞成 record_error 形同虚设。
+            _p = getattr(self, "principal", None)
+            if _p is not None and hasattr(_p, "require_layer_write"):
+                _e = (self.index.get("nodes") or {}).get(target) or {}
+                _p.require_layer_write(
+                    _e.get("layer") or tgt["frontmatter"].get("layer")
+                    or tgt["path"].split("/")[0],
+                    _e.get("sensitivity") or DEFAULT_SENSITIVITY)
+            protect.guard_write(self, target, override=override,
+                                actor=getattr(self, "actor", None))
             fm = dict(tgt["frontmatter"])
             merged_content = (tgt["content"].rstrip() + "\n\n" +
                               item["content"].strip() + "\n")
@@ -2028,7 +2294,24 @@ class MdCGOS(MdCG):
             fm["non_applicable_conditions"] = neg
             self._write_node(target, os.path.join(self.root, tgt["path"]),
                              fm, merged_content)
-            self.rebuild_index()
+            # 定向索引 upsert（issue #34）：merge 只改一个目标节点，原
+            # rebuild_index 收尾是 _scan_nodes 全库 O(N) 逐文件扫描
+            # （1500 池实测 ~97-247ms/次），与 accept/edit 的 add+flush
+            # O(1) 增量收尾不对称。改为：单文件条目重算（_node_entry 与
+            # _scan_nodes 同源唯一真源——字段集零漂移）+ 内存索引/增量
+            # 日志定向写入 + flush。不走 _stage：目标已在索引，_stage 会
+            # 虚增 bucket 计数；merge 不改 tags/目录，bucket 不变。
+            # _dirty 置数同时推进 readcache 代际（写盘后同实例不陈旧）。
+            try:
+                tp = os.path.join(self.root, tgt["path"])
+                with open(tp, encoding="utf-8") as f:
+                    fm2, c2 = nodefile.loads(f.read())
+                e2 = self._node_entry(tp, tgt["path"].split("/")[0], fm2, c2)
+                self.index["nodes"][target] = e2
+                self._dirty[target] = e2
+            except OSError:
+                pass    # 单文件重读失败（极罕见）：条目留旧值，下次 rebuild 对账
+            self.flush()
             result.update(ok=True, node_id=target)
 
         # status 映射统一出口：reject→"rejected"、noop→"noop"（同为终态，见
@@ -2074,7 +2357,7 @@ class MdCGOS(MdCG):
         h = _sig(content or "", 16)
         dst = os.path.join(self.trash_dir, f"{node_id}.md")
         try:
-            os.replace(src, dst)
+            publish(src, dst)
         except OSError as exc:
             return {"ok": False, "error": str(exc)}
         append_jsonl(self.deletions_log, {"t": time.time(), "id": node_id,
@@ -2098,7 +2381,7 @@ class MdCGOS(MdCG):
     def is_tombstoned(self, node_id: str):
         return any(r.get("id") == node_id for r in read_jsonl(self.deletions_log))
 
-# 生效条件：当 node_id 传入时，若 deletions_log 中存在该 id 且 force=False 返回 tombstoned 拒绝；否则检查 trash_dir/{node_id}.md，os.path.exists 为 False 返回 not_in_trash；可打开则读取并 self.add(override=True...) 恢复、移除 trash 源、audit，返回 ok True/id/forced=bool(force)；
+# 生效条件：当 node_id 传入时，若 deletions_log 中存在该 id 且 force=False 返回 tombstoned 拒绝；否则检查 trash_dir/{node_id}.md，os.path.exists 为 False 返回 not_in_trash；可打开则读取并以 add(override=True) + trash frontmatter 元数据全量透传（显式形参逐项传，其余键经 **extra 回写；lifecycle_state 仅在 active→该态合法迁移时透传）恢复、移除 trash 源、audit，返回 ok True/id/forced=bool(force)；
     def restore(self, node_id: str, force: bool = False):
         """恢复：若在删除清单中且未 force → 拒绝（恢复时删除检查）。"""
         tomb = [r for r in read_jsonl(self.deletions_log) if r.get("id") == node_id]
@@ -2111,13 +2394,52 @@ class MdCGOS(MdCG):
         with open(src, encoding="utf-8") as f:
             fm, content = nodefile.loads(f.read())
         layer = fm.get("layer", "knowledge")
-        tags = fm.get("tags") or []
-        self.add(node_id, content, layer=layer, tags=tags, override=True,
-                 sensitivity=fm.get("sensitivity"),
+        # 恢复 = 原样放回：add 是**全量重建 fm**，只传个位数字段会把 edges/
+        # depends_on/验证态/生命周期/created_at/语义摘要/证据计数等元数据永久
+        # 抹掉（下方 os.remove 删 trash 源后不可再恢复）。故 add 显式形参对应
+        # 的键逐项透传；其余键（created_at/evidence_*/protected/temporal/
+        # derived_relation…）经 **extra 回写（fm.update 通道覆盖默认值）。
+        # _skip 必须覆盖 add 全部显式形参名——**extra 撞形参名直接 TypeError。
+        _skip = ("id", "layer", "tags", "condition_space", "importance",
+                 "confidence", "verification_basis", "edges",
+                 "non_applicable_conditions", "derived_from", "relation",
+                 "semantic", "depends_on", "valid_from", "valid_until",
+                 "effective_from", "effective_until", "believed_at",
+                 "verification_state", "override", "consistency",
+                 "on_conflict", "state", "sensitivity", "derived_relation",
+                 "content", "node_id")
+        _extra = {k: v for k, v in fm.items()
+                  if k not in _skip and v not in (None, "", [], {})}
+        # 生命周期状态走迁移裁决：restore 时节点已摘索引、按新节点（active）
+        # 起判，active→archived 跳级会被拒——不可迁移时不透传（落 active），
+        # 不让罕见 corner case 阻断恢复主流程。
+        from . import lifecycle as _lc
+        from . import provenance as _prov
+        _ls = fm.get(_lc.STATE_FIELD)
+        if _ls and _lc.can_transition("active", _ls):
+            _extra[_lc.STATE_FIELD] = _ls
+        # 验证态同样按新节点（unverified）起判：非法值透传会被 require_transition
+        # 直接拒掉，过滤为 None（落 unverified）保证恢复不被脏数据卡死。
+        _vs = fm.get("verification_state")
+        self.add(node_id, content, layer=layer, tags=fm.get("tags") or [],
+                 override=True, sensitivity=fm.get("sensitivity"),
                  condition_space=fm.get("condition_space"),
                  importance=fm.get("importance", 0.5),
                  confidence=fm.get("confidence", 0.6),
-                 verification_basis=fm.get("verification_basis"))
+                 verification_basis=fm.get("verification_basis"),
+                 edges=fm.get("edges"),
+                 non_applicable_conditions=fm.get("non_applicable_conditions"),
+                 semantic=fm.get("semantic"),
+                 depends_on=fm.get("depends_on"),
+                 valid_from=fm.get("valid_from"),
+                 valid_until=fm.get("valid_until"),
+                 effective_from=fm.get("effective_from"),
+                 effective_until=fm.get("effective_until"),
+                 believed_at=fm.get("believed_at"),
+                 verification_state=(_vs if _vs in trust.STATES else None),
+                 derived_from=fm.get("derived_from"),
+                 relation=fm.get("derived_relation") or _prov.DEFAULT_RELATION,
+                 **_extra)
         os.remove(src)
         self._audit("restore", node_id, forced=bool(force))
         return {"ok": True, "id": node_id, "forced": bool(force)}
@@ -2365,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",
@@ -2410,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,
@@ -2421,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
@@ -3529,10 +3858,10 @@ class MdCGSecure(MdCGOS):
         self._index_sensitivity(nid, sens)
         return nid
 
-# 生效条件：sens 取 sensitivity or DEFAULT_SENSITIVITY，先 principal.require_layer_write(kw.get("layer") or "contextual", sens)，再转 super().propose(node_id, content, sensitivity=sens) 并返回其结果。
+# 生效条件：sens 取 sensitivity or DEFAULT_SENSITIVITY，先 principal.require_layer_write(kw.get("layer", "knowledge"), sens)（缺省与基类 MdCGOS.propose 的 layer="knowledge" 一致——此前误用 or "contextual" 导致校验层与落盘层错位：knowledge-only 身份被误拒 / contextual-only 身份入队成死提案，2026-09-25 缺陷 #5），再转 super().propose(node_id, content, sensitivity=sens) 并返回其结果。
     def propose(self, node_id: str, content: str, sensitivity: str = None, **kw):
         sens = sensitivity or DEFAULT_SENSITIVITY
-        self.principal.require_layer_write(kw.get("layer") or "contextual", sens)
+        self.principal.require_layer_write(kw.get("layer", "knowledge"), sens)
         return super().propose(node_id, content, sensitivity=sens, **kw)
 
 # 生效条件：sens 取 sensitivity or DEFAULT_SENSITIVITY，先 _rank(sens) 并 principal.require_layer_write("goals", sens)，再转 super().add_goal，最后按 gid 调 _index_sensitivity 并返回 gid。
@@ -3549,6 +3878,16 @@ class MdCGSecure(MdCGOS):
         self.principal.require_layer_write("goals", DEFAULT_SENSITIVITY)
         return super().set_goal_status(node_id, status)
 
+# 生效条件：verdict（转 str 去空白 lower）为 "falsified" 且索引中存在 node_id 条目时，先取该条目 layer 与 sensitivity（缺省回落 DEFAULT_SENSITIVITY）调 principal.require_layer_write——falsified 删除 = 对原节点层的一次删除写（N130，2026-09-25：verify 角色 layers_allow 本就只含 rejected/contextual，不得改/删被验证内容所在层，tokens.py verify spec forbidden 显式列明），与 add/add_rejected 同一闸口；随后把 override 原样转 super().verify（受保护节点的 guard_forget 快照留痕在基类 falsified 分支内）。verdict 非 falsified 或索引无此节点时不加闸直接透传（not_found 语义由基类维持）。
+    def verify(self, node_id: str, evidence: str, verdict: str,
+               override: bool = False):
+        if str(verdict or "").strip().lower() == "falsified":
+            e = (self.index.get("nodes") or {}).get(node_id)
+            if e is not None:
+                self.principal.require_layer_write(
+                    e.get("layer"), e.get("sensitivity") or DEFAULT_SENSITIVITY)
+        return super().verify(node_id, evidence, verdict, override=override)
+
 # 生效条件：sens 取 sensitivity or DEFAULT_SENSITIVITY，经 _rank(sens) 与 principal.require_write(sens) 后把 m 基于 meta 复制并 setdefault tenant/session、harness 与 unit 为真值时补入，再强制 m["sensitivity"]=sens，text 经 _seal_content("_recent", text, sens) 后连 tags=tags 一起转 super().remember_event（window 为 None 时不传该参，否则带上 window）。
     def remember_event(self, role: str, text: str, tags=None, meta=None,
                        window=None, sensitivity: str = None):
@@ -3571,15 +3910,57 @@ class MdCGSecure(MdCGOS):
     # ---------- 读：密级过滤 ----------
 
 # 生效条件：e 的 sensitivity 为假值时先 _read 回填为 fm 的 sensitivity or DEFAULT_SENSITIVITY，再以 self.principal.allows(sens) 的布尔结果为准。
-    def _readable(self, e) -> bool:
+    def _readable(self, e, session=None) -> bool:
+        """读可见性单点判定：clearance × sensitivity（密级）∧ 会话绑定（归属）。
+
+        会话绑定（issue #35 设计定稿 2026-09-23，使用者拍板）：
+          · public / internal = 跨会话共享档——任何通过 clearance 的会话可见；
+          · private / secret  = 会话绑定档——仅归属会话（frontmatter.session）
+            可见；can_admin（设计者，需整体判断）豁免。
+          · 绑定档无归属（存量节点）：fail-closed，仅设计者可见（宁可少读，
+            不可越权——与下方 sensitivity 回填同款纪律）。
+          · 查询侧 session 参数（含 "*"）不参与绑定档判定——身份不可自报；
+            共享档本就跨会话可见，故该参数在 Secure 层不再改变任何可见性。
+        """
         sens = e.get("sensitivity")
         if not sens:
-            # 索引可能被「无密级上下文」的实例重建而丢掉该字段：按盘上真相回填，
-            # fail-closed（宁可少读，不可越权）。
+            # 索引可能被「无密级上下文」的实例重建而丢掉该字段：按盘上真相回填。
+            # V21-2（批次 34，外部报告）：`_read` 失败（返回 None 头）时**不得**
+            # 回落宽松默认——那会把受保护节点判成 internal 对平级可见
+            # （fail-open）。密级未知 = 按最高档 secret 处理（fail-closed：
+            # 宁可误禁，不可越权）。
             fm, _c = self._read(e)
-            sens = (fm or {}).get("sensitivity") or DEFAULT_SENSITIVITY
+            if fm is None:
+                sens = "secret"
+            else:
+                sens = fm.get("sensitivity") or DEFAULT_SENSITIVITY
             e["sensitivity"] = sens
-        return self.principal.allows(sens)
+        # restricted = 错误处置标记（批次 28 分型，使用者裁定）：不走纯密级
+        # rank——密级底线 internal ∧ 错误处置链路角色（designer/orchestr/
+        # verify，或 can_admin）。平级（record/worker）与下游（output/guest）
+        # 限读，处置链路必读——故意的冲突设计在此消解。
+        if sens == "restricted":
+            from .security import can_read_restricted
+            return (self.principal.allows("internal")
+                    and can_read_restricted(self.principal))
+        if not self.principal.allows(sens):
+            return False
+        if _rank(sens) >= _rank("private"):
+            if self.principal.can_admin:
+                return True
+            # 绑定档判定**恒用 principal.session（服务端身份，不可伪造）**——
+            # 查询侧 session 参数（含 "*"）不构成豁免：调用方自报的会话不能
+            # 越过身份看别人的 private（与 _attribution「env 固定会话时请求
+            # 声明一律忽略」同款纪律）。
+            nsess = e.get("session")
+            return bool(nsess) and nsess == self.principal.session
+        return True
+
+# 生效条件：nid 在 index["nodes"] 中有条目且 _readable(e) 为真时返回 True，否则（无条目/不可见）返回 False；作为 chain.adjacency 的读隔离谓词（cg._chain_visible）被消费——关系链面（causal_chain/explain_chain/causal_path/检索 chain 路 provenance 经 expand_from_seeds）由此单点隔离，不可见节点的出边、边条件文本与下游拓扑不再进入链展开；实例身份稳定（_readable 绑定档恒用 principal.session），与 adjacency 缓存无串台。
+    def _chain_visible(self, nid) -> bool:
+        """关系链可见性谓词（chain.adjacency 读隔离闸，2026-09-25）。"""
+        e = (self.index.get("nodes") or {}).get(nid)
+        return bool(e) and self._readable(e)
 
 # 生效条件：先以 limit=None 取 super().list_goals(status=status) 的全量，再只保留 index 中 _readable(e) 为真的目标，limit 为真值时返回 keep[:limit]、否则返回全部 keep。
     def list_goals(self, status=None, limit=None):
@@ -3604,6 +3985,13 @@ class MdCGSecure(MdCGOS):
                 continue
             if not self.principal.allows(m.get("sensitivity") or DEFAULT_SENSITIVITY):
                 continue
+            # 会话绑定档（private/secret）：近期事件同口径——仅归属会话，
+            # 设计者豁免（issue #35 设计定稿，与 _readable 一致）。
+            msens = m.get("sensitivity") or DEFAULT_SENSITIVITY
+            if (_rank(msens) >= _rank("private")
+                    and not self.principal.can_admin
+                    and m.get("session") != self.principal.session):
+                continue
             if crypto.is_encrypted(r.get("text")):
                 t = self._open_content("_recent", m, r["text"])
                 if t is None:
@@ -3618,18 +4006,18 @@ class MdCGSecure(MdCGOS):
         self.principal.require_admin("clear_recent")
         return super().clear_recent()
 
-# 生效条件：在 super()._candidates(layer=layer, roles=roles, include_work=include_work, session=session, branch=branch, validity=validity, start_time=start_time, end_time=end_time, start_operator=start_operator, end_operator=end_operator, time_axis=time_axis, view=view) 的结果上，只保留 self._readable(e) 为真的条目（时间算子在父类候选层**单点已过滤**，此处只叠加读可见性、不重复判一次——重复判会让 dropped 计数与 meta 脱钩）。
+# 生效条件：在 super()._candidates(layer=layer, roles=roles, include_work=include_work, session=None（会话判定上收本层：基类硬等值过滤会误剔共享档的他人节点）, branch=branch, ...) 的结果上，只保留 self._readable(e, session=session) 为真的条目（clearance × sensitivity ∧ 会话绑定，见 _readable；时间算子在父类候选层单点已过滤，此处只叠加读可见性）。
     def _candidates(self, layer=None, roles=None, include_work=False,
                     session=None, branch=None, validity=None,
                     start_time=None, end_time=None, start_operator=None,
                     end_operator=None, time_axis=None, view=None):
         out = super()._candidates(layer=layer, roles=roles, include_work=include_work,
-                                  session=session, branch=branch, validity=validity,
+                                  session=None, branch=branch, validity=validity,
                                   start_time=start_time, end_time=end_time,
                                   start_operator=start_operator,
                                   end_operator=end_operator, time_axis=time_axis,
                                   view=view)
-        return [e for e in out if self._readable(e)]
+        return [e for e in out if self._readable(e, session=session)]
 
 # 生效条件：在 super()._neg_coverage(terms) 的结果上，只保留 self._readable(e) 为真的条目。
     def _neg_coverage(self, terms):
@@ -3667,13 +4055,11 @@ class MdCGSecure(MdCGOS):
         keep = []
         for r in res:
             e = self.index["nodes"].get(r[0]["id"], r[0])
-            if not self._readable(e):
-                continue
-            # 会话归属同为候选资格：图扩展会把**别的会话**的节点顺着边带回来，
-            # 绕过 _candidates 的会话过滤 → 自动召回照样串台。故与 validity/view
-            # 一并在此兜底（"*" = 跨会话视图，不过滤）。
-            if session and session != "*" and e.get("session") != session:
+            if not self._readable(e, session=session):
                 continue
+            # 会话归属兜底已并入 _readable（session 传参）：共享档跨会话可见、
+            # 绑定档（private/secret）按归属会话判定（图扩展绕过 _candidates
+            # 的串台路径由它一并挡住，与 validity/view 同层兜底）。
             if view is not None and not roleviews.matches(e, view):
                 continue
             if validity and trust.is_expired(e, now=now):