@furongjun1999/dsh-memory 0.4.5 → 0.4.7

package/md_cg/mdcg.py

@@ -110,8 +110,96 @@ STATE_BLINDSPOT = "BLINDSPOT"     # 无法建立可靠归属，停止猜测
 VERIFICATION_BASIS = nodefile.VERIFICATION_BASIS
 
 
+# 英→中语素召回中的代词黑名单（超泛词，进召回词只添噪声）
+_EN_ZH_PRONOUNS = {"我", "你", "他", "她", "它", "我们", "你们", "他们"}
+
+
+def semantic_on() -> bool:
+    """语义摘要路开关（MDCG_SEMANTIC=1，默认关闭零回归）。
+
+    开启时两件事生效（设想「摘要作为检索面」的两层）：
+    1. 候选资格：fm.semantic 节点无条件进入 LIKE 候选池（否则摘要层只在
+       LIKE 全空时才生效，形同虚设——e2e 实证：干扰文档的弱词法 2-gram
+       碰撞会把 gold 挡在打分池外）；
+    2. 打分面：_score 组合窗口共现分与词法分 max 聚合。
+    老库（节点无 semantic 字段）行为逐位不变。
+    """
+    return os.environ.get("MDCG_SEMANTIC") == "1"
+
+
+def en_zh_terms(text: str) -> list:
+    """原子级中英归一 v1（2026-09-13 管线接入）：英文词 → 中文语素召回词。
+
+    依据：英文 query 词面与中文语料零重叠（bench6 实测英文 hit@1 41% vs 中文 95%
+    的主因），形态归一（normalize_en）救不了跨语——beef 与「牛肉」无任何共享字符。
+    语义.en_normalizer 词表映射（时态归零→停用词剔除→英→中语素/复合词映射→
+    专有词保留）产出中文检索键，直接命中中文正文。
+
+    约束（与 cn_recall_grams 同模式）：
+      - 本函数只扩召回（terms/LIKE 资格）；打分侧由 en_zh_bigrams 显式负责
+        （search/_lexical 三处 qb 均已补充），两者同受 MDCG_EN_ATOMS 开关控制；
+      - 默认关闭（MDCG_EN_ATOMS=1 显式开启）：md_cg 主链路英文检索走
+        独立归一化原子+Jaccard 路（REPRODUCE.md 双语双路裁定，md_cg
+        char-bigram 管线跑英文实测比独立方案差 25% vs 52%），本集成为
+        opt-in 实验能力与 soul hub 序列化出口，不在默认链路生效；
+      - 仅当 query 含英文字母时触发，纯中文 query 零开销零变化；
+      - 代词语素剔除（我/你/他…超泛词防污染），动词/名词单字语素保留
+        （「吃/雨」在中文正文检索价值高，_score 终排兜底精度）；
+      - semantic 模块缺失时静默降级（不阻断主链路）。
+    词表未覆盖词保留原名（unknown_keep），是词表边界而非错误。
+    """
+    if os.environ.get("MDCG_EN_ATOMS", "0") != "1":
+        return []
+    if not re.search(r"[A-Za-z]", text or ""):
+        return []
+    try:
+        from .semantic.en_normalizer import normalize_en_query
+        terms, _detail = normalize_en_query(text)
+    except Exception:
+        return []
+    # 专有词/未知词保留原名是序列化语义；作为检索键必须统一小写
+    # （与 normalize_en 口径一致，避免大小写敏感 LIKE 意外命中）
+    return [t.lower() for t in terms
+            if t and (len(t) >= 2 or t not in _EN_ZH_PRONOUNS)]
+
+
+def en_zh_bigrams(text: str) -> set:
+    """英→中语素的打分侧补充：中文语素进 query bigram 集合。
+
+    背景：en_zh_terms 只扩 LIKE 召回资格，而 _score/_lexical 的词法分
+    = lexical_sim(qb, doc_bigrams)——英文 bigram 与中文文档恒零交集
+    （跨语场景词法分全 0、排序退化到扫描序，2026-09-13 端到端实测）。
+    「牛肉/昨天」等中文语素本身是合法 bigram，补进 qb 后与中文正文
+    bigram（牛肉面→{牛肉,肉面}）正常相交，词法分恢复区分度。
+
+    拼接升级（2026-09-14 盲测实证）：单字语素（马/肉/油…）被 len>=2
+    过滤后打分侧仍空集→跨语词法分恒 0→top5 全为 0 分扫描序干扰
+    （bench_blind_comp：词表补齐后 hit@1 反而 36.4%→27.3%，证明基线
+    命中全靠小候选集扫描序运气而非排序能力）。现把相邻中文语素按
+    query 词序拼接成 char-bigram（[马,肉]→「马肉」），与本仓主链路
+    char-bigram 口径同构（英文 query 译中文串再取 bigram）。
+    噪声边界：跨语素拼接 bigram（吃牛肉→「吃牛」「肉昨」）可与语义
+    相邻文档假相交，由 Jaccard 分母稀释，_score 终排兜底精度。
+
+    纯中文 query 零变化（en_zh_terms 不触发）；与 en_zh_terms 同受
+    MDCG_EN_ATOMS 开关控制（默认关闭）。
+    """
+    terms = en_zh_terms(text)
+    grams = {t for t in terms if len(t) >= 2}
+    # 相邻中文语素拼接：query 词序即语素序（horse meat→马 肉→「马肉」）
+    zh_seq = [t for t in terms if t and all("\u4e00" <= ch <= "\u9fff" for ch in t)]
+    joined = "".join(zh_seq)
+    grams |= {joined[i:i + 2] for i in range(len(joined) - 1)}
+    return grams
+
+
 def expand_query_terms(query: str) -> list:
