@furongjun1999/dsh-memory 0.6.1 → 0.7.0

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,7 +31,9 @@ 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,
@@ -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}

package/md_cg/nodefile.py

@@ -637,4 +637,77 @@ def cond_terms(text: str) -> list[str]:
             if seg not in seen:
                 seen.add(seg)
                 out.append(seg)
-    return out
+    return out
+
+
+# ---- §5.1 六要素的**索引角色**：那张表从 4 行长成 6 行（P2-1）------------------
+#
+# 理论真源 `docs/theory/智能论3.4.md:3053-3059` 的「要素 | 标记 | 内容 |
+# **图的索引角色**」表**只有 4 行**（功能名/生效条件/子功能/执行）。v0.4 §5.1
+# 依裁定 2 把表补成 6 行，后两行为**新增检索维度**；本常量即那 6 行的
+# **代码侧唯一真源**（检索面、索引条目、守卫三处共用一份，禁止各写一份）。
+#
+# 表的两列语义：
+#   · 字段名 = CCG 六要素之一（`CCG_MARKS` 的子集，顺序即理论表序）；
+#   · 索引键 = 该要素在检索面上的**键名**（前 4 行既有，后 2 行本批新增）。
+# 「索引键」进索引条目（`MdCG._node_entry`）成为**免读文件的扁指标量**——
+# 与既有 `time_window` / `observation_position` 同款理由（检索期不读盘）。
+CCG_INDEX_ROLES = (
+    ("功能名",     "语义符号",   "已有"),
+    ("生效条件",   "条件词",     "已有（S2 门控）"),
+    ("子功能",     "结构词",     "已有"),
+    ("执行",       "机制词",     "已有"),
+    ("验证方式",   "后置条件词", "P2-1 新增：按验证手段检索"),
+    ("不适用条件", "拒绝域词",   "P2-1 新增：按边界检索（boundary_hit）"),
+)
+
+#: 新增两行的**字段名 → 索引键名**映射（索引条目里的扁平键；单一真源）。
+#: 键名刻意带 `_terms` 后缀：它们是**词项列表**（扁指标量），不是正文行原样。
+POSTCONDITION_FIELD = "验证方式"
+REJECTION_FIELD = "不适用条件"
+POSTCONDITION_TERMS_KEY = "postcondition_terms"
+REJECTION_TERMS_KEY = "rejection_terms"
+INDEX_TERMS_KEYS = (POSTCONDITION_TERMS_KEY, REJECTION_TERMS_KEY)
+
+#: 索引词项的最小长度。口径与 `mdcg.NEG_MIN_TERM`（负条件判据的词长下限）
+#: **同值同义**：单字符碎片（的/与/3）不是检索键。两处不可各自取值——
+#: `md_cg/test_p2_six_elements.py` 有交叉断言钉住两常量相等。
+ELEMENT_TERM_MIN = 2
+
+#: 索引词项的切分面：槽分隔（；;）、短语分隔（，,、/）、括号与空白。
+#: 为什么与 `cond_terms` 不同：那两个要素是**自由文本行**（不是条件空间四槽
+#: 合成串），没有「槽标签：」前缀，故不需要剥标签那一步；切分面本身同族。
+_ELEMENT_TERM_SPLIT_RE = re.compile(r"[；;，,、/（）()\[\]【】{}\s]+")
+
+
+# 生效条件：value 为假值（None/空串/纯空白）时按空文本处理返回 []；否则按「；;，,、/（）()[]【】{}空白」切分、逐段 strip、丢弃长度 < ELEMENT_TERM_MIN 的段与纯数字段、命中 is_dep_sentinel（空值语义哨兵）或 is_placeholder_text（骨架占位）的段、以及已入选的重复段，返回保序去重的 out；
+def element_terms_from_text(value, min_len: int = ELEMENT_TERM_MIN) -> list[str]:
+    """要素文本 → 索引词项（**确定性切分，无语义猜测**）。
+
+    这是「六要素索引键」的**切分单点**：`MdCG._node_entry` 与守卫共用。
+    只做形态切分 + 空值语义剔除，不做任何同义/近义扩展（同 `cond_terms` 纪律）。
+    """
+    out, seen = [], set()
+    for seg in _ELEMENT_TERM_SPLIT_RE.split(str(value or "")):
+        seg = seg.strip().strip("。.．:：")
+        if len(seg) < int(min_len) or seg.isdigit():
+            continue
+        if is_dep_sentinel(seg) or is_placeholder_text(seg):
+            continue
+        if seg not in seen:
+            seen.add(seg)
+            out.append(seg)
+    return out
+
+
+# 生效条件：field_name 为 CCG 要素名且 content 含该行时，取该行值（走 ccg_field_value 单点）→ 经 element_terms_from_text 切分成词项列表；该行缺失/值为空时返回 []；
+def ccg_element_terms(content: str, field_name: str,
+                      min_len: int = ELEMENT_TERM_MIN) -> list[str]:
+    """CCG 要素文本 → 索引词项（**取值走既有单点**，检索面不得另写正则）。
+
+    取值**必须**经 `ccg_field_value`（仓内 CCG 行解析的唯一真源：冒号可有可无、
+    首个命中行为准、与写入闸门 `data/policy.json` 同一行语义）；本函数只在其上
+    叠加**切分**，绝不自己 `re.match(r"^#\\s*验证方式")` ——那会立刻长出第二套
+    行语义（`ccg_mark_present` 的取单点动因即此类分叉）。
+    """
+    return element_terms_from_text(ccg_field_value(content, field_name), min_len)

