@furongjun1999/dsh-memory 0.5.1 → 0.6.1

package/md_cg/chain.py

@@ -147,7 +147,7 @@ def adjacency(cg, include_hierarchy=True):
     from . import subgraph as _sg
     nodes = ((getattr(cg, "index", None) or {}).get("nodes") or {})
     adj = {}
-    for nid in nodes:
+    for nid in list(nodes):
         if vis is not None and not vis(nid):
             continue          # 不可见节点：其出边与条件整体不可见（不解析 fm）
         fm = _sg._fm(cg, nid)

package/md_cg/consistency.py

@@ -32,8 +32,11 @@
     L1 反思    ：一次条件级冲突检测（自否定 / 纪律违反 / 条件互斥）→ 四态
     L2 递归反思：L1 未决 → 沿关系链递归找「区分条件」；受深度/节点数/循环/增益门槛约束
 
-冲突自动触发飞轮：verdict ∈ {REJECT, DEFER, BLINDSPOT} 且 auto_flywheel →
+冲突自动触发飞轮：verdict == REJECT（**真冲突**）且 auto_flywheel →
     `cg.flywheel_step({query, expected_state:"ACCEPT", actual_state:verdict, missing})`
+    （H11⑥ 2026-09-30：DEFER/BLINDSPOT 不再自动建单——DEFER 是「待确认」、
+    BLINDSPOT 是「检测前提不存在（无可比对节点，空库上恒成立）」，二者都不是
+    已判定的冲突；把待确认写成待办工单只是把误判固化。判定本身仍如实返回。）
 
 留痕 `_consistency.jsonl`（append-only）：每条判定可审计「为什么冲突 / 为什么放行」。
 
@@ -70,6 +73,10 @@ SAME_COND_HIGH = 0.75   # 同侧条件重合 → 判定「同一条件空间」
 # 实测结论槽（子功能）：同槽 1.0 / 同主语异属性 0.14 / 异主题 0.0 → 0.6 可分
 SLOT_HIGH = 0.6         # 结论槽（功能名/子功能）重合 → 判定「同一件事」
 # 实测：逐字重复 1.0 / 同槽不同值 0.61 / 同值异措辞 0.74 → 0.95 只排除逐字重复
+# H8（2026-09-30）：两侧先过同一套空白归一化（`_norm_ws`）再比；且去空白后逐字
+# 相同者直接短路为「重复」。阈值本身**不动**——纯空白差异（探针实测未归一化时
+# 0.9145~0.9436）曾把「同条件·同槽」压到 0.95 以下造成假冲突，修法是消除口径
+# 不对称，不是放宽 0.95（放宽到 0.9436 以下才能救，会一并吞掉真分歧）。
 CONCLUSION_SAME = 0.95  # 正文几乎逐字相同 → 属「重复」（该合并），不算冲突
 
 EMO_AVOID = 0.70     # 冲突强度 ≥ 此值 → avoiding