-    """与 aeis.core 同实现：整句 + 分词（≥2字符）+ 同义词组展开。"""
+    """与 aeis.core 同实现：整句 + 分词（≥2字符）+ 同义词组展开 + 英文归一化
+    + 英→中语素召回扩展（en_zh_terms，MDCG_EN_ATOMS=1 开启，默认关）。"""
+    # 原子级中英归一：在 normalize_en 之前取（专有词首字母大写判断依赖原始形态）
+    _en_zh = en_zh_terms(query)
+    # 英文归一化（中文不动；小写化+去停用词+去时态复数）
+    query = normalize_en(query)
     terms = [query]
     for w in re.split(r"[\s、，。；：,;.:/\\|]+", query):
         w = w.strip()
@@ -122,6 +210,14 @@ def expand_query_terms(query: str) -> list:
             if w in query:
                 terms.extend(g for g in group if g not in terms)
                 break
+    # 构词法 v1：中文连续串 2-gram 召回扩展（只增召回，不改打分口径）
+    for g in cn_recall_grams(query):
+        if g not in terms:
+            terms.append(g)
+    # 原子级中英归一 v1：英→中语素召回扩展（与 cn_recall_grams 同模式：只增召回）
+    for t in _en_zh:
+        if t not in terms:
+            terms.append(t)
     return list(dict.fromkeys(terms))
 
 
@@ -132,6 +228,148 @@ def bigrams(s: str) -> set:
     return {s[i:i + 2] for i in range(len(s) - 1)}
 
 