package/md_cg/semantic/canonical.py

@@ -31,6 +31,28 @@ from . import zh_en_atoms
 WIN = 6          # 组合共现窗口（token 距离，探针实证口径）
 _ATOMS_ZH = None
 
+# 中文段判据（单点，2026-09-30 检索归一层作用域收窄时立）：
+# 中文 = CJK 统一表意文字基本区 U+4E00–U+9FFF。与 en_normalizer 分词字符类
+# `[A-Za-z\u4e00-\u9fff]` 的中文区间同区间；rust/src/text.rs::is_zh 是同判据的
+# Rust 侧单点（两侧归一层共用同一判据；改动须两侧同步，否则 rank_parity 漂移）。
+# 消费方：unify.py::unify_query（中文段逐字保留）、rust/src/atoms.rs::Atoms::unify。
+ZH_LO, ZH_HI = "\u4e00", "\u9fff"
+
+
+# 生效条件：单参 ch 为长度恰为 1 的 str 时返回 ZH_LO <= ch <= ZH_HI（CJK 基本区）；长度 != 1（空串/多字符串）一律返回 False（2026-09-30 清理批次把边界收紧为「长度恰为 1」——此前只在 ch 为空串时为假，多字符串按字典序比较可能被误判为真）。
+def is_zh_char(ch):
+    """中文段判据（单点）：CJK 统一表意文字基本区 U+4E00–U+9FFF。
+
+    边界约定（2026-09-30 清理批次乙2）：**仅长度恰为 1 的串可为真**——
+    空串与长度 >1 的串一律 False。此前只有空串为假（链式比较
+    `ZH_LO <= ch` 对空串即假），而多字符串按字典序比较：`is_zh_char("中文")`
+    判真（首字符在区间即真）＝判据外溢。两侧调用点清点结果：本函数只有
+    `unify.py::_runs` 与 `test_unify_scope.py::zh_runs` 两处消费，均逐字符
+    传入 ⇒ 本收紧对存量行为零变更；Rust 侧 `text.rs::is_zh` 收 `char`，
+    天然无空/多字符二态，边界语义两侧一致（docstring 已互指）。
+    """
+    return len(ch) == 1 and ZH_LO <= ch <= ZH_HI
+
 
 # 生效条件：模块级常量 `_ATOMS_ZH` 为 None 时按 `__file__` 所在目录的 atoms.json 取 `data.get("atoms", [])` 各项 `zh` 建集合并缓存，非 None 时直接返回 `_ATOMS_ZH`。
 def atoms_zh():

