@furongjun1999/dsh-memory 0.6.1 → 0.7.1

package/md_cg/mdcos.py

@@ -20,6 +20,7 @@ from __future__ import annotations
 
 import hashlib
 import json
+import math
 import os
 import re
 import time
@@ -30,11 +31,13 @@ from .mdcg import (MdCG, expand_query_terms, bigrams, normalize_en, STATE_ACCEPT
                    TIER_BUCKET_SCAN, TIER_GLOBAL_LIKE, TIER_GLOBAL_SCAN,
                    GLOBAL_CAP, expand_query_terms_weighted,
                    expand_query_terms_llm, en_zh_bigrams, semantic_on,
-                   cut_by_relevance, apply_retrieval_gates, NEG_ROUTE_LAYERS)
+                   cut_by_relevance, apply_retrieval_gates, NEG_ROUTE_LAYERS,
+                   # P2-3（§5.4）：六要素后两行索引键的召回判据单点（mdcg 侧）
+                   index_key_hits, boundary_mark)
 from . import (nodefile, routing, chain, subgraph, forgetting, protect,
                identity, consistency, metacognition, crypto, sustain,
                self_state, predict, evolution, weights, pooling,
-               writelimit, reach, trust, roleviews)
+               writelimit, reach, trust, roleviews, autonomy_modes)
 from .fsutil import (FileLock, atomic_write, append_jsonl, read_jsonl,
                      read_jsonl_tail, count_jsonl, publish)
 from .security import (Principal, TenantRegistry, AccessDenied,
@@ -64,6 +67,37 @@ DEFAULT_BUDGET = 1200  # recall 默认 token 预算
 # 0 = 关闭截断，回到"超大一律跳过"的旧行为。
 DEFAULT_MAX_ITEM_TOKENS = 250
 
+# ---- P3-temporal：时间路的核与口径（设计稿 §6.3，裁定 12）-------------------
+# 核**必须**来自唯一权威 `md_cg/whitebox_kb/aeis_core/time_core.py::cred_factor`
+# （该模块 docstring 逐字点名 `exp(-t/τ)` 为 bug）；本模块**不写任何指数核**。
+#: γ（衰减率）可配 env —— 与 `MDCG_SPREAD_DECAY` 同款：缺失/非法即回落缺省。
+TEMPORAL_GAMMA_ENV = "MDCG_TEMPORAL_GAMMA"
+#: 半衰期真源 = `links.DECAY_DAYS`（30 天，`md_cg/links.py:53`）——不复制字面量，
+#: 由 `temporal_gamma()` 现取；此处只写明「γ 缺省 = ln2 / 半衰期」这一换算。
+#: 单位口径（**最易错处**）：γ 是「每天」的速率，故 Δt 必须**以天为单位**喂入。
+TEMPORAL_DT_UNIT = "day"
+#: 分数下限（floor）：`cred_factor(gamma, dt, floor, 1.0)` 的 floor。
+#: 取值理由：0.5**10 ≈ 9.77e-4 < 1e-3 —— 30 天半衰期下 300 天（10 个半衰期）
+#: 之后衰减已落到 1e-3 以下，继续区分无信息量；floor=1e-3 让**老节点/缺
+#: created_at 的节点**仍带非零分进入本路，而不是被乘成 0 后不可召回
+#:（读数见 `md_cg/test_time_core_lint.py` 的 G4 floor 组）。
+TEMPORAL_SCORE_FLOOR = 0.001
+
+
+# 生效条件：environ（缺省 os.environ）里 TEMPORAL_GAMMA_ENV 为真值且 float() 可解析且 > 0 时返回该值；缺失/空串/不可解析/非正数一律回落 `math.log(2)/links.DECAY_DAYS`（缺省半衰期 30 天）。
+def temporal_gamma(environ=None) -> float:
+    """时间邻近度衰减率 γ（**每天**）的唯一读取点。"""
+    raw = (environ or os.environ).get(TEMPORAL_GAMMA_ENV)
+    if raw:
+        try:
+            g = float(raw)
+        except (TypeError, ValueError):
+            g = 0.0
+        if g > 0:
+            return g
+    from .links import DECAY_DAYS      # 半衰期唯一真源（links.py:53，30 天）
+    return math.log(2.0) / float(DECAY_DAYS)
+
 
 # 生效条件：text 为假值（None/空串）时返回 0，否则按「CJK 0.6/字 + 其余 /4」计算并返回 int(cjk*0.6 + other/4) + 1。
 def est_tokens(text: str) -> int:
@@ -846,8 +880,9 @@ class MdCGOS(MdCG):
         详见 _candidates。
         """
         q = (query or "").strip()
-        # 批次 15 统一口径（unify.py）：任意语言 query → 标准原子序列；
-        # 与 MdCG.search/search_rrf 三入口同口径（MDCG_UNIFY_QUERY=0 可关）
+        # 批次 15 统一口径（unify.py，2026-09-30 收窄作用域）：只译**英文内容**
+        # → 标准原子序列，中文段逐字原样（不再整条归一）；与
+        # MdCG.search/search_rrf 三入口同口径（归一层缺省关，显式 =1 才开）
         from .semantic.unify import unify_query
         q = unify_query(q)
         if not q:
@@ -940,7 +975,9 @@ class MdCGOS(MdCG):
             if in_bucket:
                 docs = self._read_many(in_bucket, stat)
                 # 语义资格（MDCG_SEMANTIC=1）：fm.semantic 节点无条件入池
-                hits = [d for d in docs if self._like(d[2], d[1], terms)
+                hits = [d for d in docs
+                        if self._like(d[2], d[1], terms,
+                                      index_key_hits(d[0], terms, q))
                         or (semantic_on() and d[1].get("semantic"))]
                 out = try_stage(hits, TIER_BUCKET_LIKE)
                 if out:
@@ -966,7 +1003,8 @@ class MdCGOS(MdCG):
             docs_r = self._read_many(reach_entries, stat)
             _dif = set(_rstat.get("reach_diffused_paths") or ())
             hits_r = [d for d in docs_r
-                      if self._like(d[2], d[1], terms)
+                      if self._like(d[2], d[1], terms,
+                                    index_key_hits(d[0], terms, q))
                       or (semantic_on() and d[1].get("semantic"))
                       or d[0].get("path") in _dif]     # 图扩散补召回：无词面命中也放行进打分
             stat["pre_cap"] = len(hits_r)     # 与 T2 同序：截断**前**的候选数
@@ -998,7 +1036,9 @@ class MdCGOS(MdCG):
         # 截断依据=相关度（同 MdCG.search：cap 值不变，改的是拿什么排序）
         docs_all = self._read_many(entries, stat)
         # 语义资格（MDCG_SEMANTIC=1）：fm.semantic 节点无条件入池
-        hits = [d for d in docs_all if self._like(d[2], d[1], terms)
+        hits = [d for d in docs_all
+                if self._like(d[2], d[1], terms,
+                              index_key_hits(d[0], terms, q))
                 or (semantic_on() and d[1].get("semantic"))]
         stat["pre_cap"] = len(hits)
         stat["cap"] = GLOBAL_CAP
@@ -1046,7 +1086,9 @@ class MdCGOS(MdCG):
         docs = self._read_many(entries, stat)
         # 语义资格（MDCG_SEMANTIC=1）：fm.semantic 节点无条件入池——
         # 语义摘要=检索面（设想核心），否则摘要层只在 LIKE 全空时生效
-        hits = [d for d in docs if self._like(d[2], d[1], terms)
+        hits = [d for d in docs
+                if self._like(d[2], d[1], terms,
+                              index_key_hits(d[0], terms, query))
                 or (semantic_on() and d[1].get("semantic"))]
         if not hits:
             # 兜底池（LIKE 全空 = 无相关度信号）：截断依据=importance/created_at
@@ -1158,7 +1200,8 @@ class MdCGOS(MdCG):
 # 生效条件：当 seeds 非空且 seed_map 非空时，用 relation_types 或 CHAIN_TYPES_DEFAULT、max_depth 或 MAX_DEPTH_DEFAULT、decay 调用 chain.expand_from_seeds，仅保留 best 中仍存在于 entries（按 id(e)）的节点，读取成功者加入 scored 并按分数降序返回 (scored, prov)；seeds/seed_map/best 为空返回 ([], {})；
     def _path_chain(self, query, entries, seeds, context=None,
                     relation_types=None, max_depth=None, decay=0.9):
-        """关系链路径：沿 causal/sequential/applies_to 边**多跳**扩散。
+        """关系链路径（= 设计稿 §6.2 的**因果路**）：沿 causal/sequential/
+        applies_to 边**多跳**扩散。
 
         理论依据：`causal` = 条件依赖因果（A 是 B 成立的条件），
         `dex_chain` 沿 causal 边正向展开、每步标注条件，**链 = 条件序列**。
@@ -1170,6 +1213,13 @@ class MdCGOS(MdCG):
         本路按边类型权重（causal .85 / sequential .60 …）、逐跳乘边置信度、
         默认 5 跳、visited 剪枝——「检索使用关系链」的落地。
 
+        **边类型集可配（P3-causal）**：relation_types 缺省不再写死
+        `CHAIN_TYPES_DEFAULT`，而走 `chain.chain_types_from_env()`（env
+        `MDCG_CHAIN_TYPES`，缺省仍 = `CHAIN_TYPES_DEFAULT`）。动因：叙事/
+        文档语料（按章切出的 doc_ref 库）里**没有 causal 边**，只有
+        `reference` 与父章节结构边 `part_of`——写死即本路在这类库上恒空。
+        未登记进 `EDGE_WEIGHTS` 的形态被读取点剔除（不静默走未知边）。
+
         返回 (scored, prov)；prov[nid] 带该节点**最强链**的节点序列与条件序列，
         使「为什么召回它」可审计。
         """
@@ -1182,7 +1232,8 @@ class MdCGOS(MdCG):
                 seed_map[nid] = float(s)
         if not seed_map:
             return [], {}
-        rels = tuple(relation_types) if relation_types else chain.CHAIN_TYPES_DEFAULT
+        rels = (tuple(relation_types) if relation_types
+                else chain.chain_types_from_env())
         depth = chain.MAX_DEPTH_DEFAULT if max_depth is None else max_depth
         best = chain.expand_from_seeds(self, seed_map, relation_types=rels,
                                        max_depth=depth, decay=decay)
@@ -1209,6 +1260,65 @@ class MdCGOS(MdCG):
         scored.sort(key=lambda x: (-x[1], str(x[0].get("id") or "")))
         return scored, prov
 
+    def _path_temporal(self, entries, q_start, q_end, start_op, end_op,
+                       now=None):
+        """时间路（P3-temporal，设计稿 §6.3）：按**时间邻近度**排序的排名项。
+
+        口径（§〇.3-12 已裁，逐条钉在此处）：
+
+        * **核走唯一权威**：`time_core.cred_factor(gamma, dt, floor, 1.0)`
+          ——本模块**不写任何指数核**（`exp(-t/τ)`、`×(1-factor)`、EMA 保持率
+          均是 time_core docstring 点名的 bug 形态）。
+        * **γ 缺省 = ln2 / 30 天**（半衰期 30 天，与 `links.py:53` 同刻度），
+          env `MDCG_TEMPORAL_GAMMA` 可覆盖；唯一读取点 `temporal_gamma()`。
+        * **Δt 取 `created_at`**（写入时刻，主链必有）。
+        * **单位必须显式是「天」**：γ 是「每天」的速率，Δt 先除以 86400 再喂
+          ——喂秒会让衰减快 86400 倍（守卫 `test_time_core_lint.py` G3 组有该反证）。
+        * **加 floor**（`TEMPORAL_SCORE_FLOOR`）：老节点/缺 `created_at` 的节点
+          不被乘成 0 而永不可召回。
+        * **不做多跳扩散**：时间天然「1 跳」，本路是**排名项**（与 S4 层级加成
+          同类），不是扩散路。
+        * **种子不来自词法命中**：时间类问句常词面零重叠，故种子取
+          **时间算子/区间命中集**——`entries`（已过 S1/S2 门控 ∧ 已过
+          `trust.filter_by_time` 的索引标量过滤），**不 `_scan` 全库**、
+          不读正文即可算分（`created_at` 在索引快照里）。
+
+        ⚠ **理论边界标注**：理论原文 `exp(-γ·t)`（`docs/theory/智能论3.4.md:2122-2125`
+        DEV-005）说的是 **confidence 衰减**；把它用于「时间邻近度」是**工程口径
+        的类比迁移**，不是理论原话——同一核形状、不同语义（新近度权重）。
+        """
+        if not any(x is not None for x in (q_start, q_end, start_op, end_op)):
+            return []          # 无时间算子/区间 → 本路不启用（默认查询零变更）
+        from .whitebox_kb.aeis_core import time_core as _tc   # 懒导入（唯一权威）
+        gamma = temporal_gamma()
+        ref = q_end if q_end is not None else q_start
+        if ref is None:
+            ref = now if now is not None else time.time()
+        out = []
+        for e in entries:
+            try:
+                created = float(e.get("created_at") or 0.0)
+            except (TypeError, ValueError):
+                created = 0.0
+            if created <= 0:
+                # 写入时刻缺失：不猜测时刻，判「距参照无穷远」——floor 兜住
+                #（仍可召回，不因缺字段整条消失）。
+                dt_days = float("inf")
+            else:
+                # **单位=天**：86400 秒/天，显式换算（γ 是每天速率）
+                dt_days = abs(created - float(ref)) / 86400.0
+            score = _tc.cred_factor(gamma, dt_days, TEMPORAL_SCORE_FLOOR, 1.0)
+            fm, c = self._read(e)
+            if c is None:
+                continue
+            c = self._open_content(fm.get("id"), fm, c)
+            if c is None:
+                continue
+            out.append(({"id": fm.get("id") or e["path"], "frontmatter": fm,
+                         "content": c, "path": e["path"]}, round(score, 6)))
+        out.sort(key=lambda x: (-x[1], str(x[0].get("id") or "")))
+        return out
+
 # 生效条件：以 expand or expand_query_terms_weighted 作扩展函数并对 query 调用（结果为假值按 {} 处理），从其中 pop "__source__"（缺键为 "whitebox"）得 source，tw 为空返回 ([], source)，否则对 entries 中存在 _weighted_coverage>0 的条目按 0.6·cov+0.3·aff+0.1·ctx_aff（context 非 None 时以 route_key(ctx, ctx.get("tags")) 得 ctx_domain，context 非 dict 时用 {}）打分，返回 (out, source)。
     def _path_fuzzy(self, query, entries, context=None, expand=None):
         """模糊路径（分级隶属度）：返回 (scored, source)。
@@ -1343,7 +1453,9 @@ class MdCGOS(MdCG):
 # 生效条件：query 去空白为空→empty_query、候选为空→no_candidates；否则按 paths 各路召回后融合（fusion=="max" 取各路最大贡献、否则求和），recall_only 中的路只以 0 分补池不参与打分，judge 与 judge_ranking 同时为真时对 fused 前 max(k*2,10) 条做资格裁决（REJECT/BLINDSPOT 剔除、DEFER 降权 0.5），否则直接取 fused 前 k；validity 真值时候选层剔除已过期节点，且 query 缓存按 validity 分键不串口径。
     def search_rrf(self, query: str, k: int = 20, layer: str = None,
                    context=None, roles=None, include_work: bool = False,
-                   judge: bool = True, paths=("lexical", "bucket", "entity", "graph"),
+                   judge: bool = True,
+                   paths=("lexical", "bucket", "entity", "graph", "chain",
+                          "temporal"),
                    record: bool = True, query_expand=None,
                    path_weights=None, recall_only=None, fusion: str = "sum",
                    goal_text=None, judge_ranking: bool = False,
@@ -1358,14 +1470,28 @@ class MdCGOS(MdCG):
         多路共同确认的记忆排在单路命中之前（对齐 noema 的 Fusion Recall）。
         meta 含 per_path（各路的候选数与来源），可审计。
 
-        paths: 基线四路（词法/条件桶/实体/图扩展）+ 两条**显式启用**的增量路：
+        paths: 基线四路（词法/条件桶/实体/图扩展）+ 增量路：
             "fuzzy"    词表驱动（同义词组分级隶属度 + 大域 IDF）
             "semantic" 条件结构驱动（CCG 生效条件 + condition_space 四槽；
                        不适用条件被整词命中即从本路剔除——条件级负路由）
             "goal"     目标定向（第 5 篇第 3 章）：以活跃目标文本（或显式
                        goal_text）扩展查询，给「与当前目标相关」的记忆加权；
                        无活跃目标时本路为空，等价于未启用。
-            缺省 ("lexical","bucket","entity","graph")，既有行为完全不变。
+            "chain"    **因果路**（P3-causal，设计稿 §6.2）：以词法/实体命中为
+                       种子沿 edges 多跳扩散（复用 `md_cg/chain.py`：14 类边权、
+                       MAX_DEPTH 5、decay 0.9）。**代价口径（P3 遗留 ⑥ 如实
+                       降级，2026-10-01）：不读正文，但邻接构建为 O(N) 索引
+                       条目级**（`chain.adjacency` 遍历全部索引节点；冷建代价
+                       读数见 `scripts/p2p4_probe.py` R7）——原表述「不走全表」
+                       与实测不符，已改正。
+            "temporal" **时间路**（P3-temporal，设计稿 §6.3）：按时间邻近度排序
+                       的**排名项**，核走 `time_core.cred_factor`；无时间算子/
+                       区间时恒空。
+            缺省 = ("lexical","bucket","entity","graph","chain","temporal")
+            —— 后两路按裁定 9「全进默认检索」进缺省集；**每路可单独关**：
+            显式传不含该路的 paths 即关（既有调用方口径一字不变）。
+            两条新路在**无 edges / 无时间参数**的库上自然为空（零多算），
+            故纯词法查询的返回与改动前一致。
         path_weights: {路名: 权重}；缺省全部 1.0 → 与既有等权 RRF 完全一致。
             用于压低**同质路**的贡献：等权融合下，两路对同一批候选给出不一致
             排序时，RRF 会双重奖励「两路都靠前」的干扰项，把强路的 top-1 挤掉。
@@ -1375,6 +1501,8 @@ class MdCGOS(MdCG):
             sum 奖励「多路共识」，但会系统性低估**单路独有**候选：当强路漏掉目标、
             弱路捞到时，目标的单路贡献必然低于任何「两路都有排名」的干扰项。
             max 只认「最好的一次排名」，不奖励共识，适合「任一路捞到即可」的召回。
+            因果路是**单路独有召回型**，MCP 面（`mdcg_recall`）按其缺省 max
+            （先例 `mcp_server.py` 的 fuzzy/semantic/goal 同款表达式）。
         judge_ranking: 白箱终排（证据防火墙，显式启用）。融合排序只产生候选
             （语义负责「不要漏」），资格裁决决定最终优先级（白箱负责「不要错」）：
             REJECT / BLINDSPOT 剔除，DEFER 降权 ×0.5，ACCEPT 保位。候选池取
@@ -1399,8 +1527,9 @@ class MdCGOS(MdCG):
             本入口的对应物是 reach——不在本函数内。
         """
         q = (query or "").strip()
-        # 批次 15 统一口径（unify.py）：任意语言 query → 标准原子序列；
-        # 归一后的 q 进热路径缓存键（归一确定 → 缓存不串味）
+        # 批次 15 统一口径（unify.py，2026-09-30 收窄作用域）：只译**英文内容**
+        # → 标准原子序列（中文段逐字原样）；归一后的 q 进热路径缓存键
+        # （归一确定 → 缓存不串味）
         from .semantic.unify import unify_query
         q = unify_query(q)
         if not q:
@@ -1479,6 +1608,13 @@ class MdCGOS(MdCG):
         ranked = {}          # path -> [(node, score)]
         fuzzy_source = None
         chain_prov = {}
+        # P3-temporal：时间路的参照窗（与 `_candidates` 同一真源 `trust.check_time_args`
+        # /`trust.parse_time`；未启用时留 None → 本路恒空，默认查询零变更）。
+        # 只读索引标量（created_at 在索引快照里），不 `_scan` 全库、不读正文。
+        _t_en, _t_ax, _t_why = trust.check_time_args(
+            start_time, end_time, start_operator, end_operator, time_axis)
+        _t_qs, _t_qe = ((trust.parse_time(start_time), trust.parse_time(end_time))
+                        if _t_en else (None, None))
         if "lexical" in paths:
             ranked["lexical"] = self._lexical(q, entries, stat)
         if "bucket" in paths:
@@ -1490,6 +1626,12 @@ class MdCGOS(MdCG):
         if "chain" in paths:
             seeds = (ranked.get("lexical") or []) + (ranked.get("entity") or [])
             ranked["chain"], chain_prov = self._path_chain(q, entries, seeds, context)
+        if "temporal" in paths:
+            # P3-temporal：时间路（排名项）。时间算子/区间未启用时恒空——默认
+            # 查询（无时间参数）零变更；启用时种子取「已过 S1/S2 门控 ∧ 已过
+            # 时间算子过滤」的 entries（索引标量直读，不 _scan 全库）。
+            ranked["temporal"] = self._path_temporal(
+                entries, _t_qs, _t_qe, start_operator, end_operator)
         if "fuzzy" in paths:
             ranked["fuzzy"], fuzzy_source = self._path_fuzzy(
                 q, entries, context, expand=query_expand)
@@ -1582,12 +1724,50 @@ class MdCGOS(MdCG):
             fused = fused_all[:k]
 
         results = []
+        # P2-2（§5.2）：默认召回路径上的**拒绝域双语义**——与 `MdCG._emit` 同款
+        # 接线（同一个判据函数 `MdCG.judge_with_boundary`，此处不另写一份）：
+        # 边界命中 ⇒ 卡片带 `boundary_hit` 标记（可召回可展示）；资格不受影响；
+        # 边界命中数与资格 REJECT 数**分开计数**（boundary_counts）。
+        boundary_counts = {"hit": 0, "terms": 0,
+                           "counts": {"accept": 0, "reject": 0, "defer": 0,
+                                      "blindspot": 0}}
         for nid, fs in fused:
             node, s = node_by_id[nid]
-            qual = (quals.get(nid)
-                    or (self.judge_qualification(node, q, context) if judge
-                        else {"state": None, "reason": "judge_disabled"}))
+            if quals.get(nid):
+                # judge_ranking（白箱终排）已算过资格 → 不重复判定，边界标记
+                # 单独取（同一个 P0-4 判据函数 `MdCG.boundary_hit`）
+                qual = quals[nid]
+                _b = boundary_mark(node, q, context)
+                _c = {"accept": 0, "reject": 0, "defer": 0, "blindspot": 0}
+                _st = str(qual.get("state") or "").lower()
+                if _st in _c:
+                    _c[_st] = 1
+                if _b.get("hit"):
+                    boundary_counts["hit"] += 1
+                    boundary_counts["terms"] += len(_b.get("terms") or [])
+                    node["boundary_hit"] = True
+                    node["boundary_marker"] = _b.get("marker")
+                    node["boundary_terms"] = list(_b.get("terms") or [])
+                for _k in _c:
+                    boundary_counts["counts"][_k] += _c[_k]
+            elif judge:
+                _jw = MdCG.judge_with_boundary(node, q, context)
+                qual = dict(_jw["qualification"])
+                _b = boundary_mark(node, q, context)
+                if _b.get("hit"):
+                    boundary_counts["hit"] += 1
+                    boundary_counts["terms"] += len(_b.get("terms") or [])
+                    node["boundary_hit"] = True
+                    node["boundary_marker"] = _b.get("marker")
+                    node["boundary_terms"] = list(_b.get("terms") or [])
+                for _k in ("accept", "reject", "defer", "blindspot"):
+                    boundary_counts["counts"][_k] += int(
+                        (_jw.get("counts") or {}).get(_k) or 0)
+            else:
+                qual = {"state": None, "reason": "judge_disabled"}
             results.append((node, round(fs, 6), qual, prov.get(nid, [])))
+        _bnd_meta = ({"boundary": boundary_counts}
+                     if boundary_counts["hit"] else {})
         if record and results:
             self.record_access([r[0]["id"] for r in results], "RRF")
         # 热路径：写 query 结果缓存 —— **同样受 `_time_on` 约束**。
@@ -1603,7 +1783,7 @@ class MdCGOS(MdCG):
                          "expand_source": fuzzy_source,
                          "goal_used": goal_used,
                          "provenance": prov, **_tf_meta,
-                         **_gates_meta}, k=k, layer=layer,
+                         **_gates_meta, **_bnd_meta}, k=k, layer=layer,
                          session=session, branch=branch, validity=validity,
                          view=view, extra=_cache_extra)
         return results, {"tier": "RRF", "scanned": stat["scanned"],
@@ -1614,7 +1794,7 @@ class MdCGOS(MdCG):
                          "expand_source": fuzzy_source,
                          "goal_used": goal_used,
                          "provenance": prov, **_tf_meta,
-                         **_gates_meta}
+                         **_gates_meta, **_bnd_meta}
 
     # ================= 7. budget-driven pack =================
 