+# 中文高频功能 bigram（召回扩展时剔除：纯语法组合，召回价值低、噪音高）
+CN_STOP_GRAMS = {
+    "的了", "是一", "的在", "有个", "就是", "不是", "没有", "这个", "那个",
+    "我们", "你们", "可以", "一个", "的话", "来说", "关于", "对于", "还是",
+}
+
+
+def cn_recall_grams(query: str, min_run: int = 4, cap: int = 16) -> list:
+    """构词法 v1 · 中文召回扩展：把连续中文串切成 2-gram 作为额外召回键。
+
+    背景（2026-09-13 诊断）：expand_query_terms 对无标点中文查询只产出「整句」
+    一个召回词，而 _like 要求正文原样包含整句才给召回资格 —— 导致「抑制剂怎么选」
+    无法召回含「酪氨酸激酶抑制剂」的节点（部分中文无法词匹配的机制断点）。
+
+    约束：只扩召回，不改打分口径（bigrams(q) 的 _score 不变）；纯标准库，零依赖；
+    仅当中文连续串 ≥ min_run 字时触发（短词本身已是召回词，无需扩展）。
+    """
+    if os.environ.get("MDCG_CN_GRAMS") == "0":   # A/B 开关：关闭即回退旧行为
+        return []
+    out = []
+    for run in re.findall(r"[\u4e00-\u9fff]{%d,}" % max(min_run, 2), query or ""):
+        for i in range(len(run) - 1):
+            g = run[i:i + 2]
+            if g in CN_STOP_GRAMS or g in out:
+                continue
+            out.append(g)
+            if len(out) >= cap:
+                return out
+    return out
+
+
+# ---- 英文归一化（与中文 cn_recall_grams 对称的英文预处理）----
+# 设计者裁定：大小写统一转小写；停用词（the 等）不能拆成 bigram 参与匹配；
+# 时态/复数归零（walked→walk, pets→pet），与语义层原子化原则一致。
+EN_STOPWORDS = frozenset({
+    "the", "a", "an", "is", "are", "was", "were", "be", "been", "being",
+    "do", "does", "did", "have", "has", "had", "will", "would", "could",
+    "should", "may", "might", "of", "to", "in", "on", "at", "for", "with",
+    "by", "from", "up", "about", "into", "over", "after", "and", "or",
+    "but", "not", "no", "so", "if", "then", "than", "also", "very",
+    "what", "which", "who", "how", "why", "when", "where",
+    "this", "that", "these", "those", "it", "its", "as", "there",
+    "i", "me", "my", "we", "our", "you", "your", "he", "him", "his",
+    "she", "her", "they", "them", "their",
+})
+
+EN_IRREGULAR = {
+    "ate": "eat", "eaten": "eat", "went": "go", "gone": "go",
+    "saw": "see", "seen": "see", "wrote": "write", "written": "write",
+    "took": "take", "taken": "take", "made": "make", "ran": "run",
+    "bought": "buy", "brought": "bring", "thought": "think",
+    "taught": "teach", "caught": "catch", "sought": "seek",
+    "fought": "fight", "sold": "sell", "told": "tell", "felt": "feel",
+    "fell": "fall", "sent": "send", "spent": "spend", "built": "build",
+    "lost": "lose", "met": "meet", "paid": "pay", "led": "lead",
+    "won": "win", "sat": "sit", "stood": "stand",
+    "understood": "understand", "heard": "hear",
+    "spoke": "speak", "spoken": "speak", "broke": "break", "broken": "break",
+    "chose": "choose", "chosen": "choose", "drew": "draw", "drawn": "draw",
+    "drove": "drive", "driven": "drive", "grew": "grow", "grown": "grow",
+    "knew": "know", "known": "know", "gave": "give", "given": "give",
+    "was": "be", "were": "be", "been": "be", "had": "have", "has": "have",
+    "did": "do", "done": "do", "said": "say", "got": "get",
+    "left": "leave", "kept": "keep", "held": "hold",
+    "slept": "sleep", "swept": "sweep", "meant": "mean",
+    "dealt": "deal", "lent": "lend", "bent": "bend",
+}
+
+def strip_tense_en(w: str) -> str:
+    """英文时态/复数归零（保守策略：宁可少剥不可误剥）"""
+    if w in EN_IRREGULAR:
+        return EN_IRREGULAR[w]
+    # -ous 结尾 = 形容词不是复数（courageous/famous/various）
+    if w.endswith("ous") or w.endswith("us") or w.endswith("is"):
+        return w
+    if w.endswith("ing") and len(w) > 5:
+        return w[:-3]
+    if w.endswith("ed") and len(w) > 4:
+        return w[:-2]
+    if w.endswith("ies") and len(w) > 4:
+        return w[:-3] + "y"
+    # -es 只剥真复数（boxes→box, watches→watch），不剥 motivates→motivate
+    if re.search(r'(ch|sh|ss|x|z)o?es$', w) and len(w) > 4:
+        return w[:-2]
+    # -s 剥离（motivates→motivate, pets→pet）
+    if w.endswith("s") and not w.endswith("ss"):
+        return w[:-1]
+    return w
+
+def normalize_en(text: str) -> str:
+    """英文归一化：小写 + 去停用词 + 去时态复数。中文部分不动。
+
+    设计者裁定：
+      - 大小写统一转小写匹配
+      - 停用词（the 等）不能拆成 bigram 参与匹配（整词剔除）
+      - 时态/复数归零（walked→walk, pets→pet）
+    """
+    # 清标点（保留中文字符和空格和数字）
+    cleaned = re.sub(r'[^\u4e00-\u9fff a-zA-Z0-9]', ' ', text or "")
+    def _norm_word(m):
+        w = m.group(0).lower()
+        if w in EN_STOPWORDS:
+            return ""
+        return strip_tense_en(w)
+    result = re.sub(r'[a-zA-Z]{2,}', _norm_word, cleaned)
+    result = re.sub(r'\s+', ' ', result).strip()
+    return result
+
+
+# 词法相似度口径（二元组集合）：
+#   legacy  = |q ∩ d| / |q|      只归一化**查询侧** → 长文档天然占优（既有基线）。
+#                                 LongMemEval-S 长 turn 上把证据挤出 Top-5：
+#                                 precise/temporal/reference hit@1 均为 0%。
+#   jaccard = |q ∩ d| / |q ∪ d|  对称归一化（长度自惩罚，无参数）。
+#                                 同口径实测：长文档组 0%→8.97% / 0%→6.77% /
+#                                 1.28%→20.51%；短文档组（LoCoMo）基本持平或微降
+#                                 → 收益随文档长度单调增长，是长度偏置的定向修复。
+# 切换：mdcg.SCORE_MODE = "jaccard"，或环境变量 MDCG_SCORE_MODE=jaccard。
+# 缺省 "legacy"：既有检索行为与基线完全不变。
+# **评测侧**改用 eval_common.use_jaccard() 显式注入——长 turn 语料上
+# precise 0%→8.97% / temporal 0%→6.77% / interference 1.28%→20.51% /
+# reference 0%→3.76%（与 Rust mdcg-eval --score jaccard 逐位一致）。
+# 主库不切：短条目语料上 jaccard 会退化（test_p17_predict G4——可预测锚点
+# 由因果起点 a 错配到语义邻居 x），收益随文档长度单调增长。
+SCORE_MODES = ("legacy", "jaccard")
+SCORE_MODE = os.environ.get("MDCG_SCORE_MODE") or "legacy"
+
+
+def lexical_sim(qb: set, nb: set, mode: str = None) -> float:
+    """查询/文档二元组集合的相似度。mode 缺省取模块级 `SCORE_MODE`。
+
+    显式传 mode 用于单点 A/B（不改全局口径即可对比两套打分）。
+    """
+    if not qb or not nb:
+        return 0.0
+    inter = len(qb & nb)
+    if (mode or SCORE_MODE) == "jaccard":
+        union = len(qb | nb)
+        return inter / union if union else 0.0
+    return inter / len(qb)
+
+
 def expand_query_terms_weighted(query: str) -> dict:
     """分级版查询扩展：返回 {词: 隶属度}，隶属度 ∈ (0, 1]。
 
@@ -348,6 +586,10 @@ class MdCG:
                     parent = os.path.basename(dirpath)
                     nodes[nid] = {
                         "path": rel, "layer": fm.get("layer", layer),
+                        # role 必须回填：它写在节点 frontmatter 里（写入时 role or "user"），
+                        # 但索引重建时若不复制，os.roles 会全部退化为 (none)，
+                        # 来源归因打分随之失效（实测 48 条全丢）。
+                        "role": fm.get("role"),
                         "tags": fm.get("tags", []),
                         "bucket": parent if parent != layer else None,
                         "importance": fm.get("importance", 0.5),
@@ -394,7 +636,7 @@ class MdCG:
             non_applicable_conditions=None, override: bool = False,
             consistency: bool = False, on_conflict: str = "reject",
             derived_from=None, relation: str = provenance.DEFAULT_RELATION,
-            **extra) -> str:
+            semantic: str = None, **extra) -> str:
         """写入一个节点。
 
         verification_basis: 外部验证基底（白箱信任的硬门槛），
