@furongjun1999/dsh-memory 0.6.1 → 0.7.1

package/md_cg/bench_e2e_locomo_qa.py

@@ -25,8 +25,14 @@
   python -X utf8 -m md_cg.bench_e2e_locomo_qa --translate   # 翻译 5882 turn + 500 问句
   python -X utf8 -m md_cg.bench_e2e_locomo_qa               # 全量 500 题 × 2 臂
   python -X utf8 -m md_cg.bench_e2e_locomo_qa --quick       # 冒烟 3 题（须先完成翻译）
-环境：DEEPSEEK_API_KEY；建议 MDCG_UNIFY_QUERY=0（中文问句含英文名时批次15归一有
-形态缺陷，见 docs/eval/端到端干扰池评测_v1.1 §4）。
+环境：DEEPSEEK_API_KEY；归一层**缺省关**（2026-09-30 使用者裁定：本层本职是让英文
+query 命中中文节点，对中文检索池是纯开销）——批次15 归一曾把中文问句的中文段
+逐字切开（中文问句含英文名时的形态缺陷，见 docs/eval/端到端干扰池评测_v1.1 §4），
+该缺陷已由 2026-09-30 作用域收窄（批次 26：只译英文内容、中文段原样）修掉：
+locomo-zh-500 定点实测 旧口径 lexical hit@1 94.4% / lexical,fuzzy 87.2% →
+收窄后 95.8% / 96.6%；而缺省关态为 96.4% / 97.2%（本脚本缺省即此态）。
+`MDCG_UNIFY_QUERY=1` 保留为**英文对照口径**（归一层显式开，95.8% / 96.6%），
+不再是缺省值（口径真源 docs/hive/检索算法口径对照_v0.1.md）。
 """
 from __future__ import annotations
 
@@ -271,7 +277,8 @@ def main(argv=None):
     cfg = {"model": a.model, "base": a.base_url, "key": key,
            "timeout": a.timeout, "workers": a.workers}
     print(f"[locomo_qa] 归一层开关 MDCG_UNIFY_QUERY="
-          f"{os.environ.get('MDCG_UNIFY_QUERY', '1')}（建议 0，见模块头注）")
+          f"{os.environ.get('MDCG_UNIFY_QUERY', '0')}（缺省关；=1 为英文对照口径，"
+          f"见模块头注）")
 
     ids, txts = load_corpus()
     answers = json.load(open(ANSWERS, encoding="utf-8"))
@@ -353,7 +360,7 @@ def main(argv=None):
     errs = sum(1 for r in rows if r.get("error"))
     print(f"判分失败 {errs} 行\n")
     summary = {"meta": {"model": a.model, "n_q": len(qs), "k": a.k,
-                        "unify": os.environ.get("MDCG_UNIFY_QUERY", "1")}}
+                        "unify": os.environ.get("MDCG_UNIFY_QUERY", "0")}}
     for arm in ("retrieval", "full_context"):
         summary[arm] = report([r for r in rows if r["arm"] == arm], arm)
     out = os.path.join(a.data_root, "results",

package/md_cg/chain.py

@@ -24,6 +24,8 @@
 """
 from __future__ import annotations
 