@@ -1638,11 +1818,12 @@ class MdCGOS(MdCG):
         动机：旧策略是「跳过超大、继续试更小的」——预算紧张时形成**逆向淘汰**，
         越有价值的详实条目越容易被排除（实测 budget=1500 时 16 条被刷、只装 2 条）。
 
-        paths/query_expand 缺省时行为与既有完全一致（默认四路、纯白箱扩展）；
-        显式传 paths 才启用新路，例如
+        paths/query_expand 缺省时行为 = 既有四路 ＋ P3 两条图检索路（chain/temporal，
+        按裁定 9 进缺省集；无 edges / 无时间参数时自然为空）；
+        显式传 paths 才启用第 5/6 路，例如
             ("lexical","bucket","entity","graph","fuzzy")            词表驱动
             ("lexical","bucket","entity","graph","semantic")         条件结构驱动
-            (… 七路全开 )                                             三者叠加
+            (… 八路全开 )                                             叠加
         include_recent=True 时，把近期事件窗口（第 5 篇第 3 章）附在包后，
         保证当前任务的连续性；它不参与 RRF 正排，但计入 token 预算。
         返回 {pack: [...], tokens_used, budget, skipped: [...], recent: [...], meta}
@@ -1831,10 +2012,11 @@ class MdCGOS(MdCG):
 
     # ================= 4. 审核队列（inbox → decisions） =================
 