@@ -409,6 +651,12 @@ class MdCG:
                      frontmatter（单一真相源）并追加派生边到 <root>/_link.jsonl；
                      **建链失败不阻断本次写入**（降级为告警 + .fail 台账留痕）。
         relation: 派生关系名，默认 "derived_from"；允许值见 provenance.RELATIONS。
+        semantic: 标准语义摘要（空格分隔的标准原子序列，如「鱼 油」）——
+                  **AI 写入侧归一**的产物（使用者设想 2026-09-14：归一主体是
+                  AI，系统只供词表真源 atoms.json + OOV 审计）。落 fm.semantic
+                  衍生层，正文原文无损；OOV token 记 fm.semantic_oov 警告不拒绝
+                  （词表覆盖有限，拒绝会堵死合法写入）。检索面经
+                  MDCG_SEMANTIC=1 开启组合共现打分（mdcg._score）。
         """
         if layer not in LAYERS:
             raise ValueError(f"未知层：{layer}（允许：{LAYERS}）")
@@ -436,6 +684,17 @@ class MdCG:
                 "emotional": (vd.get("emotional") or {}).get("bias"),
                 "unresolved_id": vd.get("unresolved_id")}
         tags = list(tags or [])
+        # 标准语义摘要（semantic/canonical.py：词表真源 + OOV 审计，警告不拒绝）。
+        # 语义校验失败不阻断写入（与 derived_from 建链降级同风格）。
+        if semantic is not None:
+            extra["semantic"] = str(semantic)
+            try:
+                from .semantic import canonical as _canon
+                _oov = _canon.oov_of(str(semantic))
+                if _oov:
+                    extra["semantic_oov"] = _oov
+            except Exception:
+                pass
         bucket = None
         d = os.path.join(self.root, layer)
         if layer in BUCKETED_LAYERS:
@@ -497,6 +756,9 @@ class MdCG:
             "self_state": fm.get("self_state"),
             "derived_from": parents,
             "derived_relation": derived_rel,
+            "writer": fm.get("writer"),
+            "session": fm.get("session"),
+            "harness": fm.get("harness"),
         })
         subgraph.invalidate_cache(self)
         chain.invalidate_cache(self)
@@ -509,6 +771,142 @@ class MdCG:
                               actor=extra.get("actor"))
         return node_id
 
+    # ------------------------------------------------------------------
+    # 边域窄原语（写路径收口：白箱工具写 md 真源的唯一正路）。
+    #
+    # 三条纪律：
+    # 1. 一律经 `self.get()` 读 + `_write_node()` 写（加密形态下 get 解封、
+    #    _write_node 再封装——绕过即破坏加密）；
+    # 2. 只动边域（fm.edges / fm.subgraph.nodes），不改 content / importance /
+    #    tags 等本体字段，故不走 guard_write 写保护（保护语义=本体覆写），
+    #    但索引 entry 的 edges/subgraph 键同步更新并标 _dirty；
+    # 3. 幂等去重：append_edge 按 (target, relation_type)、append_subgraph_node
+    #    按 child_id 去重，重复追加返回 False 不落盘。
+    # ------------------------------------------------------------------
+
+    def _edge_node(self, node_id):
+        """取节点 (fm, content, full_path)；不存在返回 None。"""
+        node = self.get(node_id)
+        if not node:
+            return None
+        return (node.get("frontmatter") or {}, node.get("content") or "",
+                os.path.join(self.root, node.get("path") or f"{node_id}.md"))
+
+    def _sync_edge_entry(self, node_id, fm):
+        """边域变更后同步索引 entry（edges/subgraph 键）并标脏。"""
+        entry = self.index["nodes"].get(node_id)
+        if entry is not None:
+            entry["edges"] = fm.get("edges") or []
+            entry["subgraph"] = fm.get("subgraph")
+            self._dirty[node_id] = entry
+        try:
+            from . import subgraph as _sg
+            _sg.invalidate_cache(self)
+        except Exception:
+            pass
+
+    def append_edge(self, node_id: str, edge: dict) -> bool:
+        """向既有节点追加一条出边（fm.edges），幂等去重。
+
+        edge 形态对齐迁移语料：{"target", "relation_type", "confidence",
+        "verified", "condition_space", ...}。节点不存在返回 False。
+        """
+        got = self._edge_node(node_id)
+        if got is None:
+            return False
+        fm, content, path = got
+        edges = fm.setdefault("edges", [])
+        if not isinstance(edges, list):
+            edges = fm["edges"] = []
+        tgt = str(edge.get("target") or "")
+        rel = str(edge.get("relation_type") or "")
+        if any(str(e.get("target") or "") == tgt
+               and str(e.get("relation_type") or "") == rel
+               for e in edges if isinstance(e, dict)):
+            return False  # 幂等：同 target 同关系已存在
+        edges.append(dict(edge))
+        self._write_node(node_id, path, fm, content)
+        self._sync_edge_entry(node_id, fm)
+        return True
+
+    def append_subgraph_node(self, node_id: str, child_id: str) -> bool:
+        """向既有父节点追加层级子节点（fm.subgraph.nodes），幂等去重。
+
+        层级边（hierarchical）在 md 语料的落点即父节点 subgraph.nodes
+        （source=父，与 migrate_wisdom_graph 导出形态一致）。
+        """
+        got = self._edge_node(node_id)
+        if got is None:
+            return False
+        fm, content, path = got
+        sg = fm.get("subgraph")
+        if not isinstance(sg, dict):
+            sg = fm["subgraph"] = {"nodes": []}
+        subs = sg.setdefault("nodes", [])
+        if not isinstance(subs, list):
+            subs = sg["nodes"] = []
+        if child_id in subs:
+            return False  # 幂等
+        subs.append(str(child_id))
+        self._write_node(node_id, path, fm, content)
+        self._sync_edge_entry(node_id, fm)
+        return True
+
+    def update_tags(self, node_id: str, add=None, remove=None) -> bool:
+        """节点 tags 增删（节点状态更新窄原语——causal 候选状态迁移面）。
+
+        remove 先于 add（状态迁移语义：去旧标→加新标），去重保序；
+        无实质变更不落盘返回 False。节点不存在返回 False。
+        """
+        got = self._edge_node(node_id)
+        if got is None:
+            return False
+        fm, content, path = got
+        tags = fm.get("tags")
+        if not isinstance(tags, list):
+            tags = fm["tags"] = []
+        tags = [str(t) for t in tags]
+        rm = {str(t) for t in (remove or [])}
+        new_tags = [t for t in tags if t not in rm]
+        for t in (add or []):
+            t = str(t)
+            if t not in new_tags:
+                new_tags.append(t)
+        if new_tags == tags:
+            return False  # 幂等：无实质变更
+        fm["tags"] = new_tags
+        self._write_node(node_id, path, fm, content)
+        entry = self.index["nodes"].get(node_id)
+        if entry is not None:
+            entry["tags"] = list(new_tags)
+            self._dirty[node_id] = entry
+        return True
+
+    def set_edge_condition(self, node_id: str, target_id: str,
+                           relation_type: str, condition_space: dict) -> bool:
+        """改既有节点上指定出边的 condition_space（模式分离更新面）。
+
+        匹配 (target, relation_type) 唯一边；无匹配返回 False 不落盘。
+        """
+        got = self._edge_node(node_id)
+        if got is None:
+            return False
+        fm, content, path = got
+        edges = fm.get("edges") or []
+        hit = None
+        for e in edges:
+            if (isinstance(e, dict)
+                    and str(e.get("target") or "") == str(target_id)
+                    and str(e.get("relation_type") or "") == str(relation_type)):
+                hit = e
+                break
+        if hit is None:
+            return False
+        hit["condition_space"] = dict(condition_space or {})
+        self._write_node(node_id, path, fm, content)
+        self._sync_edge_entry(node_id, fm)
+        return True
+
     def add_rejected(self, hypothesis: str, reason: str, verification_basis: str = "test",
                      tags=None, **extra) -> str:
         """第 5 篇 L2：负记忆——失败/否决的假设库。重复证伪幂等。"""
@@ -524,14 +922,19 @@ class MdCG:
 
     def add_unresolved(self, question: str, known_clues: str = "",
                        goal: str = "", verification_basis: str = "data",
-                       tags=None, **extra) -> str:
-        """第 5 篇 L5：未解问题清单——驱动主动探索。"""
+                       tags=None, context: str = "", **extra) -> str:
+        """第 5 篇 L5：未解问题清单——驱动主动探索。
+
+        context：结构化「现场」（如「同条件两条不同取值 vs mem_A」）。
+        缺此字段时「32 / 64 哪个对」这类缺口在裁决时看不到原始对照。
+        """
         nid = f"unr_{hashlib.sha1(question.encode()).hexdigest()[:10]}"
         if nid in self.index["nodes"]:
             return nid
         content = (f"# 问题：{question}\n"
                    f"# 已知线索：{known_clues or '（暂无）'}\n"
-                   f"# 目标：{goal or '（未设定）'}\n"
+                   + (f"# 现场：{context}\n" if context else "")
+                   + f"# 目标：{goal or '（未设定）'}\n"
                    f"# 验证：{verification_basis}\n")
         return self.add(nid, content, layer="unresolved",
                         tags=tags, verification_basis=verification_basis,
@@ -720,6 +1123,51 @@ class MdCG:
 
     # ---------- 资格判定（与性能 tier 正交）----------
 
+    @staticmethod
+    def _ccg_line(content: str, name: str) -> str:
+        """取 CCG 正文 `# <name>：` 行的值。
+
+        与 mdcos._ccg_field 同源实现——父类不得反向 import mdcos，
+        故在此落同款确定性扫描（无正则回溯风险）。
+        """
+        for line in (content or "").splitlines():
+            s = line.strip()
+            if not s.startswith("#") or name not in s:
+                continue
+            body = s.lstrip("#").strip()
+            for sep in ("：", ":"):
+                if sep in body:
+                    head, _, val = body.partition(sep)
+                    if head.strip() == name:
+                        return val.strip()
+        return ""
+
+    @staticmethod
+    def _cond_terms(cond_text: str):
+        """生效条件声明 → 匹配短语列表（确定性切分，无语义猜测）。
+
+        切分规则：按槽分隔「；/;」拆槽（condition_space_text 以「；」连四槽）
+        → 每槽剥「槽标签：」前缀（载体/位置、时间、方法、约束等标签是通用词，
+        参与命中必误判）→ 槽内按「，,、/（）」切短语 → 丢弃长度 <2、纯数字、
+        全时窗哨兵短语（全时窗 = 时间维无信息量，不因其未命中而降级）。
+        """
+        out, seen = [], set()
+        for slot in re.split(r"[；;]", str(cond_text or "")):
+            if "：" in slot:
+                slot = slot.split("：", 1)[1]
+            elif ":" in slot:
+                slot = slot.split(":", 1)[1]
+            for seg in re.split(r"[，,、/（）()]", slot):
+                seg = seg.strip()
+                if len(seg) < 2 or seg.isdigit():
+                    continue
+                if "全时窗" in seg or "任意时刻" in seg:
+                    continue
+                if seg not in seen:
+                    seen.add(seg)
+                    out.append(seg)
+        return out
+
     @staticmethod
     def judge_qualification(node_dict, query: str, context=None):
         """四态判定（白箱第 1/2 篇）。