package/md_cg/semantic/unify.py

@@ -1,45 +1,96 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-"""灵枢 · 检索 query 统一归一层（批次 15，2026-09-23 使用者口径定案）
-
-口径：**统一翻译为中文 → 归一化到标准中文集（atoms.json）→ 检索**。
-任何语言的 query 先归一为标准原子序列（空格 join）再进检索各路：
-  - 英文：en_normalizer（时态还原→停用词剔除→en→zh 语素映射）→
-    segment 展开为标准原子（「牛肉」→「牛 肉」，与 doc 侧 fm.semantic
-    原子形态同构）；
-  - 中文：segment 贪心最长匹配归一到 atoms.json 标准概念；
-  - 纯中文 query **原样返回**——segment+join+bigrams(去空白) 后与原文
-    等价，归一只对跨语 query 有信息增益（beef 与「牛肉」零共享字符，
-    形态归一救不了跨语），纯中文零变更纪律；
+"""灵枢 · 检索 query 统一归一层（批次 15 立；2026-09-30 使用者裁定收窄作用域）
+
+口径：**只对英文内容做翻译归一，中文内容原样不动**。
+query 先按「中文段 / 非中文段」切开，只有**非中文段里的英文**进归一链路：
+  - 非中文段（含 ASCII 字母）：en_normalizer（时态还原→停用词剔除→en→zh 语素
+    映射）→ segment 展开为标准原子（「牛肉」→「牛 肉」，与 doc 侧
+    fm.semantic 原子形态同构）；
+  - 中文段（CJK 统一表意文字基本区 U+4E00–U+9FFF，判据单点 =
+    `canonical.is_zh_char`）：**逐字保留、绝不切分、绝不送 segment**；
+  - 非英文段（数字/标点等，段内无 ASCII 字母）：原样保留（不是英文即不翻译）；
+  - 两段按原顺序以单空格 join，空白（段内/段间）一律折叠为单空格；
   - 专名/未登录词原样保留（词表边界 unknown_keep，非错误）。
 
-开关：MDCG_UNIFY_QUERY 默认 "1"（2026-09-23 使用者拍板口径转正）；
-"=0" 显式关回退。两侧同步：rust/mcdg-eval 读同一 env + 同一份
-atoms.json（scripts/rank_parity.py --dataset 对拍在两侧同开关态进行，
-A/B 差异归档为转正证据）。
+为什么收窄（2026-09-30 定因，实测于 locomo-zh-500 公开题池 500 题 / 567 池、
+eval_common jaccard + GLOBAL_CAP 解除、k=5）：旧口径「query 含任一 ASCII 字母
+即整条归一」会把**中夹英** query 的中文部分逐字切开（「自我接纳」→
+「自 我 接 纳」、「慈善跑」→「慈 善 跑」）；500 题里含 ASCII 字母的 145 条
+**全部**也含中文（无纯英文 query）。单点实测：整条归一 lexical hit@1 = 94.4% /
+lexical,fuzzy = 87.2%；只译英文片段 lexical = 95.8% / lexical,fuzzy = 96.6%；
+归一层全关 lexical = 96.4% / lexical,fuzzy = 97.2%。
+
+开关：MDCG_UNIFY_QUERY **默认关**（2026-09-30 使用者裁定，缺省由 "1" 翻为 "0"）。
+定因：本层本职是让**英文** query 命中中文节点，对中文检索池是**纯开销**——
+locomo-zh-500 公开题池（池 567 / 题 500）缺省关态 lexical hit@1 96.4% /
+lexical+fuzzy 97.2%，开态 95.8% / 96.6%（各跑两遍逐位相同）。
+
+三态判据（两侧同语义，唯一开态 = 显式 "1"）：
+
+    MDCG_UNIFY_QUERY      Python unify_on()   Rust Atoms::from_env()
+    未设                   False               None（不载入）
+    "0"                    False               None（不载入）
+    "1"                    True                Some(Atoms)（载入）
+
+显式 "1" 仍能开回（英文对照路要用）；两侧同源 en_zh_map.json
+（scripts/rank_parity.py --dataset 对拍在两侧同开关态进行）。
 
 归一失败（semantic 模块缺失等）静默原样返回——与 en_zh_terms 同降级
 风格，不阻断检索主链路。