-# 生效条件：当 node_id 与 content 传入时，在 strict 锁内按 payload_hash 查重；命中同内容提案（无论 pending/accepted/rejected，已裁决优先 break）时幂等返回既有 pid（info=True 返回 dedup 字典），未命中则生成新 pid 入队并返回 pid（info=True 返回 dedup False 字典）；
+# 生效条件：当 node_id 与 content 传入时，在 strict 锁内按 payload_hash（dedup_key 非空时以它为对账键、否则 _sig(content)）查重；命中同键提案（无论 pending/accepted/rejected，已裁决优先 break）时幂等返回既有 pid（info=True 返回 dedup 字典），未命中则生成新 pid 入队并返回 pid（info=True 返回 dedup False 字典）；kind 非空时原样落 rec 顶层 kind 键（缺省不落键 = 存量条目形状逐位不变）；
     def propose(self, node_id: str, content: str, layer: str = "knowledge",
                 tags=None, condition_space=None, verify=None,
-                info: bool = False, **kw):
+                info: bool = False, kind: str = None, dedup_key: str = None,
+                **kw):
         """把一个候选记忆放入海马体 inbox，等待审核（不直接持久化）。
 
         verify —— 验收判据（内联声明，裁决阶段只读），形如：
@@ -1847,10 +2029,22 @@ class MdCGOS(MdCG):
         不再入队。语义：重试与崩溃恢复无害——入队落盘成功而响应丢失时
         （MCP 客户端超时重试的真正机制），重试对账命中既有记录并返回原 pid。
 
+        kind / dedup_key（三档自治批次②，设计 §四 两个**可选**槽，缺省即
+        存量行为逐位不变）：
+          · `kind` = 队列条目**类型字段**（"proposal" 存量 / "mutation" 变更单）。
+            缺省 None **不落键**——存量与新普通提案的 rec 形状一字不变；读取方
+            经 `autonomy_modes.order_kind(rec)` 判类型，缺键一律视为 proposal
+            （零迁移）。
+          · `dedup_key` = 幂等对账键的**显式覆盖**（缺省 None → 原 `_sig(content)`）。
+            变更单必须覆盖：内容签名不带目标，「同一份新正文并入节点 X / 并入
+            节点 Y」会撞成同一条（`autonomy_modes.mutation_dedup_key` 把动作类与
+            目标并进键面）。键仍是 sha1 十六进制——`_inbox_phash_index` 与
+            `_cascade_dedup` 只做字符串比对，无需认识构造。
+
         返回值：info=False（默认）返回 pid 字符串（保形，存量调用零变化）；
         info=True 返回 {"pid", "dedup", "dup_of", "dup_status"}。
         """
-        phash = _sig(content)
+        phash = dedup_key or _sig(content)
         with FileLock(self.inbox_log, strict=True):
             # 增量对账（issue #32）：原实现每条全量 read_jsonl(inbox) +
             # read_jsonl(decisions)（锁内 O(M+D)/条、批量 O(M²)，旧格式行
@@ -1893,6 +2087,11 @@ class MdCGOS(MdCG):
                    "verify": verify or {}, "verify_hash": vhash,
                    "extra": kw, "actor": self.actor,
                    "session": getattr(self, "session", None)}
+            # 三档自治批次②（设计 §四）：类型字段**只在显式给定时落键**——
+            # 缺省不落，存量与新普通提案的 rec 形状逐位不变（零回归），
+            # 读取方按「缺键 = proposal」判（零迁移）。
+            if kind:
+                rec["kind"] = str(kind)
             append_jsonl(self.inbox_log, rec)
         self._audit("propose", node_id, pid=pid, layer=layer,
                     payload_hash=phash, verify_hash=vhash)
@@ -2161,7 +2360,7 @@ class MdCGOS(MdCG):
                  audit_source="hippocampus/decisions.jsonl", **extra)
         return nid
 
-# 生效条件：当 pid/item/decision/status/reason/round_no/rt_verdict/issues/vhash/result 传入时，构造 rec 并写 record_hash，把 result 中 ok/node_id/error/state 保留；在 strict 锁内追加 decisions_log；随后尝试写 md 审核记录，成功补 record_node_id/record_hash，异常则补 record_error 并 audit review_record_failed；最后 audit review_decide 并返回 result；
+# 生效条件：当 pid/item/decision/status/reason/round_no/rt_verdict/issues/vhash/result 传入时，构造 rec 并写 record_hash，把 result 中 ok/node_id/error/state 保留（result.mutation 为 dict 时另落 rec["mutation"]＝变更单执行时点载荷，proposal 链无此键、rec 形状逐位不变）；在 strict 锁内追加 decisions_log；随后尝试写 md 审核记录，成功补 record_node_id/record_hash，异常则补 record_error 并 audit review_record_failed；最后 audit review_decide 并返回 result；
     def _record_decision(self, pid, item, decision, status, reason, round_no,
                          rt_verdict, issues, vhash, result):
         """落盘一轮裁决：jsonl（权威）+ md 审计节点（可复核、供外部审计）。"""
@@ -2174,6 +2373,13 @@ class MdCGOS(MdCG):
         rec["record_hash"] = self._record_hash(rec)
         rec["result"] = {k: v for k, v in result.items()
                          if k in ("ok", "node_id", "error", "state")}
+        # 三档自治③（设计 §四）：变更单的**执行时点载荷**（含前像/影响面/
+        # 回滚命令）随裁决记录落盘——回滚 CLI 的读取源（rec["mutation"]）。
+        # proposal 链 result 无 mutation 键 ⇒ rec 形状逐位不变；record_hash
+        # 只算固定十键（_record_hash），不受本键影响。
+        _mut = result.get("mutation")
+        if isinstance(_mut, dict):
+            rec["mutation"] = _mut
         # 裁决记录不能丢：strict 锁内追加（并发裁决不交错；
         # 丢一条裁决会让提案回 pending → 重复落盘，比让裁决者等一下代价大）
         with FileLock(self.decisions_log, strict=True):