@@ -731,8 +1179,10 @@ class MdCG:
         - BLINDSPOT：节点 MARKS 不完整（6 行缺一不可；生效条件不可隐含，
           必须由条件空间四槽合成显式声明）→ 无法建立可靠归属，停止
         - REJECT：不适用条件命中 → 明确不适用
-        - DEFER：条件不足但缺的不是不适用条件，是适用条件未声明 → 可继续寻找
-        - ACCEPT：条件满足（默认）
+        - DEFER：生效条件未在情境（query+context）词面确认，或未声明验证基底
+          → 可继续寻找/补证据
+        - ACCEPT：条件满足（生效条件已确认，或无情境可比——此时 reason 诚实
+          标注「未做正条件确认」，不冒充已确认）
         """
         fm = node_dict.get("frontmatter") or {}
         content = node_dict.get("content") or ""
@@ -743,27 +1193,61 @@ class MdCG:
             return {"state": STATE_BLINDSPOT,
                     "reason": f"CCG 要素不全：缺 {set(nodefile.CCG_REQUIRED) - set(cpl['required_present'])}"}
 
+        # 情境合成（query + context）：正/负条件共用同一情境口径。
+        # 负条件扩面依据（2026-09-12）：不适用条件的语义是「本节点明确不适用
+        # 于这类问句」，问句（query）是情境的一半——只看 context 时「我没喝水」
+        # 声明的负条件「刚才在干什么」在同类问句下永不命中，否定事件得以冒充
+        # 事件。扩面已过全量回归（test_p33 负条件断言保绿：其词面本就命中）。
+        scene = {"query": query or ""}
+        if isinstance(context, dict):
+            scene.update(context)
+        scene_str = json.dumps(scene, ensure_ascii=False)
+
         # 2) REJECT：不适用条件命中（需条件对比，简化版用关键词命中）
         neg = fm.get("non_applicable_conditions") or []
-        ctx_str = json.dumps(context or {}, ensure_ascii=False)
-        neg_hit = [n for n in neg if any(w in ctx_str for w in n.split())]
+        neg_hit = [n for n in neg if any(w in scene_str for w in n.split())]
         if neg_hit:
             return {"state": STATE_REJECT,
                     "reason": f"不适用条件命中：{neg_hit[:3]}"}
 
-        # 3) DEFER：节点无 verification_basis → 信任根基不足
+        # 3) 正条件确认：生效条件须在情境（query+context）中词面可确认——
+        #    「没发现拒绝理由」≠「确认适用」（相似度产生候选，条件授予资格）。
+        #    情境为空（无 query 且无 context）→ 无可判定依据，跳过本段不降级：
+        #    「无情境」不能被误判成「不适用」。
+        cond_hit = None
+        has_scene = bool((query or "").strip()) or bool(context)
+        if has_scene:
+            cond_text = MdCG._ccg_line(content, "生效条件")
+            if not cond_text and fm.get("condition_space"):
+                cond_text = nodefile.condition_space_text(fm["condition_space"])
+            if cond_text and cond_text.strip() != "无条件":
+                terms_ = MdCG._cond_terms(cond_text)
+                cond_hit = next((t for t in terms_ if t in scene_str), None)
+                if cond_hit is None and terms_:
+                    return {"state": STATE_DEFER,
+                            "reason": ("生效条件未在情境确认（未命中任何声明条件："
+                                       + "、".join(terms_[:3])
+                                       + "）；可补充情境或条件词面后重判")}
+
+        # 4) DEFER：节点无 verification_basis → 信任根基不足
         if not fm.get("verification_basis"):
             return {"state": STATE_DEFER,
                     "reason": "未声明验证基底，需补充才能继续判定"}
 
-        # 4) ACCEPT：默认
-        return {"state": STATE_ACCEPT, "reason": "5 要素齐全 + 不适用条件未命中 + 验证基底已声明"}
+        # 5) ACCEPT：默认——reason 诚实标注正条件是否经情境确认
+        acc = "5 要素齐全 + 不适用条件未命中 + 验证基底已声明"
+        if cond_hit:
+            acc = f"生效条件已确认（命中「{cond_hit}」）+ " + acc
+        elif not has_scene:
+            acc = "无情境可比（未做正条件确认）+ " + acc
+        return {"state": STATE_ACCEPT, "reason": acc}
 
     # ---------- 检索（性能阶梯 + 资格判定）----------
 
     def search(self, query: str, layer: str = None, k: int = 20,
                context=None, min_results: int = 1, record: bool = True,
-               include_neg: bool = True, judge: bool = True, pools=None):
+               include_neg: bool = True, judge: bool = True, pools=None,
+               session=None):
         """返回 (results, meta)。results = [(node_dict, score, qualification)]。
 
         meta 含 tier（性能层级）、scanned（读取节点数）、bucket（路由桶）、candidates。