+
+两侧同构：rust/src/atoms.rs::Atoms::unify 同语义、同中文判据；逐位对拍 fixture
+= `md_cg/semantic/unify_fixture.json`（本侧守卫 md_cg/test_unify_scope.py 与
+Rust 单测 unify_mixed_fixture_matches_python 钉同一份期望值）。
 """
 import os
 import re
 
-# 生效条件：无 required 形参，锚定环境变量名 MDCG_UNIFY_QUERY；当 os.environ.get("MDCG_UNIFY_QUERY", "1") == "1" 时返回 True，否则返回 False。
+from .canonical import is_zh_char
+
+# 生效条件：无 required 形参，锚定环境变量名 MDCG_UNIFY_QUERY；**未设**时取缺省 "0"（2026-09-30 使用者裁定：缺省关），当 os.environ.get("MDCG_UNIFY_QUERY", "0") == "1" 时返回 True，其余（未设 / "0" / 任何非 "1" 取值）返回 False。
 def unify_on() -> bool:
-    """统一归一层开关（默认开=口径定案转正；=0 显式关回退）。"""
-    return os.environ.get("MDCG_UNIFY_QUERY", "1") == "1"
+    """统一归一层开关（**默认关**；显式 =1 才开，=0/未设一律关）。"""
+    return os.environ.get("MDCG_UNIFY_QUERY", "0") == "1"
+
+
+# 生效条件：单参 text 为任意字符串（空串返回空列表），按 canonical.is_zh_char 逐字符判中文段，相邻同判据字符归并为一个连续段，返回 [(是否中文段, 段文本), ...] 的保序列表。
+def _runs(text):
+    """按中文判据切连续段：[(True, "中文段"), (False, "非中文段"), ...]。"""
+    out = []
+    cur = None
+    buf = []
+    for ch in text:
+        k = is_zh_char(ch)
+        if buf and k != cur:
+            out.append((cur, "".join(buf)))
+            buf = []
+        cur = k
+        buf.append(ch)
+    if buf:
+        out.append((cur, "".join(buf)))
+    return out
 
 
-# 生效条件：text 为 None/空串或开关关闭或不含 [A-Za-z] 时原样返回；否则经 canonical.query_atoms 归一为标准原子序列并以单空格 join 返回（归一产物为空或抛异常时原样返回）。
+# 生效条件：text 为 None/空串、或开关 MDCG_UNIFY_QUERY 取值不为 "1"（含**未设**——缺省 "0"，2026-09-30 起关）、或 strip 后不含 [A-Za-z] 时，原样返回 text（未 strip 的入参）；否则按中文段（canonical.is_zh_char）切分——中文段与不含 ASCII 字母的非中文段逐字保留、含 ASCII 字母的非中文段经 canonical.query_atoms 归一——各段折空白后按原顺序单空格 join；归一产物为空（trim 后）或抛异常时原样返回 text。
 def unify_query(text):
-    """检索入口统一归一：任意语言 query → 标准原子序列。"""
+    """检索入口统一归一：只译英文内容，中文段逐字原样。"""
     t = (text or "").strip()
     if not t or not unify_on() or not re.search(r"[A-Za-z]", t):
         return text
     try:
         from .canonical import query_atoms
-        atoms = query_atoms(t)
+        parts = []
+        for is_zh, run in _runs(t):
+            if is_zh or not re.search(r"[A-Za-z]", run):
+                seg = run                       # 中文段 / 非英文段：逐字保留
+            else:
+                atoms = query_atoms(run)        # 非中文段里的英文：既有链路
+                seg = " ".join(a for a in atoms if a)
+            seg = " ".join(seg.split())         # 段内空白折叠为单空格
+            if seg:
+                parts.append(seg)
     except Exception:
         return text
-    u = " ".join(a for a in atoms if a).strip()
+    u = " ".join(parts)
     return u if u else text