+import os
+
 # 边类型 → 传播权重 base（AEIS《激活引擎 v0.1》第 14 行）
 EDGE_WEIGHTS = {
     "causal": 0.85,
@@ -52,11 +54,44 @@ CAUSAL_TYPES = ("causal",)
 # 否则 causal 链会被「提到过」这类无向弱关联稀释（模式分离）。
 CHAIN_TYPES_DEFAULT = ("causal", "sequential", "applies_to")
 
+#: 边类型集可配（P3-causal，2026-10-01）：逗号分隔，大小写不敏感。
+#: 动因（设计稿 §6.2 / 交接单）——**叙事/文档语料里没有 causal 边**：按章切出来
+#: 的 doc_ref 库里只有 `reference`（弱权重 0.5，上方注释明写刻意不入默认集）与
+#: 父章节结构边（`part_of`）。边类型集若写死，因果路在这类库上**恒空**，等于
+#: 没接。故做成 env 可配，缺省仍是 `CHAIN_TYPES_DEFAULT`（缺省行为一字不变）。
+#: 约束（不得违反）：本处**只从既有 `EDGE_WEIGHTS` 里挑子集**——不新造边类型、
+#: 不写第二份权重表；未登记的形态一律剔除（剔除即回落缺省，而不是按
+#: `DEFAULT_EDGE_WEIGHT` 静默走一条没人登记过的边）。
+#:
+#: **可配面边界（P3 遗留 ④ 如实降级声明，2026-10-01）**：契约 S3 的不变量原文是
+#: 「边方向/关系类型权重可配」，实测只有前一半做成了可配，后一半**不可配**：
+#:   · **类型集**：可配（本 env）；
+#:   · **权重**：沿用**唯一表** `EDGE_WEIGHTS`（仓内「真源唯一」纪律——禁止
+#:     第二份边权表；要调权重改表，不引入第二处口径）；
+#:   · **方向**：固定为**依赖方向（出边）**（`walk(direction="out")` 为缺省，
+#:     `adjacency` 建的是出邻接；`direction="in"` 存在但不在检索路上用）。
+#: ⇒ 对 S3 ④ 属**部分满足**，不得表述为「全满足」。
+CHAIN_TYPES_ENV = "MDCG_CHAIN_TYPES"
+
 MAX_DEPTH_DEFAULT = 5
 MAX_DEPTH_HARD = 64
 MAX_NODES_DEFAULT = 500
 
 
+# 生效条件：environ（缺省 os.environ）里 CHAIN_TYPES_ENV 为真值时按逗号切分、逐项 strip().lower()、只保留 EDGE_WEIGHTS 里登记过的形态；结果为空（未设 / 全是不认识的名字 / 只有空项）时回落 CHAIN_TYPES_DEFAULT。返回小写元组（顺序 = env 声明序）。
+def chain_types_from_env(environ=None):
+    """关系链边类型集的**唯一读取点**（检索 chain 路与显式调用方共用）。
+
+    形态与 `MDCG_SPREAD_DECAY` 同款：env 缺失 / 非法 → 回落缺省，不抛异常。
+    """
+    raw = (environ or os.environ).get(CHAIN_TYPES_ENV)
+    if not raw:
+        return CHAIN_TYPES_DEFAULT
+    kept = tuple(t for t in (str(x).strip().lower() for x in str(raw).split(","))
+                 if t in EDGE_WEIGHTS)
+    return kept or CHAIN_TYPES_DEFAULT
+
+
 # 生效条件：edge 为 dict 时按 relation_type→relation→type 顺序取首个真值、非 dict 时 rel 记为 None，两者统一返回 str(rel or "").strip().lower()——键缺失或全为假值时得空串。
 def edge_rel(edge):
     """取边的 relation_type（兼容 dict / 字符串两种写法），统一小写。"""
@@ -130,6 +165,18 @@ def adjacency(cg, include_hierarchy=True):
     来源两处：
       1. 节点 frontmatter.edges（关系边，含 relation_type）
       2. 节点 frontmatter.subgraph.nodes（层级边，合成 part_of）
+
+    **代价口径（P3 遗留 ⑥ 如实降级声明，2026-10-01）**：本函数**不读正文**
+    （`subgraph._fm` 优先走索引快照，条目带 `subgraph` 键即零 IO），但其构建是
+    **O(N) 索引条目级**——`for nid in nodes` 遍历的是**全部索引节点**
+    （`cg.index["nodes"]`），不是「只碰种子邻域」。故契约 S3「不走全表」这一句
+    对**本函数不成立**，正确表述是「不读正文；邻接构建为 O(N) 索引条目级」。
+    代价读数（`scripts/p2p4_probe.py` R7，400 条目确定性小库）：冷建 ~0.24ms、
+    缓存命中 ~1µs；缓存键 `(include_hierarchy, 闸存在位)` 存于 `cg._chain_adj`，
+    写入/删除后由 `invalidate_cache` 作废。
+    （可选硬化路径 (b1)：在索引快照的**边集合**上增量构建邻接——本轮未做，
+    如需做见 P3 遗留 B 的二选一。）
+
     只读索引快照，不读文件正文；结果缓存在 `cg._chain_adj`。
 
     读隔离（2026-09-25）：cg._chain_visible(nid) 谓词在位（MdCGSecure 注入，

package/md_cg/consistency.py

@@ -59,10 +59,21 @@ from .mdcg import expand_query_terms_weighted
 LOG_FILE = "_consistency.jsonl"
 
 MAX_SCAN = 200       # 单次检测最多比对的既有节点数（防 O(N) 爆炸）
+                     # cons200（2026-10-03）：本值是**相关面/保底面各自的限额**，不是
+                     # 「索引序前 N」——数值一字未动（契约禁止面）；超限走可观测
+                     # （truncated/kept/hint），修法是选面与预筛，不是调大本值。
 MAX_DEPTH = 3        # L2 递归深度上限（对齐 :273）
 MAX_NODES = 60       # L2 递归展开节点上限（对齐 :273）
 MIN_GAIN = 0.15      # 信息增益门槛：候选空间减少比例低于此值即停（对齐 :273）
 
+# 截断可操作提示（cons200：与 stg `_CAP_HINT` 同口径精神——禁止静默）——文案必须
+# 含「细化生效条件/不适用条件」与「建立条件索引」语义；数值放大（调 limit/MAX_SCAN）
+# 不是修法，故明文劝阻。
+_SCAN_HINT = ("候选 %s 条超过单次检测限额 limit=%s，已按相关性保留 %s 条"
+              "（截断不静默）：请细化生效条件/不适用条件收窄候选集，"
+              "或按设计稿建立条件索引（docs/plans/stg条件化与结构索引_设计_v0.1.md）"
+              "——不要调大 limit/MAX_SCAN 数值。")
+
 CLASH_HIGH = 0.6     # 条件互相覆盖阈值 → 明确互斥
 CLASH_LOW = 0.35     # 条件部分覆盖阈值 → 待定
 SELF_NEGATION = 0.5  # 自否定阈值：负条件被自身正文强命中
@@ -303,6 +314,53 @@ def _slot_text(content):
             _ccg_field(content or "", "子功能"))
 
 