@@ -783,12 +1267,15 @@ class MdCG:
         pool_cfg = pooling.resolve(pooling.from_env(pools))
 
         terms = expand_query_terms(q)
-        qb = bigrams(q)
+        # 英文归一化后再取 bigram（小写+去停用词+去时态；中文不动）
+        # + 英→中语素 bigram 补充（跨语词法分：纯中文零变化，MDCG_EN_ATOMS 可关）
+        qb = bigrams(normalize_en(q)) | en_zh_bigrams(q)
         # 把 rejected/unresolved 视作可参与召回的特殊「候选池」
         # ——命中它们的结果会改变 meta 的 covered_neg（被负记忆覆盖的查询）
         # 默认排除掉负记忆层的节点进入正排打分，仅作为「覆盖标记」用
         entries = [e for e in self.index["nodes"].values()
-                   if not layer or e["layer"] == layer]
+                   if (not layer or e["layer"] == layer)
+                   and (not session or e.get("session") == session)]
         if not entries:
             return [], {"tier": None, "reason": "no_candidates", "scanned": 0}
 
@@ -811,7 +1298,7 @@ class MdCG:
                     if any(t in content for t in terms):
                         neg_coverage.append(e)
 
-        stat = {"scanned": 0}
+        stat = {"scanned": 0, "query": q}
         route_bucket = None
         if context is not None:
             ctx = context if isinstance(context, dict) else {}