@@ -80,6 +87,12 @@ DISCIPLINE_TAGS = ("discipline", "纪律", "work_discipline", "rule", "规则",
 
 VERDICTS = ("ACCEPT", "REJECT", "DEFER", "BLINDSPOT")
 
+#: 自动建单（飞轮）**唯一**的触发态——只有真冲突才落 unresolved（H11⑥，2026-09-30）。
+#: 改前是 ("REJECT","DEFER","BLINDSPOT")：DEFER=「条件互斥/部分覆盖、待确认」、
+#: BLINDSPOT=「无节点可比对（检测前提不存在）」——都不是「已判定的冲突」。
+#: 单点：`check()` 与 `catalog()` 都读本元组。
+FLYWHEEL_TRIGGERS = ("REJECT",)
+
 
 # 生效条件：以 verdict 与 reason 构造异常（消息 `[{verdict}] {reason}`），conflicts 传假值（None/空容器等，源码 `conflicts or []`）时 self.conflicts 为 []，传真值时原样保留；
 class ConsistencyError(Exception):
@@ -243,6 +256,37 @@ def _body_text(content):
     return "\n".join(out)
 
 
+# 生效条件：text 假值时按空串处理，返回把任意连续空白（半角/全角空格、\t、\r、\n）折叠为单个半角空格并去掉首尾空白后的字符串；纯空白文本返回空串 "";
+def _norm_ws(text):
+    """空白归一化（仓内既有惯用法 `" ".join(x.split())`，见 writelimit.py:233
+    与 tool_face.py:136）——结论比对**两侧必须同一套**。
+
+    为什么需要（H8）：结论文本是被 `expand_query_terms_weighted` 当作**一个整段
+    加权词**（`mdcg.py` 整句 `put(q, 1.0)`）+ 若干分词来比对的，而 `_term_degree`
+    对「非整段命中」只给子串回退分 `0.5·L/n`。两侧若只差空白（`\r\n`↔`\n`、尾部
+    多换行、行首缩进（半角/全角）、插空行、行尾空格、词间多空格），整段词就只能
+    拿到部分分，`conclusion_overlap` 掉到 0.95 以下 → 被误判成「同条件·同槽·取值
+    不同」（假冲突 + 假 unresolved 工单）。两侧先经同一归一化，纯空白差异不再进入
+    结论比对。
+    """
+    return " ".join((text or "").split())
+
+
+# 生效条件：text 假值时按空串处理，返回去掉全部空白字符（半角/全角空格、\t、\r、\n 等 str.split() 认可的空白）后的字符串；纯空白文本返回空串 "";
+def _nows(text):
+    """去掉**全部**空白——只用于「两侧差异是不是只在空白」的相等短路判定。
+
+    与 `_norm_ws` 的分工：`" ".join(x.split())` 只折叠空白，**词内插空白**
+    （「指数退避重连」↔「指数 退避重连」）归一化后仍非逐字相同（探针实测该情形
+    归一化覆盖率 0.9388 < 0.95，仍会判分歧）；去掉空白才判得出「差异只在空白」。
+
+    安全性：它只用于**相等**判定（相等 ⇒ 必判重复），不参与覆盖率计算，故不会
+    放宽「同槽不同值 / 同值异措辞」这两类真分歧——它们的差异不是空白，去空白后
+    仍不相等，照旧走 `conclusion_overlap < CONCLUSION_SAME` 的判据。
+    """
+    return "".join((text or "").split())
+
+
 # 生效条件：content 给出时（假值按空串）解析 CCG 的 `# 功能名` 与 `# 子功能` 字段并返回两者；
 def _slot_text(content):
     """结论槽：CCG 声明的 `# 功能名` / `# 子功能`（结构字段，非正文词面）。
@@ -382,7 +426,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，按循环中 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,DEFER,BLINDSPOT} 时加 unresolved_id，最后 log 并返回 rec；
+# 生效条件：以 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；
 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,
@@ -398,17 +442,35 @@ def check(cg, content, layer=None, condition_space=None,
       REJECT    硬冲突：自否定 / 违反纪律
       DEFER     条件互斥但可能可分辨（交给 L2 递归或飞轮）
       BLINDSPOT 有条件声明，但既有节点全无声明 → 无法建立比对路径（不假装确定）
+
+    non_applicable_conditions（⑧ 2026-09-30）：入参里的**空值语义哨兵**
+    （`["无"]` / `["（无）"]` / `[""]`…）在本函数的入口统一剔除——判据复用
+    `mdcos._is_null_condition`（仓内唯一哨兵表，**不新造第二张词表**）。
+    为何修在漏斗而不是各调用点：本函数是全部入口（`MdCG.add` 直连
+    `consistency.check`、`MdCGOS.check_consistency`、写链 `writepipe`）的
+    公共汇聚点，只改一处即可同口径；此前 mdcos 侧已在 `_ccg_field` 与
+    `check_consistency` 两处收口，而 `mdcg.add` 的直连绕过了它们——实测
+    `consistency.check(..., non_applicable_conditions=["无"])` 仍判
+    DEFER/strength=1.0 并建工单，同一内容不传该列表则 ACCEPT/0.0/无工单。
     """
     _ccg_field, _declared, _neg_hit, _cov = _prims()
     content = content or ""
+    # ⑧：哨兵剔除单点（延迟导入，避免 consistency ← mdcos 的模块级循环依赖）。
+    if non_applicable_conditions:
+        from .mdcos import _is_null_condition
+        non_applicable_conditions = [x for x in non_applicable_conditions
+                                     if not _is_null_condition(x)]
     pos, neg = _new_terms(content, condition_space, non_applicable_conditions)
     tw_pos = expand_query_terms_weighted(" ".join(pos)) if pos else {}
     tw_neg = expand_query_terms_weighted(" ".join(neg)) if neg else {}
     # 结论文本词权（结论比对专用）：**去 CCG 声明行**。模板行（`# 功能名` /
     # `# 子功能` 等）在两条节点间逐字相同，若混入会稀释结论覆盖率——实测
     # 逐字重复仅 0.32、同槽不同值 0.61，与异属性（0.62）不可分。去模板才可判。
-    tw_content = (expand_query_terms_weighted(_body_text(content))
-                  if content else {})
+    # H8：**两侧还要同一套空白归一化**（`_norm_ws`）——见 `_norm_ws` 说明；
+    # `n_body_tight` 是去全部空白的形态，只供 L1-c 的相等短路用。
+    n_body = _body_text(content)
+    tw_content = expand_query_terms_weighted(_norm_ws(n_body)) if n_body else {}
+    n_body_tight = _nows(n_body)
     # 结论槽（CCG 结构字段）——「是否同一件事」的代理，见 _slot_text 说明
     n_fn, n_sb = _slot_text(content)
 
@@ -431,7 +493,7 @@ def check(cg, content, layer=None, condition_space=None,
     # ---- L1-b 与既有节点的条件级比对（反题） ----
     nodes = ((getattr(cg, "index", None) or {}).get("nodes") or {})
     seeds = []
-    for nid, e in nodes.items():
+    for nid, e in list(nodes.items()):
         if exclude and nid == exclude:
             continue
         if layer and e.get("layer") != layer:
@@ -478,8 +540,17 @@ def check(cg, content, layer=None, condition_space=None,
                 _cov(expand_query_terms_weighted(n_sb), e_sb)
                 if (n_sb and e_sb) else 0.0)
             if slot >= SLOT_HIGH:
-                # 同口径比对（正文↔正文）；tw_content 已去模板行，见上文
-                concl = _cov(tw_content, _body_text(body)) if tw_content else 0.0
+                # 同口径比对（正文↔正文）：tw_content 已去模板行 + 两侧同一套
+                # 空白归一化（H8），见上文与 `_norm_ws` / `_nows` 说明。
+                e_body = _body_text(body)
+                if n_body_tight == _nows(e_body):
+                    # 差异只在空白（\r\n↔\n / 缩进 / 空行 / 行尾空格 / 词内插空白）
+                    # ⇒ 归一化后逐字相同，必判**重复**（该合并），不判分歧。
+                    # 这不是放宽真分歧判据：取值真不同者去空白后仍不相等。
+                    concl = 1.0
+                else:
+                    concl = (_cov(tw_content, _norm_ws(e_body))
+                             if tw_content else 0.0)
                 if concl < CONCLUSION_SAME:
                     divergences.append({
                         "type": "same_condition_divergence", "with": nid,
@@ -564,7 +635,13 @@ def check(cg, content, layer=None, condition_space=None,
            "actor": getattr(cg, "actor", "unknown")}
 
     # ---- 冲突自动触发飞轮（误差 → 补条件 → 结构更新） ----
-    if auto_flywheel and verdict in ("REJECT", "DEFER", "BLINDSPOT"):
+    # H11⑥（2026-09-30）：**只对真冲突（REJECT）建单**。改前是
+    # verdict ∈ {REJECT, DEFER, BLINDSPOT} 全建——DEFER 是「条件互斥/部分覆盖、
+    # 待确认」，BLINDSPOT 是「既有节点全无声明 ⇒ 检测前提不存在」（空库上恒
+    # 成立），两者都不是「已判定的冲突」；自动落 unresolved 等于把待确认与
+    # 无法比对写成待办工单，污染裁决队列（实测：哨兵形态误判出的 DEFER 直接
+    # 固化成工单 unr_9af4803381）。判定本身照旧返回，缺的只是「自动建单」。
+    if auto_flywheel and verdict in FLYWHEEL_TRIGGERS:
         rec["unresolved_id"] = _fire_flywheel(cg, query or content, verdict,
                                               reason, missing, allc)
     log(cg, rec)
@@ -694,6 +771,9 @@ def catalog():
                     "same_condition_divergence": "同侧比对（新正↔旧正 / 新负↔旧负）"
                                                  "＋ CCG 结论槽 = 同条件空间内的取值分歧（矛盾）",
                 },
+                "conclusion_normalization": "结论比对两侧同一套空白归一化"
+                                            "（' '.join(x.split())）+ 去空白后逐字"
+                                            "相同 ⇒ 必判重复（H8）",
                 "verdicts": list(VERDICTS),
                 "thresholds": {"high": CLASH_HIGH, "low": CLASH_LOW,
                                "same_condition": SAME_COND_HIGH, "slot": SLOT_HIGH,
@@ -710,7 +790,15 @@ def catalog():
         },
         "auto_flywheel": {
             "theory": "知识飞轮：误差 → 补条件 → 结构更新（智能论 :725）",
-            "triggers_on": ["REJECT", "DEFER", "BLINDSPOT"],
+            # H11⑥（2026-09-30）：建单只限**真冲突**（REJECT）。DEFER 是
+            # 「条件互斥/部分覆盖、待确认」，BLINDSPOT 是「检测前提不存在
+            # （无节点可与比对）」——两者都不是「已判定冲突」，自动落 unresolved
+            # 会把待确认项与无法比对项写成待办工单（且 BLINDSPOT 在空库上恒成立，
+            # 即每写第一条内容就建一张工单）。可复核的现场：本轮
+            # `consistency.check(..., non_applicable_conditions=["无"])` 实测
+            # DEFER/strength=1.0 → 建单 unr_9af4803381，而同一内容不传该列表
+            # 则 ACCEPT/0.0/无单——自动建单把「误判」直接固化成了待办。
+            "triggers_on": list(FLYWHEEL_TRIGGERS),
         },
         "discipline_detection": {"tags": list(DISCIPLINE_TAGS),
                                  "id_prefixes": ["discipline_", "work_discipline"]},

package/md_cg/consolidate.py

@@ -530,9 +530,10 @@ def replay_check(pos_terms, neg_terms, body: str) -> dict:
 
 # ---- 写盘（固化）---------------------------------------------------------
 
-# 生效条件：给定 content 与 field，当 content 含 "# field：" 或 "# field:" 时返回 True，否则 False。
+# 生效条件：委托 nodefile.ccg_mark_present——content 含 "# field" 标题行（冒号可有可无）则返回 True，否则 False。
 def _has_ccg_line(content: str, field: str) -> bool:
-    return f"# {field}：" in (content or "") or f"# {field}:" in (content or "")
+    # 判据单点在 nodefile（2026-09-28 收口径）：冒号可有可无，与写入闸门同一语义。
+    return nodefile.ccg_mark_present(content, field)
 
 
 # 生效条件：给定 fm 与 content，对每个 CCG_FIELDS，若 frontmatter.comment 值非空或正文含对应 CCG 行则记入，返回已有字段字典。
@@ -551,7 +552,17 @@ def existing_fields(fm: dict, content: str) -> dict:
 
 # 生效条件：给定 content、field、value，若已有 "# field：" 行则替换并返回新正文；否则插在 "# 功能名" 之后，若无则该行前置。
 def _upsert_ccg_line(content: str, field: str, value: str) -> str:
-    """在正文里写入/替换 `# <字段>：<值>`，优先插在「# 功能名」之后。"""
+    """在正文里写入/替换 `# <字段>：<值>`，优先插在「# 功能名」之后。
+
+    **值必须单行**（N208，2026-09-28）：本函数此前只有 `ccgc` 那份副本做了
+    加固而自身漏掉——而本副本被 `backfill` 与 `crosscheck` 共用，等于注入面
+    在这两条路径上仍然开着。判据委托 `nodefile.ccg_value_has_break`（单点）。
+    """
+    if nodefile.ccg_value_has_break(value):
+        raise ValueError(
+            "ccg 行值含换行：%r——值必须是单行（换行会注入伪造的独立正文行，"
+            "正文读面按首个命中行取值即被顶替）。N208 fail-closed 拒写。"
+            % (str(value)[:80],))
     lines = (content or "").split("\n")
     for i, ln in enumerate(lines):
         s = ln.strip()
@@ -849,11 +860,20 @@ def fill_verification_basis(root: str, basis: str, layer: str = None,
 # 场景：情境层（contextual）里有些记忆被反复命中/并入——它们已经不是「一次情境」，
 # 而是稳定的规律。本动作把它们提升为长期知识（knowledge），并保留：
 #   · 双向可追溯：promoted_from + 演化账本（KIND_LAYER_SHIFT）；
-#   · 条件门槛：四要素（CCG）不全者**不提升**（未可判定就不该升格为长期知识）；
+#   · 条件门槛：六要素（CCG，真源 `nodefile.CCG_REQUIRED`：功能名/生效条件/
+#     子功能/执行/验证方式/不适用条件）不全者**不提升**（未可判定就不该升格为
+#     长期知识）——C-7 前此处只查四要素，缺「验证方式」的弱证据节点可蒙混升格；
 #   · 可预演：apply=False 只出报表；可留痕：`_maintain.jsonl`。
 
 MAINTAIN_LOG = "_maintain.jsonl"
-CCG_REQUIRED = ("生效条件", "子功能", "执行", "不适用条件")
+# C-7（2026-09-29）：本模块此前自带**第二份**要素常量——4 元素
+# ("生效条件","子功能","执行","不适用条件")，与真源 `nodefile.CCG_REQUIRED`
+# 的**六要素**（多「功能名」「验证方式」）不一致 ⇒ 缺「验证方式」的弱证据节点
+# `all(_has_ccg_line(...))` 仍判 complete，可被 `promote_memories` 升格进
+# knowledge 层；`predict` 亦按此常量判 node_ready，同一缺口在两个消费面同时
+# 放大。判据单点在 `nodefile`，本处只**转发**不复制——副本再抄一次就会再次
+# 漂移（N208 同型教训：`_upsert_ccg_line` 的 ccgc 副本加固而本副本漏掉）。
+CCG_REQUIRED = nodefile.CCG_REQUIRED
 
 
 # 生效条件：给定 cg、nid、e、fm、content、target_layer，把节点写入目标层（必要时按 routing 分桶）并删除旧路径，返回新相对路径与 bucket。
@@ -875,11 +895,16 @@ def _relocate_layer(cg, nid, e, fm, content, target_layer):
             "bucket": bucket}
 
 
-# 生效条件：给定 root，把 source_layer 中命中次数不小于 min_merge 或 importance 不小于 min_importance 且条件完整的节点提升到 target_layer，返回统计 rep。
+# 生效条件：给定 root，把 source_layer 中命中次数不小于 min_merge 或 importance 不小于 min_importance 且**六要素完整**（真源 nodefile.CCG_REQUIRED，经模块常量 CCG_REQUIRED 转发）的节点提升到 target_layer，返回统计 rep；require_conditions 为真时六要素不全者计入 skipped_incomplete 不提升。
 def promote_memories(root, source_layer="contextual", target_layer="knowledge",
                      min_merge=2, min_importance=0.6, require_conditions=True,
                      limit=None, apply=False, actor="maintain") -> dict:
-    """把反复命中的情境记忆批量提升为长期知识（可预演 / 可留痕 / 可追溯）。"""
+    """把反复命中的情境记忆批量提升为长期知识（可预演 / 可留痕 / 可追溯）。
+
+    升格门槛（C-7，2026-09-29）：要件清单与写入闸门**同源**
+    （`nodefile.CCG_REQUIRED` 六要素，模块常量转发）——原先本模块自带 4 元素
+    副本，缺「验证方式」的弱证据节点会被判 complete 并升格。
+    """
     cg = MdCGOS(root)
     entries = cg._candidates(layer=source_layer)
     rep = {"root": root, "source_layer": source_layer, "target_layer": target_layer,
@@ -905,7 +930,7 @@ def promote_memories(root, source_layer="contextual", target_layer="knowledge",
         imp = float(fm.get("importance") or e.get("importance") or 0.0)
         complete = all(_has_ccg_line(content, f) for f in CCG_REQUIRED)
         if require_conditions and not complete:
-            rep["skipped_incomplete"] += 1  # 四要素不全 → 不可判定，不升格
+            rep["skipped_incomplete"] += 1  # 六要素不全 → 不可判定，不升格
             continue
         hot = hits >= int(min_merge)
         if not hot and imp < float(min_importance):
@@ -1329,7 +1354,7 @@ def induce_memories(cg_or_root, source_layer="contextual", target_layer="knowled
         require_conditions = True
 
     nodes = (getattr(cg, "index", None) or {}).get("nodes") or {}
-    pool = [nid for nid, e in nodes.items()
+    pool = [nid for nid, e in list(nodes.items())
             if (not source_layer or (e or {}).get("layer") == source_layer)
             and not (e or {}).get("protected")
             and not (set(INDUCE_SKIP_TAGS) & set((e or {}).get("tags") or []))]

package/md_cg/crypto.py

@@ -43,9 +43,11 @@ import json
 import os
 import secrets
 import struct
+import sys
 import time
 
 from .datapath import aux_root
+from .fsutil import FileLock
 
 # ---- 常量 ----------------------------------------------------------------
 
@@ -259,24 +261,42 @@ def keys_path(root):
     return os.path.join(root, KEYS_FILE)
 
 
-# 生效条件：root 为入参；若 os.path.exists(keys_path(root)) 为假，返回 {"v": ENVELOPE_VERSION, "alg": ALG, "envelopes": {}}；否则尝试 json.load，若结果为 dict 且其 "envelopes" 为 dict 则返回该 dict；若 json 解析 ValueError 或 OSError 则返回同样的空结构。
+# 生效条件：root 为入参；keys_path(root) 不存在时返回 {"v": ENVELOPE_VERSION, "alg": ALG, "envelopes": {}}（缺文件=fresh install，零告警零标记）；否则尝试 json.load，结果为 dict 且 "envelopes" 为 dict 时原样返回；json 解析 ValueError、OSError、或顶层为 dict 但 "envelopes" 缺失/非 dict（版本漂移）时向 stderr 写「密钥库损坏/不可读」告警（N139，2026-09-27 第 5 轮：静默回落会让 provision_dek 据空表重签新 DEK 并经 _save_keys 整份覆盖写回，旧信封无痕抹除、旧密文永久不可解——告警必须开口）并返回带 load_error 标记的空结构；provision_dek 见 load_error 即 fail-closed 拒绝重签，unwrap_dek 照旧按无信封抛 LockedError（读面零闸变）。
 def _load_keys(root):
     p = keys_path(root)
     if not os.path.exists(p):
         return {"v": ENVELOPE_VERSION, "alg": ALG, "envelopes": {}}
+    err = None
     try:
         with open(p, "r", encoding="utf-8") as f:
             d = json.load(f)
         if isinstance(d, dict) and isinstance(d.get("envelopes"), dict):
             return d
-    except (ValueError, OSError):
-        pass
-    return {"v": ENVELOPE_VERSION, "alg": ALG, "envelopes": {}}
-
-
-# 生效条件：root、data 为入参，将 data 经 json.dumps(data, ensure_ascii=False, indent=1) 后由 atomic_write 写入 keys_path(root)。
+        err = "顶层不是对象或 envelopes 非映射（版本漂移？）"
+    except (ValueError, OSError) as e:
+        err = f"{type(e).__name__}: {e}"
+    sys.stderr.write(
+        f"[mdcg-crypto] ⚠ 密钥库损坏/不可读（{err}）：{p}"
+        f"——按回落口径返回空结构并置损坏标记（load_error）；签发/重写在"
+        f"标记下拒绝（静默重签会无痕抹除旧信封，N139）。"
+        f"请修复或恢复该文件后重试。\n")
+    return {"v": ENVELOPE_VERSION, "alg": ALG, "envelopes": {},
+            "load_error": err}
+
+
+# 生效条件：root、data 为入参；先调 _load_keys 读盘面写前对账（N184）：盘面带 load_error 时抛 LockedError（N139 同闸延申到写点——解析不了的密钥库不得被整份覆盖），随后把盘面已有而 data["envelopes"] 没有的信封逐键并入（陈旧快照整份写回不得无痕抹除并发新增的他身份信封；键同时存在时以本次写回为准，rotate 语义不受影响），最后 json.dumps(data, ensure_ascii=False, indent=1) 由 atomic_write 写入 keys_path(root)。调用方须已持有 keys_path(root) 的 FileLock（provision_dek 持锁调用）；对账合并是防线纵深，兜底任何未持锁的陈旧快照写者。
 def _save_keys(root, data):
     from .fsutil import atomic_write
+    disk = _load_keys(root)
+    if disk.get("load_error"):
+        raise LockedError(
+            f"密钥库损坏/不可读（{disk['load_error']}）：{keys_path(root)}"
+            f"——写前对账发现盘面不可解析，拒绝整份覆盖（解析不了的信封"
+            f"一概不能被写掉，N139/N184）。请先手工处理该文件。")
+    env = data.setdefault("envelopes", {})
+    for k, v in (disk.get("envelopes") or {}).items():
+        if k not in env:
+            env[k] = v
     atomic_write(keys_path(root),
                  json.dumps(data, ensure_ascii=False, indent=1))
 
@@ -286,7 +306,7 @@ def _envelope_key(tenant, actor):
     return f"{tenant}|{actor}"
 
 
-# 生效条件：root、kek、tenant、actor、clearance="private"、rotate=False 为入参；若 kek 为假抛 LockedError；否则加载 keys，若 _envelope_key(tenant, actor) 已在 envelopes 中且 rotate 为假则返回 unwrap_dek(root, kek, tenant, actor, clearance)；否则生成新 DEK 与 nonce，用 aead_encrypt(kek, nonce, dek, _dek_aad(tenant, actor)) 包裹后写入 envelopes[k] 并保存，返回 dek。
+# 生效条件：root、kek、tenant、actor、clearance="private"、rotate=False 为入参；若 kek 为假抛 LockedError；否则以 FileLock(keys_path(root), strict=True) 持跨进程写锁进入临界区（N184，2026-09-28 第 23 轮：读快照→签发→写回全程持锁，写者互斥——原子替换只防撕裂不防丢失更新，两写者按各自陈旧快照整份写回会无痕抹除对方信封；锁竞争超时经 TimeoutError 转 LockedError fail-closed，绝不无锁放行整份写回）；临界区内加载 keys，keys 带 load_error 损坏标记时抛 LockedError（N139：损坏/漂移回落下静默重签会经 _save_keys 整份覆盖写回并无痕抹除旧信封——旧密文永久不可解）；若 _envelope_key(tenant, actor) 已在 envelopes 中且 rotate 为假则返回 unwrap_dek(root, kek, tenant, actor, clearance)（临界区内互见 → 同身份并发 provision 幂等同 DEK）；否则生成新 DEK 与 nonce，用 aead_encrypt(kek, nonce, dek, _dek_aad(tenant, actor)) 包裹后写入 envelopes[k]，经 _save_keys 写前对账合并并发新增信封（N184 防线纵深）后保存，返回 dek。
 def provision_dek(root, kek, tenant, actor, clearance="private", rotate=False):
     """为 (tenant, actor) 生成 / 取回 DEK，用 KEK 包裹后存入 `_keys.json`。
 
@@ -294,24 +314,37 @@ def provision_dek(root, kek, tenant, actor, clearance="private", rotate=False):
     """
     if not kek:
         raise LockedError("无主密钥（KEK）：拒绝签发数据密钥")
-    data = _load_keys(root)
-    data.setdefault("envelopes", {})
-    k = _envelope_key(tenant, actor)
-    if k in data["envelopes"] and not rotate:
-        return unwrap_dek(root, kek, tenant, actor, clearance)
-    dek = secrets.token_bytes(KEY_LEN)
-    nonce = secrets.token_bytes(NONCE_LEN)
-    ct, tag = aead_encrypt(kek, nonce, dek, _dek_aad(tenant, actor))
-    data["envelopes"][k] = {
-        "id_fp": identity_fingerprint(tenant, actor),
-        "clearance": clearance,
-        "nonce": _b64e(nonce), "ct": _b64e(ct + tag),
-        "created_at": time.time(),
-    }
-    data["v"] = ENVELOPE_VERSION
-    data["alg"] = ALG
-    _save_keys(root, data)
-    return dek
+    try:
+        with FileLock(keys_path(root), timeout=10.0, strict=True):
+            data = _load_keys(root)
+            if data.get("load_error"):
+                raise LockedError(
+                    f"密钥库损坏/不可读（{data['load_error']}）：{keys_path(root)}"
+                    f"——损坏标记下拒绝重签数据密钥（静默整份覆盖会无痕抹除旧信封，"
+                    f"N139）。请修复或恢复 _keys.json 后重试；若有意重置，请先手工"
+                    f"处理该文件（备份/移除）再重试。")
+            data.setdefault("envelopes", {})
+            k = _envelope_key(tenant, actor)
+            if k in data["envelopes"] and not rotate:
+                return unwrap_dek(root, kek, tenant, actor, clearance)
+            dek = secrets.token_bytes(KEY_LEN)
+            nonce = secrets.token_bytes(NONCE_LEN)
+            ct, tag = aead_encrypt(kek, nonce, dek, _dek_aad(tenant, actor))
+            data["envelopes"][k] = {
+                "id_fp": identity_fingerprint(tenant, actor),
+                "clearance": clearance,
+                "nonce": _b64e(nonce), "ct": _b64e(ct + tag),
+                "created_at": time.time(),
+            }
+            data["v"] = ENVELOPE_VERSION
+            data["alg"] = ALG
+            _save_keys(root, data)
+            return dek
+    except TimeoutError as e:
+        raise LockedError(
+            f"密钥库写锁（{keys_path(root)}.lock）竞争超时：并发 provision "
+            f"未在限时内获得互斥——fail-closed 拒绝签发（无锁整份写回会无痕"
+            f"抹除他身份信封，N184）。请稍后重试。") from e
 
 
 # 生效条件：root、kek、tenant、actor、clearance=None 为入参；若 kek 为假抛 LockedError；否则取 _load_keys(root)["envelopes"] 中 _envelope_key(tenant, actor) 的信封，无则抛 LockedError；若 env["id_fp"] 不等于 identity_fingerprint(tenant, actor) 抛 LockedError；否则从 env["ct"] 解出 raw，按 TAG_LEN 切出 ct/tag，调 aead_decrypt；若 aead_decrypt 抛 CryptoError 则转抛 LockedError；clearance 形参默认 None 但源码未在条件中使用。

package/md_cg/docindex.py

@@ -196,7 +196,22 @@ def extract(source, path="", suffix=None):
                   if info[k]["small"] or heads[k]["level"] > MAX_LEVEL]
         merged = [m for m in merged if m]
         if merged:
-            summary = (summary + "；" + "；".join(merged))[:MAX_SUMMARY]
+            # N204（2026-09-28）：合并段必须**真的进得去**。此前先 `_summary(direct)`
+            # 按 MAX_SUMMARY 取满（父节直接正文 ≥200 字时已占满 200），再拼接整体
+            # 截断 ⇒ 被合并子节的文字一个字都留不下（实测 parent_len=440/200/199
+            # 均「子节独有文本进摘要=False」）。而合并的**唯一目的**就是让这些
+            # 小节的正文可检索——等于静默丢索引。改为**预算预分配**：合并段最多
+            # 占 MAX_SUMMARY 的一半，父段按「总预算 − 合并段实占 − 分隔符」取，
+            # 于是合并段无论父段多长都保证进得去（父段过长时让位，最后仍整体截到
+            # MAX_SUMMARY 上限）。
+            # 如实边界：单个被合并子节（≤80 字）恒进得去；合并段超预算时只保前
+            # min(len, MAX_SUMMARY//2) 字——200 字上限下这是不可避免的上界。
+            merged_text = "；".join(merged)
+            merged_budget = min(len(merged_text), MAX_SUMMARY // 2)
+            parent_budget = max(0, MAX_SUMMARY - merged_budget - 1)
+            summary = "；".join(
+                x for x in (_summary(info[i]["direct"], parent_budget),
+                            merged_text) if x)[:MAX_SUMMARY]
         if not summary:
             summary = "（该节无直接正文，见子节）"
         parent = _path_titles(heads, i)