+# --------------------------------------------------------------------------
+# 选面支持件（cons200）：相关性预筛打分（快照级，不读盘）
+# --------------------------------------------------------------------------
+
+# 生效条件：e 为索引快照条目、nid 为节点 id、tw_pos/tw_neg 为 {词: 权重}（可为空）、cov 为 _weighted_coverage 同签名函数、disc 为 _is_discipline 的预判结果（None 时按 `_is_discipline({"tags": e.get("tags")}, nid)` 现算）——只读条目内既有键（tags/rejection_terms），恒返回整数二元组 (rank, score)：disc 真 → (3, 0)；否则 rejection_terms 与 tw_pos/tw_neg 有整词子串交集 → (2, int(round(1e4 * max(双方 _cov)) ))；仅 rejection_terms 非空 → (1, 0)；其余 → (0, 0)；不读盘、不解析正文、不调用 cg.get。
+def _sift_score(e, nid, tw_pos, tw_neg, cov, disc=None):
+    """候选相关性打分（**只排序，不裁决**）——选面的廉价预筛单点。
+
+    为什么需要它（cons200 = 设计稿签收点 5）：修前选面是 `list(nodes.items())`
+    的索引序前 MAX_SCAN——库超限后 id 字典序靠后的记忆节点（`mem_*`）几乎从不
+    进入比对面；而在役库前 200 名基本全是 `code_*` 索引节点。修后按**相关性**
+    （本函数）排序取前 limit，让「可能与本内容构成条件冲突」的候选优先入面。
+
+    信号与廉价性（全部来自索引快照既有键，零读盘、零正文解析）：
+      · `tags`（`_is_discipline` 单点判纪律）——纪律违反是硬冲突（REJECT），
+        且其命中走 `_ban_hit` 子串判定、不走词权，故纪律候选 rank 最高（3）；
+      · `rejection_terms`（**不适用条件**的索引词项，由既有单点
+        `mdcg.rejection_index_terms` 生成——不新造第二套解析）：与本次内容的
+        条件词面（tw_pos/tw_neg）做整词交集（`in` 子串，C 速度），命中即
+        rank 2 并以 `_weighted_coverage`（既有单点）给连续分；非空但无交集
+        rank 1（弱迹象：该节点确有负条件声明）。
+    诚实边界（不假装全知）：本键只覆盖**负条件面**（新正↔旧负 / 新负↔旧负）。
+    「旧节点只声明生效条件（e_pos）」的比对面在快照里**无字段可判**（`_declared`
+    还要读 content 的 `# 生效条件：` 行）——故本函数不做任何剔除，只做排序；
+    信息不足的候选按 rank 0 落在相关面尾部、并在候选超限时由**保底面**
+    （修前扫描面 ∩ 候选，逐位保留）兜底，二者共同保证「修后检出 ⊇ 修前」。
+    """
+    if disc is None:
+        disc = _is_discipline({"tags": e.get("tags")}, nid)
+    if disc:
+        return 3, 0
+    rt = e.get("rejection_terms") or []
+    if not rt:
+        return 0, 0
+    blob = " ".join(str(t) for t in rt)
+    hit = False
+    if tw_pos:
+        hit = any(str(t) in blob for t in tw_pos)
+    if not hit and tw_neg:
+        hit = any(str(t) in blob for t in tw_neg)
+    if not hit:
+        return 1, 0
+    s1 = cov(tw_pos, blob) if tw_pos else 0.0
+    s2 = cov(tw_neg, blob) if tw_neg else 0.0
+    return 2, int(round(10000 * max(s1, s2)))
+
+
 # --------------------------------------------------------------------------
 # L0 情绪通道（信息差二阶变化）
 # --------------------------------------------------------------------------