@@ -836,7 +1323,9 @@ class MdCG:
             in_bucket = [e for e in entries if e.get("bucket") == route_bucket]
             if in_bucket:
                 docs = self._read_many(in_bucket, stat)
-                hits = [d for d in docs if self._like(d[2], d[1], terms)]
+                # 语义资格（MDCG_SEMANTIC=1）：fm.semantic 节点无条件入池
+                hits = [d for d in docs if self._like(d[2], d[1], terms)
+                        or (semantic_on() and d[1].get("semantic"))]
                 out = try_stage(hits, TIER_BUCKET_LIKE)
                 if out:
                     return out
@@ -846,7 +1335,9 @@ class MdCG:
 
         # T2：跨桶 LIKE（§七 截断点：分池截断，索引类不再挤掉知识类）
         docs_all = self._read_many(entries, stat)
-        hits = [d for d in docs_all if self._like(d[2], d[1], terms)]
+        # 语义资格（MDCG_SEMANTIC=1）：fm.semantic 节点无条件入池
+        hits = [d for d in docs_all if self._like(d[2], d[1], terms)
+                or (semantic_on() and d[1].get("semantic"))]
         stat["pre_cap"] = len(hits)
         stat["cap"] = GLOBAL_CAP
         hits, _rep = pooling.cut_report(hits, GLOBAL_CAP, pools=pool_cfg,
@@ -888,16 +1379,39 @@ class MdCG:
         # judge_qualification 走 REJECT，不能把节点召回。tags 仍参与匹配。
         tags = " ".join(str(t) for t in (fm.get("tags") or []))
         body = nodefile.positive_body(content)
-        return any(t in body or t in tags for t in terms)
-
-    def _score(self, docs, q, qb, pools=None):
+        # 双边小写化：英文大小写统一（中文无大小写不受影响）
+        body_l = body.lower()
+        tags_l = tags.lower()
+        return any(t in body_l or t.lower() in tags_l for t in terms)
+
+    def _score(self, docs, q, qb, pools=None, mode=None):
+        # 语义摘要路（MDCG_SEMANTIC=1 opt-in，默认关闭零回归）：
+        # doc 侧 fm.semantic 标准原子序列 × query 归一序列的组合窗口共现分
+        # （semantic/canonical.pair_hits），与词法分 **max 聚合**——语义路=
+        # 候选生成器/终排器（judge_ranking 同定位），词法强时不拖累、词法
+        # 零交集（L3 盲测靶区）时独立成臂。延迟导入+异常静默降级（与
+        # en_zh_terms 同风格：semantic 模块缺失不阻断主链路）。
+        sem_on = semantic_on()
+        _pair_hits = None
+        if sem_on:
+            try:
+                from .semantic import canonical as _canon
+                _pair_hits = _canon.pair_hits
+            except Exception:
+                sem_on = False
         scored = []
         for e, fm, c in docs:
-            nb = bigrams(c)
-            sim = len(qb & nb) / len(qb) if qb else 0.0
+            # 归一化 content 后取 bigram（与 query 侧 normalize_en 对称）
+            c_norm = normalize_en(c)
+            nb = bigrams(c_norm)
+            sim = lexical_sim(qb, nb, mode)
             tag_bonus = 0.05 if any(str(t) in q or q in str(t)
                                     for t in (fm.get("tags") or [])) else 0.0
-            raw = min(1.0, sim + tag_bonus)
+            if sem_on and _pair_hits is not None and fm.get("semantic"):
+                raw = min(1.0, max(sim, _pair_hits(fm["semantic"], q))
+                          + tag_bonus)
+            else:
+                raw = min(1.0, sim + tag_bonus)
             if pools:                       # §七 降权：乘数只来自显式权重表（可复算）
                 raw = max(0.0, min(1.0, raw * pooling.weight_of(
                     fm.get("id") or e["path"], e, pools)))
@@ -905,6 +1419,7 @@ class MdCG:
                             "content": c, "path": e["path"]}, raw))
         return scored
 