@@ -2279,7 +2485,158 @@ 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'），且写入前经与 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。
+# 生效条件：item 为 kind=mutation 的队列记录时先经 rollback.preimage 在**执行时点**留前像（目标在位时拍快照 + 采影响面 + 生成回滚命令；目标缺失返回 None 走既有错误路径；拍摄失败抛 PreimageError 被专捕成 preimage_unavailable 错误体），再按载荷 extra.mutation 分派——B：primitive 为 "converge_into" 走 writelimit.converge_into、否则走 forgetting.reinforce（两者都以 rec.actor 为动作发起者、载荷 meta 的 session/override 复现原槽）；C：目标经 forgetting.prior_node 判定——目标已不存在即返回 {"ok": False, "error": "target_missing", ...}（fail-closed，不重建节点、不记 accepted），存在才 self.add(目标, 后像, layer=rec.layer, sensitivity=rec.sensitivity, override, **载荷 meta) 覆写落盘；D：self.forget(目标, override) 软删；动作类不在 {B,C,D} 或原语返回失败（ok 为 False / None / target_missing）时返回 {"ok": False, "error": "mutation_execute_failed"/"mutation_action_unknown", ...} 且**不改动任何节点**；成功返回 {"ok": True, "mutation": <执行时点载荷：原载荷 + kind/executed + before/impact/rollback>, "node_id": ...}；
+    def _mutation_execute(self, item, reason: str = "", override: bool = False):
+        """变更单 accept 的执行桥：**显式越过确认判定**，直调对应动作的底层原语。
+
+        为什么这样就是「越过」（而不是绕过闸门）：三档自治的确认判定只长在
+        **热路径入口**（写链 `writepipe._gate_autonomy`、遗忘合并闸
+        `_autonomy_gate_merge`、工具面 `forget_gated`）；本桥调的是
+        `MdCG.add` / `forgetting.reinforce` / `writelimit.converge_into` /
+        `MdCGOS.forget`——即**库层原语**，它们历来不含档位判定（设计 §三 硬约束
+        「直调库层不接线，保持库层语义不变」）。故「已确认」这件事由调用点
+        （本桥）保证，不靠传一个 `already_confirmed=True` 之类的旗标穿透各层
+        （旗标会变成可被伪造的旁路）。
+
+        保护闸不绕：`add`/`reinforce`/`converge_into` 内部的
+        `protect.guard_write|guard_overwrite` 与 `forget` 的 `guard_forget`
+        仍是落盘必经之路——受保护节点在确认后依然被拦（拦下即返回失败、
+        裁决不落盘、提案保持 pending）。
+
+        失败语义（如实）：动作未发生 ⇒ 返回 ok=False 且**不记裁决**；调用方
+        （`review_decide`）据此提前返回，提案维持 pending 可见。
+
+        补强（2026-10-02，复核观察 3）：**C 改写的目标在 accept 时已消失**此前
+        走 `self.add` 的 upsert——静默把「改写」落地成「新增同 id 节点」并记
+        accepted（单子声称 C、盘面却是 A，前像被清空且无失败信号）。现与 B/D
+        同口径：目标不存在 ⇒ `{"ok": False, "error": "target_missing"}`，
+        **不重建节点**、不记裁决、提案保持 pending。判据复用存在性单点
+        `forgetting.prior_node`（与出单时的 C/A 判定同一单点）。
+
+    批次③（2026-10-02，设计 §四）——**执行时点三字段补全**：动作落盘**之前**
+        经 `rollback.preimage()` 拍前像（`protect.snapshot_preimage`，写
+        `_protected_history` 同面）+ 采影响面（边/索引条目/聚合行）+ 生成回滚
+        命令；成功返回的 `mutation` 是**补全后的执行时点载荷**
+        （`autonomy_modes.mutation_executed`），由 `_record_decision` 随裁决
+        落进 decisions.jsonl 的 `rec["mutation"]`（回滚 CLI 的读取源）。
+        前像**必须**是执行时点（不是提议时点）：从提议到 accept 之间目标可能
+        被第三方改动，回滚只撤销本变更本身（设计 §四 明文）。拍摄失败
+        （目标在位而快照未落）⇒ `preimage_unavailable` fail-closed，不执行
+        ——「一切破坏性动作先留前像」（设计 §六 义务）。
+        """
+        from . import autonomy_modes as _am
+        from . import rollback as _rb
+        try:
+            slot = (item.get("extra") or {}).get(_am.MUTATION_SLOT) or {}
+        except AttributeError:
+            slot = {}
+        act = str(slot.get("action") or "").strip().upper()
+        tgt = slot.get("target") or item.get("id")
+        after = slot.get("after")
+        if after is None:
+            after = item.get("content") or ""
+        meta = dict(slot.get("meta") or {})
+        actor = item.get("actor") or getattr(self, "actor", None)
+        session = meta.pop("session", None)
+        _ovr = bool(meta.pop("override", False)) or bool(override)
+        layer = item.get("layer") or "knowledge"
+        sens = item.get("sensitivity")
+        pre = None
+        try:
+            # ---- 执行时点补全（三档自治③ · 设计 §四）----
+            # 前像（执行时点快照引用）+ 影响面 + 回滚命令——在**动作落盘之前**：
+            # 从提议到 accept 之间目标可能被第三方改动，前像必须反映「执行前
+            # 一刻」的盘面，回滚才只撤销本变更本身。目标不存在时返回 None
+            # （动作不会发生，走既有 target_missing/not_found 错误路径）；
+            # 目标在位而拍摄失败 ⇒ PreimageError ⇒ 下方专捕 fail-closed。
+            pre = _rb.preimage(self, act, tgt, pid=item.get("pid"),
+                               reason="变更单执行时点前像（%s→%s，pid=%s）"
+                                      % (act, tgt, item.get("pid") or "?"))
+            if act == _am.B_MERGE:
+                if str(slot.get("primitive") or "") == "converge_into":
+                    res = writelimit.converge_into(self, tgt, after,
+                                                   override=_ovr, actor=actor,
+                                                   session=session)
+                else:
+                    res = forgetting.reinforce(self, tgt, override=_ovr,
+                                               actor=actor, content=after,
+                                               session=session)
+                node_id = tgt
+            elif act == _am.C_REWRITE:
+                # 补强（2026-10-02，复核观察 3）：C 的**目标节点在 accept 执行时
+                # 已不存在** ⇒ fail-closed，**不得**静默 `self.add` upsert 成
+                # 新增。旧形态：目标出单后被删除，重放把「改写」落成「同名新
+                # 节点」并记 accepted——变更单声称执行了 C 改写，盘面却凭空多出
+                # 一个节点（前像被清空，且无任何失败信号）。
+                # 判据复用**存在性单点** `forgetting.prior_node`（与出单时的
+                # C/A 判定同一单点），错误名与 B/D 原语同口径
+                # （`writelimit.converge_into` 的 {"ok": False,
+                # "error": "target_missing"}）。
+                if forgetting.prior_node(self, tgt) is None:
+                    return {"ok": False, "error": "target_missing",
+                            "kind": _am.KIND_MUTATION, "action": act,
+                            "target": tgt,
+                            "detail": "变更单 C 改写：目标节点在 accept 执行时"
+                                      "已不存在（出单后被删除/移走）——"
+                                      "fail-closed 未执行任何动作、未重建节点。",
+                            "hint": "目标节点 %s 已不存在：C 改写不得静默转成"
+                                    "「新增同 id 节点」。请核对目标是否已被删除"
+                                    "（trash/ 可 restore）后重新提议——裁决"
+                                    "**未落盘**，提案保持 pending。" % tgt}
+                node_id = self.add(tgt, after, layer=layer, sensitivity=sens,
+                                   override=_ovr, **meta)
+                res = {"ok": True, "node_id": node_id}
+            elif act == _am.D_DELETE:
+                res = self.forget(tgt, reason=reason or slot.get("reason") or "",
+                                  override=_ovr)
+                node_id = tgt
+            else:
+                return {"ok": False, "error": "mutation_action_unknown",
+                        "kind": _am.KIND_MUTATION, "action": act or None,
+                        "detail": "变更单载荷的动作类缺失或不在 %s——fail-closed"
+                                  "未执行任何动作、提案保持 pending。"
+                                  % "/".join(_am.ACTION_CLASSES)}
+        except _rb.PreimageError as exc:
+            # 执行时点前像未落盘（目标在位而快照失败）——「一切破坏性动作先留
+            # 前像」（设计 §四/§六），fail-closed 不执行：动作**未发生** ⇒
+            # 如实返回失败，不落裁决、提案保持 pending。
+            return {"ok": False, "error": "preimage_unavailable",
+                    "kind": _am.KIND_MUTATION, "action": act, "target": tgt,
+                    "detail": str(exc),
+                    "hint": "变更单未执行：执行时点前像未落盘（设计 §四：一切"
+                            "破坏性动作先留前像）——裁决**未落盘**，提案保持 "
+                            "pending；排查 _protected_history 目录可写性后"
+                            "重新裁决。"}
+        except Exception as exc:            # noqa: BLE001
+            # 保护闸（ProtectionError/AccessDenied）、冲突闸（ConsistencyError）、
+            # 路径闸（ValueError）等一律走这里：动作**未发生** ⇒ 如实返回失败，
+            # 不落裁决、提案保持 pending（把异常原样抛给 CLI 会让裁决进程崩在
+            # 「已执行一半」的歧义态上，且提案去向不可见）。
+            return {"ok": False, "error": "mutation_execute_failed",
+                    "kind": _am.KIND_MUTATION, "action": act, "target": tgt,
+                    "detail": "%s: %s" % (type(exc).__name__, exc),
+                    "hint": "变更单未执行：目标节点 %s 的动作被既有闸门拦下或原语"
+                            "失败——裁决**未落盘**，提案保持 pending；"
+                            "受保护节点/冲突需先按既有通道处置（override 或"
+                            "修文）后重新裁决。" % tgt}
+        if not isinstance(res, dict) or res.get("ok") is False:
+            return {"ok": False, "error": "mutation_execute_failed",
+                    "kind": _am.KIND_MUTATION, "action": act, "target": tgt,
+                    "detail": res,
+                    "hint": "变更单未执行：目标节点 %s 的动作原语未成功"
+                            "（受保护/目标缺失/同 id 冲突等）——裁决**未落盘**，"
+                            "提案保持 pending，修好后可重新裁决。" % tgt}
+        # 执行时点载荷（**唯一补全点**，autonomy_modes.mutation_executed）：
+        # 原载荷（动作类/目标/后像/理由/primitive/meta）+ kind/executed +
+        # before/impact/rollback——_record_decision 随裁决落 decisions.jsonl
+        # 的 rec["mutation"]（回滚 CLI 据此读回前像与动作类）。
+        mpay = _am.mutation_executed(
+            slot, before=(pre or {}).get("before"),
+            impact=(pre or {}).get("impact"),
+            rollback=(pre or {}).get("rollback"))
+        return {"ok": True, "node_id": node_id, "mutation": mpay}
+
+# 生效条件：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"）；kind=mutation 的变更单（三档自治批次②）不走上述分支——accept 经 _mutation_execute 执行对应动作（失败即返回错误、不记裁决、提案保持 pending）、reject 只留痕，其余裁决 fail-closed 返回 mutation_decision_unsupported；最后统一 _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,
@@ -2298,6 +2655,14 @@ class MdCGOS(MdCG):
         的写入门控（它根本不写）。此处 noop 是**裁决动作**，与 lifecycle/trust 中
         同名的**状态迁移结果码**分属两层（见模块常量区注释）。
 