@@ -426,7 +484,7 @@ def _recursive_reflect(cg, seeds, tw_pos, tw_neg, max_depth=MAX_DEPTH,
 # 主入口：三级决策
 # --------------------------------------------------------------------------
 
-# 生效条件：以 cg.index.nodes 为既有节点、content（假值按 ""）经 _new_terms 得 pos/neg 并算 tw_pos/tw_neg（non_applicable_conditions 入参先按 mdcos._is_null_condition 剔除空值语义哨兵——⑧ 漏斗单点），按循环中 hard（自否定或纪律命中）→ divergences（同条件槽且 concl < CONCLUSION_SAME）→ strength ≥ CLASH_HIGH → strength ≥ CLASH_LOW → comparable==0 且 (pos or neg) → 否则 ACCEPT 的顺序定 verdict；DEFER 且 int(depth)>0 且 emo["bias"] != "approaching" 时调 _recursive_reflect 补 recursion，auto_flywheel 且 verdict == REJECT 时加 unresolved_id，最后 log 并返回 rec；
+# 生效条件：以 cg.index.nodes 为既有节点、content（假值按 ""）经 _new_terms 得 pos/neg 并算 tw_pos/tw_neg（non_applicable_conditions 入参先按 mdcos._is_null_condition 剔除空值语义哨兵——⑧ 漏斗单点）；选面（cons200；收口轮①加面内例外）：快照级预筛剔「tw_pos 与 tw_neg 皆空（新节点未声明可展开条件）时的非纪律候选」，且**剔除永不触及修前扫描面**（过滤后索引序前 limit 内候选一律保留——面内例外；「修后检出 ⊇ 修前」由此成为与「条目 tags 与盘面 fm.tags 同源」无关的结构保证），候选超 limit 时精比面＝相关面（_sift_score 序）前 limit ∪ 保底面（过滤后索引序前 limit ∩ 候选），记 scanned（候选数）/kept（精比数）/truncated（scanned>kept）/hint；按循环中 hard（自否定或纪律命中）→ divergences（同条件槽且 concl < CONCLUSION_SAME）→ strength ≥ CLASH_HIGH → strength ≥ CLASH_LOW → comparable==0 且 (pos or neg) → 否则 ACCEPT 的顺序定 verdict；DEFER 且 int(depth)>0 且 emo["bias"] != "approaching" 时调 _recursive_reflect 补 recursion，auto_flywheel 且 verdict == REJECT 时加 unresolved_id，最后 log 并返回 rec；
 def check(cg, content, layer=None, condition_space=None,
           non_applicable_conditions=None, tags=None, exclude=None,
           limit=MAX_SCAN, depth=MAX_DEPTH, auto_flywheel=False,
@@ -436,6 +494,7 @@ def check(cg, content, layer=None, condition_space=None,
     返回完整判据（可审计）：
       verdict / reason / conflict_strength / emotional / conflicts[] /
       recursion{} / missing[] / unresolved_id（若触发飞轮）
+      + 选面读数 scanned / kept / truncated（超限时另附 hint）
 
     verdict：
       ACCEPT    无冲突，或新节点未声明条件（无从冲突）
@@ -443,6 +502,36 @@ def check(cg, content, layer=None, condition_space=None,
       DEFER     条件互斥但可能可分辨（交给 L2 递归或飞轮）
       BLINDSPOT 有条件声明，但既有节点全无声明 → 无法建立比对路径（不假装确定）
 
+    选面（cons200，2026-10-03；设计稿签收点 5；收口轮① 2026-10-03 复核 DEFER
+    后补面内例外）：
+      修前＝`list(nodes.items())` 索引序前 limit 并静默 break——在役库 17882
+      节点 ⇒ 检测面 ≈1.1%，且 id 字典序最前的 `code_*` 索引节点占满名额，
+      真正相关的记忆节点（`mem_*` 在字典序后段）几乎从不进入比对面。修后：
+        · 预筛（快照级、不读盘）：`_sift_score` 只读条目既有键（tags /
+          rejection_terms），不做任何「信息不足」的剔除——唯一剔除档是
+          **可证无产出且不落修前扫描面**的「tw_pos 与 tw_neg 皆空（新节点
+          未声明可展开条件）时的非纪律候选」（c1/c2/c3/c4 与分歧判定都以
+          tw_* 为乘子；纪律违反走 `_ban_hit` 子串、不看词权，故纪律候选
+          一律保留）。**面内例外（收口轮①）**：剔除永不触及修前扫描面
+          （过滤后索引序前 limit 内的候选一律保留进候选面、落保底面通道）
+          ——「修后检出 ⊇ 修前」由此是**与「条目 tags 与盘面 fm.tags
+          同源」无关的结构保证**（预筛读条目快照，而精比读盘面；非同源
+          形态下面内候选仍进精比面、由盘面判据裁决）。
+        · 精比面＝相关面（`_sift_score` 序）前 limit ∪ **保底面**（过滤后
+          索引序前 limit ∩ 候选，逐位＝修前扫描面）。保底面不撤是「修后检出
+          ⊇ 修前」的结构性保证（不是概率）；两面上限各 limit（≤2×MAX_SCAN）。
+        · 可观测：`scanned`＝预筛后候选数、`kept`＝实际精比数、`truncated`＝
+          scanned>kept（截断不静默，附 `hint` 给细化条件/建索引方向）。
+      诚实边界：`rejection_terms` 只覆盖负条件面；「旧节点仅声明生效条件
+      （e_pos，正文 `# 生效条件：` 行）」在快照里无字段可判——此类节点在
+      候选超限且不落修前扫描面/保底面时可能不被精比（由 truncated 可观测）。
+      非同源形态（盘面 tags 与索引条目不一致，非合作写者直改 `.md` 不重建
+      索引）分两段：**面内**（修前扫描面内）由面内例外保底、精比读盘面判定，
+      修后仍检出（不构成回归）；**面外残余**（条目未标纪律、盘面是纪律的
+      节点落修前扫描面之外）修前亦检不出——不构成回归，属已声明边界
+      （预筛读索引条目快照；协作写者协议下条目与盘面同源，无此形态）。
+      判据本身（阈值/覆盖计算/四态路由）一字未动——本批只改**选面与读数**。
+
     non_applicable_conditions（⑧ 2026-09-30）：入参里的**空值语义哨兵**
     （`["无"]` / `["（无）"]` / `[""]`…）在本函数的入口统一剔除——判据复用
     `mdcos._is_null_condition`（仓内唯一哨兵表，**不新造第二张词表**）。
@@ -475,7 +564,7 @@ def check(cg, content, layer=None, condition_space=None,
     n_fn, n_sb = _slot_text(content)
 
     conflicts, hard, divergences = [], [], []
-    strength, scanned, comparable = 0.0, 0, 0
+    strength, comparable = 0.0, 0
 
     # ---- L1-a 自否定：自己的负条件排除自己的生效条件/正文 ----
     body = _body_text(content)
@@ -491,16 +580,47 @@ def check(cg, content, layer=None, condition_space=None,
         strength = max(strength, round(_cov(tw_neg, body), 4))
 
     # ---- L1-b 与既有节点的条件级比对（反题） ----
+    # 选面（cons200）：预筛（快照级，不读盘）→ 候选面 → 相关面 ∪ 保底面。
     nodes = ((getattr(cg, "index", None) or {}).get("nodes") or {})
-    seeds = []
-    for nid, e in list(nodes.items()):
+    order = list(nodes.items())          # 索引序快照（H-4(a)：快照后再迭代）
+    lim = max(0, int(limit))
+    no_terms = not (tw_pos or tw_neg)    # 新节点未声明可展开条件
+    cand = []                            # (rank, score, in_before, nid, e)
+    fidx = 0
+    for nid, e in order:
         if exclude and nid == exclude:
             continue
         if layer and e.get("layer") != layer:
             continue
-        if scanned >= int(limit):
-            break
-        scanned += 1
+        in_before = fidx < lim           # 是否在修前扫描面内（过滤后前 limit）
+        fidx += 1
+        disc = _is_discipline({"tags": e.get("tags")}, nid)
+        # 预筛唯一剔除档（可证无产出；其余一律放行——宁多勿漏）：
+        # 新节点未声明可展开条件时，非纪律候选在精比中产出恒为零
+        # （c1/c2/c3/c4 与分歧判定均以 tw_pos/tw_neg 为乘子；纪律违反走
+        # _ban_hit 子串判定、不看词权——故纪律候选一律保留）。
+        # 收口轮①（复核 DEFER 后补）：**面内例外**——剔除永不触及修前扫描面
+        # （过滤后索引序前 limit 内的候选一律保留），使「修后检出 ⊇ 修前」
+        # 成为与「条目 tags 与盘面 fm.tags 同源」无关的结构保证（非同源形态
+        # 下面内候选仍进精比面、由盘面判据裁决）；面外非同源残余见 check
+        # docstring 诚实边界（修前亦检不出，不构成回归）。
+        if no_terms and not disc and not in_before:
+            continue
+        rank, score = _sift_score(e, nid, tw_pos, tw_neg, _cov, disc)
+        cand.append((rank, score, in_before, nid, e))
+    # 相关面：rank/score 降序 + id 升序终键（确定性；与索引物理序无关）
+    rel = sorted(cand, key=lambda t: (-t[0], -t[1], str(t[3])))[:lim]
+    rel_ids = {t[3] for t in rel}
+    # 精比面＝相关面 ∪ 保底面（过滤后索引序前 limit ∩ 候选）——保底面即
+    # 修前扫描面；其逐位保留是「修后检出 ⊇ 修前」的结构性保证（非概率），
+    # 两面上限各 limit（≤ 2×MAX_SCAN；MAX_SCAN 数值未动）。
+    scan_face = [(t[3], t[4]) for t in rel]
+    scan_face += [(t[3], t[4]) for t in cand if t[2] and t[3] not in rel_ids]
+    scanned = len(cand)                  # 预筛后候选数（截断前）
+    kept = len(scan_face)                # 实际精比数（相关面 ∪ 保底面）
+    truncated = scanned > kept
+    seeds = []
+    for nid, e in scan_face:
         node = cg.get(nid) or {}
         fm = node.get("frontmatter") or {}
         body = node.get("content") or ""
@@ -630,9 +750,14 @@ def check(cg, content, layer=None, condition_space=None,
     rec = {"t": time.time(), "layer": layer, "verdict": verdict,
            "reason": reason, "conflict_strength": round(strength, 4),
            "emotional": emo, "conflicts": allc, "recursion": recursion,
-           "missing": missing, "scanned": scanned, "comparable": comparable,
+           "missing": missing, "scanned": scanned, "kept": kept,
+           "truncated": truncated, "comparable": comparable,
            "pos": pos[:6], "neg": neg[:6],
            "actor": getattr(cg, "actor", "unknown")}
+    # 截断不静默（与 stg `_with_scan_reads` 同口径精神）：候选有被限额丢弃时
+    # 附可操作 hint（细化条件 / 建索引方向；数值放大不是修法）。
+    if truncated:
+        rec["hint"] = _SCAN_HINT % (scanned, lim, kept)
 
     # ---- 冲突自动触发飞轮（误差 → 补条件 → 结构更新） ----
     # H11⑥（2026-09-30）：**只对真冲突（REJECT）建单**。改前是

package/md_cg/forgetting.py

@@ -33,7 +33,7 @@
                                         噪音，不该去强化既有记忆（否则例行日志
                                         会把普通记忆刷成高重要性）
     3) 冗余 ≥0.85             → MERGE ← 外部/未知来源的重复 = 又一次确认，强化
-    4) 半重复 且 不重要       → DEFER
+    4) 半重复 且 未触发保护   → DEFER ← 与重要度无关：半重复是「变更确认」的输入端
     5) 重要度 ≥0.30           → ACCEPT
     6) 新信息 ≥0.15           → ACCEPT
     7) 其余                   → DEFER
@@ -236,7 +236,7 @@ def importance_score(hint, novelty, kind, content):
     return {"score": round(max(0.0, min(1.0, s)), 4), "from": "heuristic"}
 
 
-# 生效条件：以 source_kind(role,verification_basis) 的 kind 与 redundancy(cg,content,layer=layer,exclude=node_id) 的 red["max"] 为输入，按 if/elif 顺序取首个命中分支——imp["score"]≥PROTECT_IMPORTANCE→"ACCEPT"；否则 kind=="internal_deterministic" 且 red["max"]≥DUP_DROP→"DROP"；否则 red["max"]≥DUP_MERGE→"MERGE"；否则 red["max"]≥DUP_DROP 且 imp["score"]<IMPORTANCE_MIN→"DEFER"；否则 imp["score"]≥IMPORTANCE_MIN→"ACCEPT"；否则 novelty≥NOVELTY_MIN→"ACCEPT"；否则→"DEFER"。返回体附带 P-9b 可见性字段：entropy.overwrite_of / entropy.overwrite_ratio（同 id 覆写时非 null）、dedup_skipped（**仅 PROTECT 分支**非 null，标注「因保护优先未走去重」+ 去重判据读数）——两者都不改 verdict、不改落盘行为。
+# 生效条件：以 source_kind(role,verification_basis) 的 kind 与 redundancy(cg,content,layer=layer,exclude=node_id) 的 red["max"] 为输入，按 if/elif 顺序取首个命中分支——imp["score"]≥PROTECT_IMPORTANCE→"ACCEPT"（reason 按 imp["from"] 分叉：hint→「触发不可遗忘保护」，heuristic→「未落保护——保护须显式声明」，issue50-d）；否则 kind=="internal_deterministic" 且 red["max"]≥DUP_DROP→"DROP"；否则 red["max"]≥DUP_MERGE→"MERGE"；否则 red["max"]≥DUP_DROP→"DEFER"（**与 imp 无关**）；否则 imp["score"]≥IMPORTANCE_MIN→"ACCEPT"；否则 novelty≥NOVELTY_MIN→"ACCEPT"；否则→"DEFER"。返回体附带 P-9b 可见性字段：entropy.overwrite_of / entropy.overwrite_ratio（同 id 覆写时非 null）、dedup_skipped（**仅 PROTECT 分支**非 null，标注「因保护优先未走去重」+ 去重判据读数）——两者都不改 verdict、不改落盘行为。
 def assess(cg, content, layer="contextual", role=None, verification_basis=None,
            importance_hint=None, node_id=None):
     """三问 → 四态裁决。返回完整判据（可审计，不只给结论）。
@@ -261,6 +261,27 @@ def assess(cg, content, layer="contextual", role=None, verification_basis=None,
           关键正文并入他节点、检索归属漂移——风险高于收益；③ 缺陷本体是「绕过
           去重而不可见」而非「保护存在」，标注即可消除静默且零回归面
           （test_p9_forget_protect.py 的「importance_hint≥0.7→ACCEPT」逐字不变）。
+
+    issue50-d（2026-10-02）：保护分支的 reason 文案按 **imp["from"] 分叉**——
+    改前启发式路径（不传 hint）过线时也声称「触发不可遗忘保护」，但落盘面
+    importance=0.5（默认）且无保护位（隔离沙箱直读 frontmatter 实证：
+    u_heur_new 裁决 0.837/落盘 0.5；t_heur 裁决 0.711/落盘 0.5）——审计面在
+    声称未发生的事。处置：from=="hint" 且 ≥0.7 维持原文案（add 的自动保护位
+    对显式声明真落 protected 位，文案与落盘一致）；from=="heuristic" 且 ≥0.7
+    改为如实文案「启发式 …（未落保护——保护须显式声明）」。裁决面 verdict、
+    分支顺序、常量均不变；落盘口径的修复在 remember_gated ACCEPT 分支
+    （mdcos.py：落盘=裁决值 + importance_source 标注来源）。
+
+    issue50-a（2026-10-01）：分支 ④「半重复 → DEFER」此前写作
+    `red["max"] >= DUP_DROP and imp["score"] < IMPORTANCE_MIN`，**结构性不可达**：
+    用户角色属外部惊奇来源（`SOURCE_WEIGHT["external_surprising"]=1.00`），启发式
+    重要度 = 0.5·novelty + 0.3·1.00 + 0.2·lf ⇒ 基线恰为 0.30 = IMPORTANCE_MIN，
+    且比较用 `>=`；插件侧还显式传 `hint=0.6`（同样 ≥0.30）。实测：重复度 0.7324 /
+    0.7606 的半重复内容一律走分支 ⑤ 判 ACCEPT，`_forgetting.jsonl` 的 DEFER 计数为
+    0（在役库 215 条留痕：ACCEPT 201 / MERGE 14）——本应是「变更确认」输入端的
+    那条回路从不产生输入。处置：**删去 `and imp["score"] < IMPORTANCE_MIN`**，
+    半重复（且未触发保护）一律 DEFER，与重要度解耦。分支顺序与其余六条分支的
+    判据/文案均不变，保护优先（①）仍最先，故保护面零回归。
     """
     kind = source_kind(role, verification_basis)
     red = redundancy(cg, content, layer=layer, exclude=node_id)
@@ -294,8 +315,19 @@ def assess(cg, content, layer="contextual", role=None, verification_basis=None,
         if red["with"] and red["max"] >= DUP_MERGE:
             due.append("与 %s 重复度 %.2f≥%.2f（够 MERGE 阈值）"
                        % (red["with"], red["max"], DUP_MERGE))
-        verdict, why = "ACCEPT", (f"重要度 {imp['score']:.2f}≥{PROTECT_IMPORTANCE}"
-                                 f"（触发不可遗忘保护）")
+        # issue50-d（2026-10-02）：文案按来源分叉——`imp["from"]` 就在手上的
+        # imp 里，单点可判。显式 hint 维持「触发不可遗忘保护」（add 的自动
+        # 保护位会真落 protected 位，文案与落盘一致）；启发式过线**只落分、
+        # 不打保护位**（issue50-d 裁决②：保护须显式声明），文案改成如实
+        # 表述——改前启发式 0.84 也声称「触发不可遗忘保护」，而落盘面
+        # importance=0.5 且无保护位（隔离沙箱实证），审计面在声称未发生的事。
+        # 分支顺序与 verdict 不变（硬边界：issue50-a 的那行除外，本批不动）。
+        if imp["from"] == "hint":
+            verdict, why = "ACCEPT", (f"重要度 {imp['score']:.2f}≥{PROTECT_IMPORTANCE}"
+                                      f"（触发不可遗忘保护）")
+        else:
+            verdict, why = "ACCEPT", (f"启发式 {imp['score']:.2f}≥{PROTECT_IMPORTANCE}"
+                                      f"（未落保护——保护须显式声明）")
         dedup_skipped = {
             "reason": "protect_importance",
             "detail": ("保护优先分支排在冗余判定之前：本次未走 MERGE/DROP"
@@ -315,9 +347,9 @@ def assess(cg, content, layer="contextual", role=None, verification_basis=None,
     elif red["max"] >= DUP_MERGE:
         verdict, why = "MERGE", (f"重复度 {red['max']:.2f}≥{DUP_MERGE}"
                                 f"（并入 {red['with']}，强化既有）")
-    elif red["max"] >= DUP_DROP and imp["score"] < IMPORTANCE_MIN:
+    elif red["max"] >= DUP_DROP:
         verdict, why = "DEFER", (f"半重复 {red['max']:.2f}∈[{DUP_DROP},{DUP_MERGE})"
-                                f" 且重要度 {imp['score']:.2f}<{IMPORTANCE_MIN}"
+                                f" 且未触发不可遗忘保护"
                                 f"（待定复核）")
     elif imp["score"] >= IMPORTANCE_MIN:
         verdict, why = "ACCEPT", f"重要度 {imp['score']:.2f}≥{IMPORTANCE_MIN}"