+
     def _emit(self, scored, k, tier, stat, bucket, record, candidates,
               judge, context, neg_coverage, big_domain=None, big_scores=None,
               pools=None):
@@ -915,7 +1430,8 @@ class MdCG:
         out = []
         for r in results:
             if judge:
-                qual = self.judge_qualification(r[0], "", context)
+                qual = self.judge_qualification(r[0], stat.get("query") or "",
+                                                context)
             else:
                 qual = {"state": None, "reason": "judge_disabled"}
             out.append((r[0], r[1], qual))
@@ -1007,6 +1523,10 @@ class MdCG:
         D = 1 - 有效命中比例，0=信息差为零（完美），1=完全空白。
 
         简化模型：本次查询的「有效命中」= score>0 且 state=ACCEPT 的比例。
+
+        口径声明（智能论3.4 §2.7.0 DEV-002a）：本值是 D_task 的
+        「检索-资格链路工程化身」——对象同一、数值不与 wisdom 四分量
+        D_norm（验证链路化身）直接互换。
         """
         if not results:
             return 1.0
@@ -1129,8 +1649,27 @@ class MdCG:
         question = (f"为何 {try_data.get('query','?')} 出现 {try_data.get('actual_state','?')}"
                     f" 而期望 {try_data.get('expected_state','?')}？")
         clues = try_data.get("missing", "")
+        # detail：判定器的结构化缺口（[{type, with, same_condition, ...}]）。
+        # 原先整字段被忽略——上游产出了结构却送不到下游。这里提炼为「现场」，
+        # 使条目在人工/外部裁决时能看到原始对照（如「同条件两条不同取值」）。
+        detail = try_data.get("detail") or []
+        parts = []
+        if isinstance(detail, list):
+            for d in detail:
+                if not isinstance(d, dict):
+                    continue
+                if d.get("type") == "same_condition_divergence":
+                    parts.append("同条件取值分歧 vs %s（条件重合 %s / 槽位 %s / 结论差异 %s）"
+                                 % (d.get("with"), d.get("same_condition"),
+                                    d.get("slot_overlap"), d.get("conclusion_overlap")))
+                elif d.get("type") == "condition_clash":
+                    parts.append("条件互斥 vs %s（覆盖 %s）"
+                                 % (d.get("with"), d.get("score")))
+                elif d.get("type"):
+                    parts.append("%s vs %s" % (d.get("type"), d.get("with")))
         nid = self.add_unresolved(question=question, known_clues=clues,
-                                  goal="结构精化：补缺失条件分支")
+                                  goal="结构精化：补缺失条件分支（或裁决取值）",
+                                  context=" | ".join(parts))
         return {"unresolved_id": nid, "question": question}
 
     # ---------- 访问计数：append-only，检索路径不写节点文件 ----------