+        **变更单**（`kind=mutation`，三档自治批次② · 设计 §四）：本批只定义
+        accept/reject——accept = 执行对应动作（B 合并原语 / C 覆写落盘走既有
+        add / D 软删走既有 forget），reject = 原样留痕不执行；edit/merge/noop
+        对变更单**未定义** ⇒ fail-closed 报错带 hint（不静默当已处理）。
+        执行失败 ⇒ **不记裁决**、提案保持 pending（与 merge 的
+        `merge_target_not_found` 同款：不落一条「accepted 而动作没做」）。
+        存量 `kind` 缺键的提案（= proposal）在本方法里**逐位不变**。
+
         两条验证纪律（借自任务分级协议的验证端）：
           1. 判据只读：verify 由 propose 声明，裁决阶段传入不同判据 → verify_readonly。
           2. 红队门控 + 再审批：redteam.verdict=reject（或带 issues 的 reject）不落库，
@@ -2353,6 +2718,14 @@ class MdCGOS(MdCG):
             return {"ok": False, "error": "redteam_required",
                     "detail": "MDCG_REDTEAM_REQUIRED=1：accept 必须带红队 pass"}
 
+        # 三档自治批次②（设计 §四）：**变更单**（kind=mutation）走**独立执行桥**
+        # ——在既有前置闸（已判/verify_readonly/再审批/红队门控）之后、既有
+        # accept/edit/merge/noop 链之前。proposal（含存量无 kind 条目）一律不
+        # 进此支，下面整条链对它逐位不变。
+        if autonomy_modes.order_kind(item) == autonomy_modes.KIND_MUTATION:
+            return self._decide_mutation(pid, item, decision, reason, override,
+                                        round_no, rt_v, rt_issues, expect)
+
         result = {"pid": pid, "decision": decision, "round": round_no,
                   "redteam": rt_v or "absent"}
         if decision == DECISION_NOOP:
@@ -2363,6 +2736,11 @@ class MdCGOS(MdCG):
         elif decision == "reject":
             result["ok"] = True
         elif decision in ("accept", "edit"):
+            # issue50-c F1 对口（2026-10-01，本分支**零行为改动**）：accept 早就是
+            # 「队列记录 → 节点 fm」的映射通道（`rec.tags` / `rec.condition_space`
+            # / `**extra`，下方 :2553/:2573）。`remember_gated` 的 DEFER 出口把调用方
+            # 声明的 meta 随入队一并落进这三槽之后，DEFER→accept 与直接 ACCEPT 的
+            # 节点 fm 即等价——映射不需要新增第二套实现，本分支职责与判据不变。
             content = item["content"]
             tags = list(item.get("tags") or [])
             layer = item.get("layer") or "knowledge"
@@ -2446,6 +2824,18 @@ class MdCGOS(MdCG):
             self.flush()
             result.update(ok=True, node_id=target)
 
+        return self._finish_decision(pid, item, decision, reason, round_no,
+                                     rt_v, rt_issues, expect, result)
+
+# 生效条件：result 为已定好的裁决返回体时，按其 pid/item/decision/reason/round_no/rt_v/rt_issues/expect 调 _record_decision（status 映射统一出口：reject→"rejected"、noop→"noop"、其余→"accepted"）落盘 jsonl + 审计节点，再按 item 的 payload_hash（缺失时 _sig(content)）调 _cascade_dedup 级联出清（有 closed 时写 result["cascade_closed"]），最后 flush 并返回 result；
+    def _finish_decision(self, pid, item, decision, reason, round_no, rt_v,
+                         rt_issues, expect, result):
+        """裁决**统一收尾**（单点）：proposal 链与变更单执行桥共用同一收尾。
+
+        为何抽出来：三档自治批次② 的变更单走独立执行桥（`_decide_mutation`），
+        但「落 decisions.jsonl + 写审计节点 + 级联出清 + flush」这几步必须与原
+        路径**同一条实现**——各写一份必然漂移（本仓已两次教训）。
+        """
         # status 映射统一出口：reject→"rejected"、noop→"noop"（同为终态，见
         # TERMINAL_DECISION_STATUS）、其余→"accepted"。
         result = self._record_decision(
@@ -2467,6 +2857,40 @@ class MdCGOS(MdCG):
         self.flush()
         return result
 
+# 生效条件：item 为 kind=mutation 的队列记录——decision 为 accept 时经 _mutation_execute 执行对应动作（返回 ok=False 时**原样返回该错误**、不落裁决、提案保持 pending），为 reject 时只置 ok=True 留痕；decision 非此二者时返回 {"ok": False, "error": "mutation_decision_unsupported", ...} 带 hint（fail-closed，不落裁决）；通过者交 _finish_decision 收尾后返回其结果；
+    def _decide_mutation(self, pid, item, decision, reason, override, round_no,
+                         rt_v, rt_issues, expect):
+        """变更单的裁决分派（三档自治批次② · 设计 §四）：accept 执行 / reject 留痕。
+
+        本批只定义 accept/reject 两态；其余裁决（edit/merge/noop）**fail-closed
+        报错带 hint**，不静默当作已处理——否则一条被 noop 的变更单会伪装成
+        「评估过、无需改动」，而实际动作从未发生过（设计 §三 硬约束③ 的同精神：
+        没发生的事不许汇报成发生了）。
+        """
+        if decision not in (DECISION_ACCEPT, DECISION_REJECT):
+            return {"ok": False, "error": "mutation_decision_unsupported",
+                    "kind": autonomy_modes.KIND_MUTATION,
+                    "decision": decision,
+                    "hint": "变更单（kind=mutation）本批只定义 accept/reject："
+                            "accept=执行对应动作（B reinforce/converge、"
+                            "C 覆写落盘、D 软删），reject=原样留痕不执行；"
+                            "edit/merge/noop 对变更单未定义——fail-closed "
+                            "未处理，提案保持 pending（未静默关闭）。"}
+        result = {"pid": pid, "decision": decision, "round": round_no,
+                  "redteam": rt_v or "absent"}
+        if decision == DECISION_ACCEPT:
+            mres = self._mutation_execute(item, reason=reason, override=override)
+            if not mres.get("ok"):
+                # 执行失败 = 动作未发生：**不落裁决**（提案保持 pending，与 merge
+                # 分支的 merge_target_not_found 同款——落一条 accepted 而动作没做，
+                # 就是「汇报不实」）。
+                return mres
+            result.update(mres)
+        else:
+            result["ok"] = True
+        return self._finish_decision(pid, item, decision, reason, round_no,
+                                     rt_v, rt_issues, expect, result)
+
 # 生效条件：无输入形参；调用即返回 list(read_jsonl(self.decisions_log))，记录内容取决于 decisions_log 可读结果；
     def decisions(self):
         return list(read_jsonl(self.decisions_log))
@@ -2474,11 +2898,17 @@ class MdCGOS(MdCG):
     # ================= 5. tombstone + 恢复时删除检查 =================
 
 # 生效条件：当 node_id 传入且索引中存在该节点时，先经 protect.guard_forget(override=override) 保护检查，随后尝试把源路径 os.replace 到 trash_dir/{node_id}.md；OSError 返回 ok False error 字符串；成功则写 deletions_log、_unstage、缓存失效、audit，并返回 ok True/id/tombstone；索引无此节点返回 not_found；
-    def forget(self, node_id: str, reason: str = "", override: bool = False):
-        """软删除：节点文件移入 trash/，写入删除清单（payload-free）。
+    def _forget_qualify(self, node_id: str, override: bool = False):
+        """删除的**既有资格前置闸**（单点）：索引代际感知 → not_found → 写保护。
 
-        写保护：受保护节点（self/anchor 层、protected 标记、importance≥0.7）
-        不可遗忘——需显式 override=True，且旧版本先快照、动作全程留痕。
+        为什么抽出来：三档自治（设计 §三 硬约束②「判定必须在既有资格闸通过
+        之后」）需要在**不重复、不重排、不放宽**这三道既有判据的前提下，先让
+        资格闸跑完再问档位。判据只此一份——`forget`（库层原路径）与
+        `forget_gated`（工具面档位路径）共用，不各写一份必然漂移。
+
+        返回 (entry, None) 表示资格通过（entry = 索引条目）；(None, err) 表示
+        资格未过（err 即既有 forget 的返回体；保护闸抛出的异常照旧外抛，不在
+        此吞掉——调用方看到的语义与改动前逐位一致）。
         """
         # N195（2026-09-28）：删除面与写面同源，先做索引代际感知。此前直读
         # 本进程内存索引——他进程刚写入的 anchor/self 节点在本进程索引中
@@ -2487,8 +2917,28 @@ class MdCGOS(MdCG):
         self._maybe_reload_index()
         e = self.index["nodes"].get(node_id)
         if not e:
-            return {"ok": False, "error": "not_found"}
+            return None, {"ok": False, "error": "not_found"}
         protect.guard_forget(self, node_id, override=override, actor=self.actor)
+        return e, None
+
+    def forget(self, node_id: str, reason: str = "", override: bool = False):
+        """软删除：节点文件移入 trash/，写入删除清单（payload-free）。
+
+        写保护：受保护节点（self/anchor 层、protected 标记、importance≥0.7）
+        不可遗忘——需显式 override=True，且旧版本先快照、动作全程留痕。
+
+        **库层语义不变**（三档自治批次②边界）：本方法不读档位、不出变更单——
+        档位判定在工具面 `forget_gated`（MCP `cg(op=forget)` / `mdcg_forget`），
+        脚本通道（`scripts/dsh_log_index.py` 等直调本方法）现状逐位不变。
+        """
+        e, err = self._forget_qualify(node_id, override=override)
+        if err is not None:
+            return err
+        return self._forget_apply(node_id, e, reason)
+
+# 生效条件：e 为 _forget_qualify 通过后的索引条目时执行既有软删体（os.replace 进 trash_dir、写 deletions_log、_unstage、缓存失效、audit）；publish 抛 OSError 时返回 {"ok": False, "error": 异常字符串}；成功返回 {"ok": True, "id", "tombstone"}；
+    def _forget_apply(self, node_id: str, e: dict, reason: str = ""):
+        """软删**执行体**（单点）：与改动前的 `forget` 体逐位一致。"""
         src = os.path.join(self.root, e["path"])
         fm, content = self._read(e)
         h = _sig(content or "", 16)
@@ -2510,6 +2960,43 @@ class MdCGOS(MdCG):
         self._audit("forget", node_id, reason=reason, payload_hash=h)
         return {"ok": True, "id": node_id, "tombstone": h}
 
+# 生效条件：先跑既有资格前置闸 _forget_qualify（未过即原样返回其 err，含 not_found 与 protect.guard_forget 抛出）；资格通过后以 autonomy_modes.decide(D_DELETE) 判定——ALLOW 走 _forget_apply 软删并返回其原返回体；FORBID 返回 ok=False/moved_to="autonomy_forbidden" 终态；CONFIRM 经 autonomy_modes.propose_mutation 出变更单（目标 node_id、后像为空、复现参数 override 入载荷）并返回 ok=True/committed=False/deleted=False/moved_to="review_queue" 的终态（**不软删**）；
+    def forget_gated(self, node_id: str, reason: str = "", override: bool = False):
+        """软删的**档位路径**（三档自治批次② · 设计 §三 D 删除）：MCP 工具面专用。
+
+        位置（硬约束②「纯加严」）：`protect.guard_forget` 等既有资格判据跑完
+        之后才问档位——档位**不参与**资格判定、也**不放宽**任何判据：受保护
+        节点在这里照旧被 `ProtectionError` 拦下（不是先出单再拦）。
+
+        边界（如实）：脚本通道直调 `MdCGOS.forget`（库层原路径）**不接**本档位
+        ——本批只覆盖 MCP 工具面两个落点（`cg(op=forget)` / `mdcg_forget`）。
+        """
+        e, err = self._forget_qualify(node_id, override=override)
+        if err is not None:
+            return err
+        dec = autonomy_modes.decide(autonomy_modes.D_DELETE)
+        if dec["decision"] == autonomy_modes.ALLOW:
+            return self._forget_apply(node_id, e, reason)
+        aut = {"mode": dec["mode"], "action": dec["action"],
+               "action_name": dec["action_name"], "decision": dec["decision"]}
+        if dec["decision"] == autonomy_modes.FORBID:
+            return {"ok": False, "id": node_id, "deleted": False,
+                    "moved_to": "autonomy_forbidden", "error": "autonomy_forbid",
+                    "autonomy": aut, "hint": dec["hint"]}
+        pay = autonomy_modes.mutation_payload(
+            autonomy_modes.D_DELETE, node_id, after="",
+            reason=reason or "删除（MCP forget 工具面）", primitive="forget",
+            meta={"override": bool(override)})
+        pr = autonomy_modes.propose_mutation(
+            self, autonomy_modes.D_DELETE, node_id, payload=pay,
+            layer=e.get("layer") or "knowledge",
+            sensitivity=e.get("sensitivity"), info=True)
+        return {"ok": True, "id": node_id, "committed": False, "deleted": False,
+                "moved_to": "review_queue", "pid": pr["pid"], "mutation": pay,
+                "autonomy": aut,
+                "hint": "%s 本次未删除（节点原样在位）：变更单已入审核队列"
+                        "（pid=%s，目标 %s）。" % (dec["hint"], pr["pid"], node_id)}
+
 # 生效条件：无输入形参；调用即返回 list(read_jsonl(self.deletions_log))，记录内容取决于 deletions_log 可读结果；
     def deletions(self):
         return list(read_jsonl(self.deletions_log))
@@ -3412,7 +3899,176 @@ class MdCGOS(MdCG):
 
     # ---- 主动遗忘（写入侧三问闸门）+ 写保护盘点 ----
 
-# 生效条件：kw 中 gated 为假值时旁路直接 ACCEPT 写入并返回 bypass；否则 writelimit.check 非 None 时按 CONVERGE→MERGE 并经 converge_into（带 session 归属）并入 target、DROP/DEFER 只记 forgetting 日志，无限流拦截时按 forgetting.assess 的四态处理（ACCEPT 走 add；MERGE 走 reinforce（带 content 与 session，返回体带 content_sink 去向）；DROP 经 forgetting.record_drop 落去向留痕并带 dropped 去向单；DEFER 不落库只留痕）。
+# 生效条件：以 autonomy_modes.decide(B_MERGE) 判定——ALLOW 返回 None（调用方照旧执行合并原语，merge 裁决本身一字不改）；FORBID 返回 verdict="FORBID"/moved_to="autonomy_forbidden" 的终态；CONFIRM 经 autonomy_modes.propose_mutation 出变更单（目标 tgt、后像 content、复现参数 override/session 入载荷 meta）并返回 verdict="CONFIRM"/moved_to="review_queue" 的终态（**不调用任何合并原语、不落盘**）；
+    def _autonomy_gate_merge(self, node_id, tgt, content, kw, primitive,
+                             reason="", gate=None):
+        """三档自治档位在 **B 合并**出口的判定单点（设计 §三：变更确认档需确认）。
+
+        为什么是单点：合并的**两个落点**（`writelimit.check` 的 CONVERGE →
+        `converge_into`、`forgetting.assess` 的 MERGE → `reinforce`）都必须
+        过同一判据——两处各写一份必然漂移；且判定必须晚于**各自的裁决**
+        （限流闸 / 遗忘三问），档位不参与裁决（纯加严）。
+
+        变更单载荷：动作类 B · 目标 tgt · 后像 = 本次新内容 · 理由 · 复现参数
+        （override/session——merge 原语的两个非默认槽，裁决 accept 时按此重放）。
+        提议者/会话由 propose 的库端快照自动归属（`actor`/`session` 字段）。
+        """
+        from . import autonomy_modes as _am
+        # 资格在先（纯加严）：合并落盘时 reinforce/converge_into 内部的
+        # guard_overwrite 若会拒（受保护/越权），必须在**出单之前**照样拒——
+        # 否则一次本该报错的合并会变成「静默入队」。
+        self.write_qualify(tgt, override=bool(kw.get("override")),
+                           actor=self.actor)
+        dec = _am.decide(_am.B_MERGE)
+        if dec["decision"] == _am.ALLOW:
+            return None
+        aut = {"mode": dec["mode"], "action": dec["action"],
+               "action_name": dec["action_name"], "decision": dec["decision"]}
+        if dec["decision"] == _am.FORBID:
+            # 形态对齐原 MERGE 出口（gate / merged_into 两键照带）：调用方按
+            # 「gate.reason」取值读判断依据的既有读法不因本闸断裂。
+            return {"verdict": "FORBID", "node_id": node_id, "gate": gate,
+                    "merged_into": tgt, "moved_to": "autonomy_forbidden",
+                    "autonomy": aut, "hint": dec["hint"]}
+        # 队列的层闸（MdCGSecure.propose）按**目标节点的真层**校验：合并落点
+        # 本来就是目标层，用调用方声明的层会让闸与落点错位（issue50 前车：
+        # 校验层与落盘层错位会造死提案）。
+        tlayer = ((self.index.get("nodes") or {}).get(tgt) or {}).get("layer") \
+            or ((self.get(tgt) or {}).get("frontmatter") or {}).get("layer") \
+            or "contextual"
+        pay = _am.mutation_payload(
+            _am.B_MERGE, tgt, after=content,
+            reason=reason or ("档位确认（变更确认档）：新写入内容并入既有节点 %s"
+                              "（原语 %s）" % (tgt, primitive)),
+            primitive=primitive,
+            meta={"override": bool(kw.get("override")),
+                  "session": _writer_session(self, kw)})
+        pr = _am.propose_mutation(self, _am.B_MERGE, tgt, payload=pay,
+                                  layer=tlayer,
+                                  sensitivity=kw.get("sensitivity"), info=True)
+        return {"verdict": "CONFIRM", "node_id": node_id, "gate": gate,
+                "merged_into": tgt, "moved_to": "review_queue",
+                "pid": pr["pid"], "mutation": pay, "autonomy": aut,
+                "hint": "%s 本次未合并：变更单已入审核队列（pid=%s，目标 %s，"
+                        "新内容随单）。" % (dec["hint"], pr["pid"], tgt)}
+
+# 生效条件：以 forgetting.prior_node 判「同 id 已存在」（存在=C 改写、不存在=A 新增）后交 autonomy_modes.decide 判定——ALLOW 返回 None（调用方照旧 add 落盘，逐位不变）；FORBID 返回 ok=False/verdict="FORBID"/moved_to="autonomy_forbidden" 的终态（fail-closed，不落盘、不出单）；CONFIRM 先经 self.write_qualify 跑既有资格探针（受保护/越权覆写照旧当场抛出、不静默入队）再经 autonomy_modes.propose_mutation 出变更单并返回 ok=True/verdict="CONFIRM"/committed=False/moved_to="review_queue" 的终态（**不落盘**）；既有节点（C 改写）confirm/plan 两档出单、full 档放行；新节点（A 新增）confirm/full 两档放行、plan 档 FORBID（计划外零变更）；
+    def _autonomy_gate_rewrite(self, node_id, content, layer, kw,
+                               override=False, reason="", gate=None):
+        """三档自治档位在 **gated 面「C 改写 / A 新增」**出口的判定单点。
+
+        为什么要它（补强批次 2026-10-02，复核发现 1/2）：`gated=true` 的写入
+        在上游 `writepipe._gate_gated` 是**替代执行路径**（`remember_gated`
+        自行落盘后直接返回终态，链尾 `_gate_autonomy` 根本不执行）——而
+        `remember_gated` 的 ACCEPT 分支此前**无任何档位判据**、直调 `self.add`：
+        缺省（confirm）档对**既有 node_id 的覆写**直接落盘（不出变更单）、
+        计划档对**新 node_id** 也照样写入。二者都与设计 §三（C=需确认、
+        计划外零变更）相抵。本方法是该面**唯一**的档位判定点（与写链
+        `writepipe._gate_autonomy`、合并面 `_autonomy_gate_merge` 同口径）。
+
+        位置（纯加严，设计 §三 硬约束②）：遗忘闸四态裁决（`forgetting.assess`）
+        之后、`self.add` 落盘之前；档位**不参与**裁决、也不放宽任何既有判据。
+
+        动作类判定：`forgetting.prior_node(self, node_id)` 同 id 存在 ⇒
+        **C 改写**；不存在 ⇒ **A 新增**——判据复用同一单点，不另写一份存在性判据。
+
+        资格在先：既有节点出单**之前**先 `self.write_qualify`（与 add 内部同一批
+        protect 单点，只判不写）——受保护/越权覆写照旧当场 `ProtectionError`/
+        `AccessDenied`，不会变成「静默入队」（放宽既有判据）。
+
+        载荷 meta（复现原动作）：取**写链同一份白名单** `writepipe.
+        _AUTONOMY_META_KEYS`（延迟导入，单一真源），并补 gated 面独有的 fm 扩展键
+        `role`——直写路径 `self.add(..., **kw)` 会把 role 经 add 的 `**extra`
+        落 fm，重放不带就会「出单→确认→写」与直写两条路径 fm 不等价。
+        边界（如实）：`kw` 里的 `session` 不在本白名单内、且执行桥会把它
+        收进 B 原语的 session 槽（C 面不复现）——当前两个 gated 调用点
+        （`writepipe._gate_gated` / `mcp_server.mdcg_remember`）都不传 session。
+
+        返回形态：出单 = `ok=True/committed=False/moved_to="review_queue"`
+        且带 pid（口径同写链 `_gate_autonomy`）；FORBID = `ok=False/
+        moved_to="autonomy_forbidden"`（口径同写链 A 面）；ALLOW = `None`
+        （调用方原路落盘，行为逐位不变）。
+        """
+        from . import autonomy_modes as _am
+        # 载荷 meta 白名单的单一真源在写链（写面唯一定义处）；延迟导入防循环。
+        from . import writepipe as _wp
+        prior = forgetting.prior_node(self, node_id)
+        action = _am.C_REWRITE if prior is not None else _am.A_ADD
+        if prior is not None:
+            # 资格在先（纯加严）：同 `_autonomy_gate_merge` / `writepipe.
+            # _gate_autonomy`——覆写的层闸/写保护闸住在 `self.add` 内部，档位
+            # 先出单会把一次本该报错的覆写变成「静默入队」（放宽既有判据）。
+            self.write_qualify(node_id, target_layer=layer,
+                               override=bool(override), actor=self.actor)
+        dec = _am.decide(action)
+        if dec["decision"] == _am.ALLOW:
+            return None
+        aut = {"mode": dec["mode"], "action": dec["action"],
+               "action_name": dec["action_name"], "decision": dec["decision"]}
+        if dec["decision"] == _am.FORBID:
+            return {"ok": False, "verdict": "FORBID", "node_id": node_id,
+                    "committed": False, "gate": gate,
+                    "moved_to": "autonomy_forbidden", "error": "autonomy_forbid",
+                    "autonomy": aut, "hint": dec["hint"]}
+        meta = {k: kw[k] for k in _wp._AUTONOMY_META_KEYS
+                if kw.get(k) is not None}
+        if kw.get("role") is not None:
+            meta["role"] = kw["role"]
+        if override:
+            meta["override"] = True
+        pay = _am.mutation_payload(
+            action, node_id, after=content,
+            reason=reason or ("gated 面覆写（gated=true / remember_gated 对既有"
+                              "节点 %s 的 %s）" % (node_id, _am.ACTION_NAMES[action])),
+            primitive="add", meta=meta)
+        pr = _am.propose_mutation(self, action, node_id, payload=pay,
+                                  layer=layer,
+                                  sensitivity=kw.get("sensitivity"), info=True)
+        return {"ok": True, "verdict": "CONFIRM", "node_id": node_id,
+                "committed": False, "gate": gate, "moved_to": "review_queue",
+                "pid": pr["pid"], "mutation": pay, "autonomy": aut,
+                "hint": "%s 本次未落盘：变更单已入审核队列（pid=%s，目标 %s）。"
+                        % (dec["hint"], pr["pid"], node_id)}
+
+# 生效条件：node_id 不在索引中（新节点）时返回 None（新写入面没有「既有资格闸」，其层闸由落盘面把守）；在索引中时以 override=False 跑 protect.guard_overwrite（既有节点覆写前的统一双闸：principal 层闸按**既有节点真层** + 引擎级写保护闸）与（target_layer 非空且与真层不同时）protect.guard_move（受保护节点移出保护层的降级闸），任一拒绝抛出的 AccessDenied 一律照抛、ProtectionError 仅在 override 为假时照抛（override 为真时放行——真实写入那一次会带授权并写快照，本探针**不写快照**）；全部通过返回 None；本函数不落盘、不改索引、不写任何快照；
+    def write_qualify(self, node_id, target_layer=None, override=False,
+                      actor=None):
+        """既有节点写面的**资格探针**（三档自治：档位判定必须晚于既有资格闸）。
+
+        为什么要它（纯加严，设计 §三 硬约束②）：写面落盘时的两道资格闸
+        ——`protect.guard_overwrite`（层闸 + 写保护闸）与 `protect.guard_move`
+        （降级闸）——住在 `MdCG.add` **内部**。若档位闸在 add 之前就判「出变更
+        单」，一次本该被拒的越权/受保护覆写就从 `AccessDenied`/`ProtectionError`
+        变成「静默入队」——那是**放宽既有判据**（未授权者凭空获得一个排单出口）。
+        故档位判定前先用**同一批单点**跑一遍资格：判据只有一份（protect 的那些
+        单点），这里只负责按 add 的次序与范围调用它们。
+
+        无副作用边界（如实）：override=False 时 guard_write/guard_move 只判不写；
+        override=True 的情形**不由本探针**产生快照——快照归真实写入那一次
+        （`_allow` → `_protected_history`）。故本探针不得被当作「授权检查」以外的
+        用途（它不建目录、不落文件、不动索引）。
+        """
+        e = (self.index.get("nodes") or {}).get(node_id)
+        if not e:
+            return None
+        if target_layer and str(e.get("layer") or "") \
+                and str(e.get("layer")) != str(target_layer):
+            try:
+                protect.guard_move(self, node_id, target_layer, override=False,
+                                   actor=actor)
+            except protect.ProtectionError:
+                if not override:
+                    raise
+        try:
+            # 层闸按**既有节点真层**解析（layer=None ⇒ protect._resolve_target
+            # 取索引/ fm 的真层）——与 add 的 N221 跨层覆写同口径（源层在先）。
+            protect.guard_overwrite(self, node_id, override=False, actor=actor)
+        except protect.ProtectionError:
+            if not override:
+                raise
+        return None
+
+# 生效条件：kw 中 gated 为假值时旁路直接 ACCEPT 写入并返回 bypass；否则 writelimit.check 非 None 时按 CONVERGE→MERGE 并经 converge_into（带 session 归属）并入 target、DROP/DEFER 只记 forgetting 日志，无限流拦截时按 forgetting.assess 的四态处理（ACCEPT **先过档位闸 `_autonomy_gate_rewrite`**——既有 node_id ⇒ C 改写（confirm/plan 出单且不落盘、full 放行）、不存在 ⇒ A 新增（confirm/full 放行、plan fail-closed `autonomy_forbidden`），放行才走 add——issue50-d：落盘 importance 恒等于裁决 imp["score"]（hint 或启发式）并落 importance_source（"hint"|"heuristic"），add 的自动保护位只认显式声明；MERGE 走 reinforce（带 content 与 session，返回体带 content_sink 去向）；DROP 经 forgetting.record_drop 落去向留痕并带 dropped 去向单；DEFER 不落盘、经既有入队单点 self.propose 把**正文 + 声明 meta（**kw）+「为何待定」**送进审核队列（返回体带 proposed=pid；node_id 非字符串时兜底成内容派生 id 并写 proposed_id_fallback），并照旧只记 forgetting 留痕）。
     def remember_gated(self, node_id, content, layer="contextual", **kw):
         """写入情景层记忆前的**主动遗忘闸门**：三问 → 四态。
 
@@ -3424,6 +4080,34 @@ class MdCGOS(MdCG):
         DROP 丢弃（低熵噪音）/ DEFER 待定（不写）。
         四种结果都写进 `_forgetting.jsonl`，可审计。
 
+        issue50-b（2026-10-01）：DEFER 此前**只留一行痕**——不落盘、无收件箱。
+        issue50-a 把半重复判 DEFER 后，这条出口的语义（「待定**复核**」）与
+        实际（静默不记）分叉：噪声缺陷会换成「不落盘且无收件箱」缺陷。故
+        DEFER 出口接线**既有入队单点** `self.propose`（与审计/策略闸
+        `writepipe._gate_audit`、一致性闸 `_gate_consistency` 同一条链、同一
+        payload_hash 幂等对账）：正文随提案进审核队列，裁决 accept 即落盘；
+        「为何待定」写进提案记录的 `extra.defer_reason`（propose 的既有任意槽，
+        不新增队列字段/队列类型）。
+
+        issue50-c F1（2026-10-01，扩面修）：入队**只带 content/layer/sensitivity**，
+        调用方声明的其余 meta 全丢——accept 只能从队列记录取值，故「同一声明」下
+        DEFER→accept 落盘的节点比直接 ACCEPT 少 tags/condition_space/
+        verification_basis/non_applicable_conditions/derived_from/relation/role
+        （实测 tags=[] 而对面有值、derived_from 缺失、bucket_zh 因 tags 空而不生成）。
+        处置：入队时把本闸收到的 meta 一并落进队列记录（`**kw` → `self.propose`，
+        口径与直接 ACCEPT 的 `add(**kw)` 同源），accept 分支既有的
+        `tags=/condition_space=/**extra` 映射即把它写回节点 fm——**两条路径元数据
+        等价**，且 review_decide 无需改动。
+
+        issue50-c F2（2026-10-01）：`node_id=None` 时 propose 造 pid 的
+        `node_id + str(…)` 抛 TypeError；按仓内既有形态（`forgetting._prefeed_id`）
+        兜底成内容派生 id，不崩且非静默（返回体 `proposed_id_fallback`）。
+
+        接线只覆盖**本闸自己**的 DEFER——
+        writelimit 限流 DEFER 在上方已 return（其语义是「先别写」，原文在
+        recent 时间线，不是内容待定），gated=False 旁路与 ACCEPT 后因
+        on_conflict=defer 降级的 DEFER（`out["conflict"]`）都不在此列。
+
         B3（2026-09-30）：MERGE 分支此前**不把 content 往下传**（`reinforce`
         也没有该槽）——近重复的第二次写入，其新正文 100% 丢弃，只有既有节点
         被强化；现传 content + session，新正文按目标缺的行追加为聚合行落盘，
@@ -3431,6 +4115,26 @@ class MdCGOS(MdCG):
         来源，`assess` :214 先于 MERGE）把新正文全文与去向记进 `_forgetting.jsonl`
         并返回 `dropped` 去向单（trace_id/sha1/检索入口）。两条分支都有处置。
         H3：合并时把写入方会话归属并列落目标 fm（`fm.merge_sources`）。
+
+        issue50-d（2026-10-02）：ACCEPT 分支**落盘=裁决值**——此前「hint 非
+        None 才透传」的口径把启发式裁决值（0.84/0.71 量级，隔离沙箱实证）
+        全部丢在闸门上，落盘一律默认 0.5；现无条件落 `imp["score"]` 并按
+        `imp["from"]` 落 `importance_source`（"hint"|"heuristic"，进 fm 与
+        索引条目）。`add` 的自动保护位只认显式声明：heuristic 过线只落分、
+        不打保护位——由此审计面文案（assess 保护分支按 from 分叉）、落盘分、
+        保护位三者首次同源一致。外部基准（hive-memory-bench v1.0）测得 L3
+        使用端损耗 3-4/19：本批让重要度轴带电（排序次级键从此拿到真分）。
+
+        补强批次（2026-10-02，复核发现 1/2 的收口）：ACCEPT 分支此前**无任何
+        档位判据**、直调 `self.add`——`gated=true`（插件自动记忆主写入通道）
+        在缺省 confirm 档对既有 node_id 直接覆写（不出变更单）、在计划档对新
+        node_id 也照样写入。现该分支落盘前先经 `_autonomy_gate_rewrite`
+        （gated 面档位判定单点，与写链 `writepipe._gate_autonomy` 同口径、
+        同一存在性单点 `forgetting.prior_node`）：C 改写 confirm/plan 出单、
+        full 放行；A 新增 confirm/full 放行（行为逐位不变）、plan fail-closed。
+        出单前先跑 `write_qualify` 资格探针——受保护/越权覆写照旧当场拒，
+        不因「改为入队」而放宽既有判据（纯加严）。出单/拒绝都写一行
+        `_forgetting.jsonl`（verdict=CONFIRM/FORBID + hint），可审计。
         """
         role = kw.get("role")
         vb = kw.get("verification_basis")
@@ -3462,6 +4166,18 @@ class MdCGOS(MdCG):
         if lim is not None:
             if lim["verdict"] == "CONVERGE":
                 tgt = lim["target"]
+                # 三档自治批次②：档位判定在**限流闸裁决之后、合并原语之前**。
+                _ag = self._autonomy_gate_merge(node_id, tgt, content, kw,
+                                               primitive="converge_into",
+                                               gate=lim)
+                if _ag is not None:
+                    forgetting.log(self, {"t": time.time(), "node_id": node_id,
+                                          "layer": layer,
+                                          "verdict": _ag["verdict"],
+                                          "reason": _ag["hint"],
+                                          "limiter": lim.get("limiter"),
+                                          "actor": self.actor})
+                    return _ag
                 out = {"verdict": "MERGE", "node_id": node_id,
                        "merged_into": tgt, "gate": lim,
                        "converged": writelimit.converge_into(
@@ -3489,8 +4205,39 @@ class MdCGOS(MdCG):
         v = verdict["verdict"]
         out = {"verdict": v, "node_id": node_id, "gate": verdict}
         if v == "ACCEPT":
-            if hint is not None and "importance" not in kw:
-                kw["importance"] = hint
+            # issue50-d（2026-10-02）：**落盘=裁决值**。此前「hint 非 None 才
+            # 透传」的口径把启发式裁决值全部丢在闸门上——隔离沙箱实证：
+            # u_heur_new 裁决 0.837/落盘 0.5、t_heur 裁决 0.711/落盘 0.5，落盘
+            # 重要度不携带任何区分信息（启发式全 0.5、插件 hint 通道全 0.6），
+            # 排序/使用端拿不到真分。现无条件落 `imp["score"]`（hint 或启发式，
+            # 均为 assess 实际使用的裁决值，含 0~1 裁剪），并按裁决来源落
+            # `importance_source`（"hint"|"heuristic"）进 fm 与索引条目——
+            # add 的自动保护位据此只认显式声明（heuristic 过线只落分、不打
+            # 保护位，与裁决②一致；writelimit 的保护豁免仍读原始 hint，不受
+            # 本批影响）。
+            kw["importance"] = verdict["importance"]["score"]
+            kw["importance_source"] = verdict["importance"]["from"]
+            # 三档自治批次②补强（2026-10-02）：**gated 面的 C 改写 / A 新增档位
+            # 判定**。此前本分支直调 `self.add`——`gated=true` 的覆写在确认档
+            # 不落任何档位判定就覆写既有节点（复核发现 1：插件自动记忆的主写入
+            # 通道可旁路确认档），计划档的新增也不被拦（发现 2）。判定与写链
+            # `writepipe._gate_autonomy` **同口径**、同一存在性单点
+            # （`forgetting.prior_node`）：既有 node_id ⇒ C 改写（confirm/plan
+            # 出单、full 放行）、不存在 ⇒ A 新增（confirm/full 放行、plan
+            # fail-closed）；出单前先跑 write_qualify 资格探针（受保护/越权覆写
+            # 照旧当场拒，不静默入队）。位置在 importance 落盘值写入之后，故
+            # 变更单载荷带的是**裁决值**（issue50-d 同源口径）。
+            _ag = self._autonomy_gate_rewrite(node_id, content, layer, kw,
+                                              override=override, gate=verdict)
+            if _ag is not None:
+                forgetting.log(self, {"t": time.time(), "node_id": node_id,
+                                      "layer": layer,
+                                      "verdict": _ag["verdict"],
+                                      "reason": _ag["hint"],
+                                      "importance": verdict["importance"],
+                                      "entropy": verdict["entropy"],
+                                      "actor": self.actor})
+                return _ag
             try:
                 out["written"] = self.add(node_id, content, layer=layer,
                                           override=override,
@@ -3508,6 +4255,24 @@ class MdCGOS(MdCG):
                     writelimit.record_accepted(self, node_id, content)
         elif v == "MERGE":
             tgt = verdict["redundancy"]["with"]
+            # 三档自治批次②：档位判定在**遗忘闸四态裁决之后、合并原语之前**
+            # （纯加严——裁决仍归 forgetting.assess，档位只决定「立即合并」还是
+            # 「出变更单」）。合并对象为空（tgt 假值）时不上报变更单：原路径
+            # 的 reinforce 也只在 tgt 为真时执行，档位不得把「无事发生」变成
+            # 「一张凭空指向空目标的单」。
+            if tgt:
+                _ag = self._autonomy_gate_merge(node_id, tgt, content, kw,
+                                                primitive="reinforce",
+                                                gate=verdict)
+                if _ag is not None:
+                    forgetting.log(self, {"t": time.time(), "node_id": node_id,
+                                          "layer": layer,
+                                          "verdict": _ag["verdict"],
+                                          "reason": _ag["hint"],
+                                          "importance": verdict["importance"],
+                                          "entropy": verdict["entropy"],
+                                          "actor": self.actor})
+                    return _ag
             out["merged_into"] = tgt
             # B3 ②（2026-09-30）：把**新正文**与写入方归属一并传下去。此前只传
             # tgt——调用方手上正握着 content 与 node_id 却不往下传，reinforce 写回
@@ -3531,6 +4296,56 @@ class MdCGOS(MdCG):
                 self, content, node_id=node_id, target=tgt, verdict=verdict,
                 layer=layer, sensitivity=kw.get("sensitivity"),
                 session=_writer_session(self, kw), actor=self.actor)
+        elif v == "DEFER":
+            # issue50-b（2026-10-01）：遗忘闸门的 DEFER 此前只写一行
+            # `_forgetting.jsonl` 留痕——**不落盘且无收件箱**（对比 DROP 分支
+            # 有 `forgetting.record_drop` 留全文 + trace_id）。第①条（issue50-a）
+            # 把半重复从「落成近似重复节点」改成 DEFER 之后，这条出口就会把
+            # 噪声缺陷换成「静默不记」缺陷。处置：接线**既有入队单点**
+            # `self.propose`——与审计/策略闸（`writepipe._gate_audit`）、一致性闸
+            # （`_gate_consistency`）**同一条入队链**（不新增第二套入队实现），
+            # 复用其 payload_hash 幂等对账（同内容重复写入不长第二条）。
+            # 只覆盖**本闸自己的** DEFER——writelimit 限流 DEFER 在上方已 return
+            # （语义是「先别写」，原文在 recent 时间线，不是内容待定）；
+            # gated=False 旁路与 ACCEPT 后 on_conflict=defer 的降级 DEFER 都不走
+            # 本分支（后者发生在 `if v == "ACCEPT"` 内，v 就地改写）。
+            # 「为何待定」写进提案的既有任意槽 extra（不新增队列字段/队列类型，
+            # 见 propose 的 `**kw → extra`）；密级随 sensitivity 一并透传，避免
+            # 声明 private 在此静默降级 internal（B2 同一漏传族）。
+            #
+            # issue50-c F1（2026-10-01，扩面修）：此前入队只带 content/layer/
+            # sensitivity，**调用方声明的其余 meta 全丢**（tags/condition_space/
+            # verification_basis/non_applicable_conditions/derived_from/relation/
+            # role…）。accept 只能从队列记录取值，于是「同一声明」下
+            # DEFER→accept 落盘的节点比「直接 ACCEPT」少掉这些键（实测 tags=[]
+            # 而对面有值、derived_from 缺失、role 缺失、bucket_zh 因 tags 空而
+            # 不生成）——同一份声明的两条落地路径元数据不等价。处置：把本闸收到
+            # 的那组 meta **随入队一并落进队列记录**（`**kw` 交给 `self.propose`：
+            # 其形参 `tags`/`condition_space`/`sensitivity`/`verify` 落 rec 专属槽，
+            # 其余键落 `extra`——与直接 ACCEPT 走 `add(**kw)` 的口径同源，不新增
+            # 队列字段/队列类型）；accept 分支早已把 `rec.tags`/`rec.condition_space`
+            # /`**extra` 映射回 `add`（mdcos.py:2573），故无需改 review_decide。
+            #
+            # issue50-c F2（2026-10-01）：`node_id=None` 时上文 `**kw` 透传依旧，
+            # 但 propose 造 pid 用 `node_id + str(time.time()) + …`——None + str
+            # 抛 TypeError。本闸的 ACCEPT/MERGE/DROP 三个出口都会经 `add` 对
+            # 非字符串 node_id 抛 ValueError（fail-closed 既有行为），唯独 DEFER
+            # 出口的入队单点会以 TypeError 崩出。处置：按仓内既有形态兜底成
+            # **内容派生 id**（`forgetting._prefeed_id` 同款——forgetting.py:879
+            # 对「无 id 候选」即用 `pre_<sha1[:12]>`，同一语义的单点复用），
+            # 使「DEFER 有收件箱」在缺 id 时同样成立、不崩；兜底事实写进返回体
+            # `proposed_id_fallback`（非静默——调用方可判、可检索），**不进
+            # forgetting 留痕行**（该行形状由 issue50-b 冻结）。
+            _why = "遗忘闸门：" + str(verdict.get("reason") or "待定复核")
+            _dup_with = (verdict.get("redundancy") or {}).get("with")
+            if _dup_with:
+                _why += "（重复对象 %s）" % _dup_with
+            _nid = node_id if isinstance(node_id, str) and node_id else \
+                forgetting._prefeed_id(content)
+            out["proposed"] = self.propose(
+                _nid, content, layer=layer, **kw, defer_reason=_why)
+            if _nid != node_id:
+                out["proposed_id_fallback"] = _nid
         # DROP 的去向留痕已由 record_drop 单点落盘（含全文/trace_id），此处只补
         # ACCEPT/MERGE/DEFER 的裁决留痕，避免同一次裁决出现两行。
         if v != "DROP":
@@ -4373,11 +5188,27 @@ class MdCGSecure(MdCGOS):
 
     # ---------- 管理：需 can_admin ----------
 
-# 生效条件：先 principal.require_admin("forget")，再转 super().forget(node_id, reason, override=override)。
-    def forget(self, node_id: str, reason: str = "", override: bool = False):
+# 生效条件：principal 在位时调用 principal.require_admin("forget")（越权抛 AccessDenied），返回 None；
+    def _forget_admin(self):
+        """删除面的**管理权限闸单点**（三档自治批次②：两个入口共用一份口径）。
+
+        为什么抽出来：`forget`（既有）与 `forget_gated`（档位路径）都必须先过
+        这道闸——`MdCGSecure` 的 can_admin 要求原先只写在 `forget` 里，档位路径
+        若直调 `_forget_apply` 就把它整个跳过了（实测：`MDCG_CAN_ADMIN=0` 的身份
+        经 `mdcg_forget` 能把节点删掉）。判据只此一份，两个入口都走它。
+        """
         self.principal.require_admin("forget")
+
+# 生效条件：先 _forget_admin()，再转 super().forget(node_id, reason, override=override)；
+    def forget(self, node_id: str, reason: str = "", override: bool = False):
+        self._forget_admin()
         return super().forget(node_id, reason, override=override)
 
+# 生效条件：先 _forget_admin()（与 forget 同序同错型——管理闸在资格闸与档位判定**之前**），再转 super().forget_gated(node_id, reason, override=override)；三档自治批次② 的 D 删除工具面路径由此把 can_admin 要求带进档位路径；
+    def forget_gated(self, node_id: str, reason: str = "", override: bool = False):
+        self._forget_admin()
+        return super().forget_gated(node_id, reason, override=override)
+
 # 生效条件：先 principal.require_admin("restore")，再转 super().restore(node_id, force=force)。
     def restore(self, node_id: str, force: bool = False):
         self.principal.require_admin("restore")