@furongjun1999/dsh-memory 0.7.2 → 0.7.3

package/md_cg/auditview.py

@@ -0,0 +1,248 @@
+# -*- coding: utf-8 -*-
+"""L5 证据审计面：只读组装器（路线 C）——「现值＋出处链＋两存/备择＋盲区＋退役史」。
+
+多主体世界模型对齐 v0.1 §4 路线 C：「给节点 id 输出『现值＋出处链＋两存/备择＋
+盲区＋退役史』。**纯读、零写路径改动**」。命名约束（设计稿复核修订）：**不得
+复用 `view` 参数名**（已被 roleviews 占用，mdcos._candidates 的 view 面）。
+
+五面数据源（全部只读）：
+  · 现值       —— `cg.get` 的 fm + 正文（层/生命态/验证态/时效/A1 检验强度/
+                 A2 幽灵标记/归属面）；
+  · 出处链     —— fm.derived_from（血缘）+ fm.edges（它引用谁）+ **反查**
+                 索引条目 edges（谁引用它，内存扫描免读盘）+ provenance 台账
+                 `_link.jsonl` 相关行；
+  · 两存/备择   —— `cg.check_consistency(..., auto_flywheel=False, exclude=<自身>)`
+                 的**只读复用**（与写入链同一判据）：同条件空间分歧/对照数/
+                 截断如实透出（「两存之为默认、冲突一等」的可见化）；
+  · 盲区       —— negative/positive evidence 计数、非适用条件、A2 幽灵标记、
+                 trust.validity 判定（未生效/已过期/未知）、verification_state；
+  · 退役史     —— fm.state_history / fm.verification_history（lifecycle/trust
+                 的既有 HISTORY_FIELD 快照）+ `evolution.history` 台账。
+
+成本如实：备择面复用一致性检查，大库上有候选截断（截断计数如实带出，hint
+与写入面同款）；本组装器**不落盘、不改任何状态**。超出 cap 的面截断并计数。
+"""
+from __future__ import annotations
+
+import os
+
+__all__ = ["build"]
+
+#: 各面截断上限（超限计数并如实带出 truncated）。
+DEFAULT_CAP = 8
+
+
+def _readable_guard(cg):
+    """读隔离谓词（与 linkref.known_ids 同口径）：不可调用时全放行。"""
+    fn = getattr(cg, "_readable", None)
+    return fn if callable(fn) else (lambda _e: True)
+
+
+def _referenced_by(cg, node_id, cap):
+    """反查：谁引用了本节点（索引条目 edges 的内存扫描；免读盘）。
+
+    **读隔离**（2026-10-05 复核 R3）：扫描按 `cg._readable` 过滤——不可读
+    节点的 id 与其引用关系不得经本面泄漏（与 linkref.known_ids /
+    evolution.entries 同口径：「不可见即不存在」）。
+    """
+    # H-4 纪律（test_h4_sustain_snapshot G1a）：从 cg.index 取回的 nodes
+    # 须先取**快照**再迭代——并发写者 flush 时裸迭代会撞「字典变更」。
+    _live = (getattr(cg, "index", None) or {}).get("nodes") or {}
+    nodes = dict(_live)
+    guard = _readable_guard(cg)
+    out, total = [], 0
+    for nid, e in nodes.items():
+        if nid == node_id:
+            continue
+        try:
+            if not guard(e):
+                continue
+        except Exception:                                 # noqa: BLE001 —— fail-closed
+            continue
+        for ed in (e.get("edges") or []):
+            if str(ed.get("target")) == node_id:
+                total += 1
+                if len(out) < cap:
+                    out.append({"from": nid, "relation": ed.get("relation_type"),
+                                "confidence": ed.get("confidence"),
+                                "source": ed.get("source")})
+                break
+    return {"items": out, "total": total, "truncated": total > len(out)}
+
+
+def _link_rows(cg, node_id, cap):
+    """provenance 台账（`_link.jsonl`）里与本节点相关的行。
+
+    **schema 对齐 provenance.make_edge**（2026-10-05 复核 R1 修）：真字段是
+    `child/parent/rel/t/actor`（原实现按 `target/source/relation/at` 匹配
+    ⇒ 恒读空，整面死）。「与本节点相关」＝ child==本节点（它派生自谁）或
+    parent==本节点（谁派生自它）。
+
+    **行级读隔离**（2026-10-05 复验 R4 修）：行是否可见取决于**另一端**——
+    「不可见即不存在」的口径下，verify 身份不得经本面看到不可读 secret
+    节点的 id 与其派生关系（复验实证：修复前与 designer 视角逐位相同）。
+    另一端条目不在索引或不可读 ⇒ **整行不出**（fail-closed，与
+    `_referenced_by` 的 guard 同口径；自身端必可读——本函数只在本节点
+    已可读[build 的 cg.get 成功]之后被调用）。
+    """
+    try:
+        from . import provenance
+        path = provenance.ledger_file(getattr(cg, "root", None))
+    except Exception:                                     # noqa: BLE001
+        return {"items": [], "total": 0, "truncated": False}
+    if not path or not os.path.exists(path):
+        return {"items": [], "total": 0, "truncated": False}
+    _live = (getattr(cg, "index", None) or {}).get("nodes") or {}
+    nodes = dict(_live)                    # H-4 快照纪律（迭代前取快照）
+    guard = _readable_guard(cg)
+    out, total = [], 0
+    try:
+        with open(path, encoding="utf-8", errors="replace") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    import json
+                    rec = json.loads(line)
+                except Exception:                         # noqa: BLE001
+                    continue
+                if not isinstance(rec, dict):
+                    continue
+                c, p = str(rec.get("child")), str(rec.get("parent"))
+                if c == node_id:
+                    other = p
+                elif p == node_id:
+                    other = c
+                else:
+                    continue
+                e_other = nodes.get(other)
+                if e_other is None:
+                    continue                       # 另一端不在索引（含已删）→ 不出
+                try:
+                    if not guard(e_other):
+                        continue                   # 另一端不可读 → 整行不出
+                except Exception:                  # noqa: BLE001 —— fail-closed
+                    continue
+                total += 1
+                if len(out) < cap:
+                    out.append({k: rec.get(k) for k in
+                                ("child", "parent", "rel", "t", "actor", "note")})
+    except Exception:                                     # noqa: BLE001 —— 只读面不抛
+        pass
+    return {"items": out, "total": total, "truncated": total > len(out)}
+
+
+def build(cg, node_id, cap=DEFAULT_CAP) -> dict:
+    """组装五面只读视图。node_id 不存在 ⇒ {"ok": False, "error": "node_not_found"}。
+
+    cap 防御（2026-10-05 复核 Y2）：非数/None 回落缺省、钳 [1, 64]——
+    直调面与 MCP 面同语义（MCP 面的钳制在分发层，直调 API 不得裸抛 TypeError）。
+    """
+    try:
+        cap = int(cap)
+    except (TypeError, ValueError):
+        cap = DEFAULT_CAP
+    cap = max(1, min(64, cap))
+    nid = str(node_id or "").strip()
+    if not nid:
+        return {"ok": False, "error": "node_not_found", "node_id": node_id}
+    rec = cg.get(nid)
+    if not rec:
+        return {"ok": False, "error": "node_not_found", "node_id": nid}
+    fm = rec.get("frontmatter") or {}
+    content = rec.get("content") or ""
+    from . import evolution, lifecycle, nodefile, trust
+
+    # ---- 面一：现值 ----
+    try:
+        _validity = trust.validity(fm)
+    except Exception as exc:                              # noqa: BLE001
+        _validity = "%s: %s" % (type(exc).__name__, exc)
+    present = {
+        "layer": fm.get("layer"),
+        "lifecycle_state": lifecycle.state_of(fm),
+        "verification_state": trust.state_of(fm),
+        "validity": _validity,
+        "importance": fm.get("importance"),
+        "sensitivity": fm.get("sensitivity"),
+        "created_at": fm.get("created_at"),
+        "tags": fm.get("tags"),
+        "verification_basis": fm.get("verification_basis"),
+        nodefile.CHECK_STRENGTH_FIELD: fm.get(nodefile.CHECK_STRENGTH_FIELD),
+        nodefile.UNCERTAIN_REFS_FIELD: fm.get(nodefile.UNCERTAIN_REFS_FIELD),
+        "writer": fm.get("writer"), "harness": fm.get("harness"),
+        "session": fm.get("session"),
+        "content_chars": len(content),
+    }
+
+    # ---- 面二：出处链 ----
+    _edges = list(fm.get("edges") or [])
+    sources = {
+        "derived_from": fm.get("derived_from"),
+        "derived_relation": fm.get("derived_relation"),
+        "refers_to": {"items": _edges[:cap], "total": len(_edges),
+                      "truncated": len(_edges) > cap},
+        "referenced_by": _referenced_by(cg, nid, cap),
+        "link_ledger": _link_rows(cg, nid, cap),
+    }
+
+    # ---- 面三：两存/备择（一致性只读复用；不建单、不落盘）----
+    alternatives = {"comparable": None, "verdict": None, "conflicts": [],
+                    "missing": [], "truncated": None, "scanned": None}
+    try:
+        # log_write=False（复核 R2 修）：只读消费面——判定照常、台账不写
+        #（consistency.log 原为无条件追加，审计会变成隐式写）。
+        cvd = cg.check_consistency(
+            content, layer=fm.get("layer") or "knowledge",
+            condition_space=fm.get("condition_space"),
+            non_applicable_conditions=fm.get("non_applicable_conditions"),
+            tags=fm.get("tags"), exclude=nid, auto_flywheel=False,
+            log_write=False)
+        if isinstance(cvd, dict):
+            cf = list(cvd.get("conflicts") or [])
+            alternatives = {
+                "verdict": cvd.get("verdict"), "reason": cvd.get("reason"),
+                "conflict_strength": cvd.get("conflict_strength"),
+                "comparable": cvd.get("comparable"),
+                "scanned": cvd.get("scanned"), "truncated": cvd.get("truncated"),
+                "conflicts": cf[:cap],
+                "conflicts_total": len(cf), "conflicts_truncated": len(cf) > cap,
+                "missing": list(cvd.get("missing") or [])[:cap],
+                "hint": cvd.get("hint"),
+            }
+    except Exception as exc:                              # noqa: BLE001 —— 只读面不抛
+        alternatives["error"] = "%s: %s" % (type(exc).__name__, exc)
+
+    # ---- 面四：盲区 ----
+    blindspots = {
+        "negative_evidence": fm.get("negative_evidence", 0),
+        "positive_evidence": fm.get("positive_evidence", 0),
+        "non_applicable_conditions": fm.get("non_applicable_conditions"),
+        nodefile.UNCERTAIN_REFS_FIELD: fm.get(nodefile.UNCERTAIN_REFS_FIELD),
+        "verification_state": trust.state_of(fm),
+        "validity": _validity,
+        "note": ("未决不进二值：DEFER/unresolved 痕迹在『两存/备择』与 "
+                 "negative_evidence 面；本面只呈现，不下判断。"),
+    }
+
+    # ---- 面五：退役史 ----
+    _sh = list(fm.get(lifecycle.HISTORY_FIELD) or [])
+    _vh = list(fm.get(trust.HISTORY_FIELD) or [])
+    _ev = []
+    try:
+        _ev = list((evolution.history(cg, nid, limit=cap) or {}).get("entries") or [])
+    except Exception:                                     # noqa: BLE001
+        pass
+    history = {
+        lifecycle.HISTORY_FIELD: _sh[-cap:],
+        trust.HISTORY_FIELD: _vh[-cap:],
+        "evolution": _ev[:cap],
+        "totals": {lifecycle.HISTORY_FIELD: len(_sh),
+                   trust.HISTORY_FIELD: len(_vh), "evolution_scanned": len(_ev)},
+    }
+
+    return {"ok": True, "node_id": nid, "cap": cap,
+            "present": present, "sources": sources,
+            "alternatives": alternatives, "blindspots": blindspots,
+            "history": history}

package/md_cg/bench_e2e_judge.py

@@ -40,7 +40,8 @@
   python -X utf8 -m md_cg.bench_e2e_judge --quick        # 冒烟 20题×level 0,1×无LLM
   python -X utf8 -m md_cg.bench_e2e_judge                # 全量 120题×4级×3臂+LLM两轮
   python -X utf8 -m md_cg.bench_e2e_judge --skip-llm     # 只跑确定性两臂
-环境：DEEPSEEK_API_KEY（LLM 臂）；数据落 --data-root（默认 D:/program/test/e2e_judge）
+环境：DEEPSEEK_API_KEY（LLM 臂）；数据落 --data-root（默认 <仓根父目录>/test/e2e_judge，
+可用 MDCG_E2E_JUDGE_ROOT 覆盖）
 """
 from __future__ import annotations
 
@@ -64,7 +65,8 @@ from md_cg.mdcos import MdCGOS                             # noqa: E402
 from md_cg import nodefile                                 # noqa: E402
 
 DATA_SRC = os.path.join(HERE, "data", "benchmarks", "locomo-zh-500")
-DEFAULT_ROOT = r"D:\program\test\e2e_judge"
+DEFAULT_ROOT = os.environ.get("MDCG_E2E_JUDGE_ROOT") or os.path.join(
+    os.path.dirname(HERE), "test", "e2e_judge")
 FUSION_KW = dict(paths=("lexical", "bucket", "entity", "graph", "fuzzy"),
                  fusion="sum")
 LEVELS_DEFAULT = (0, 1, 2, 4)

package/md_cg/branches.py

@@ -111,6 +111,12 @@ def fork(cg, node_ids, branch_id=None, note=None) -> dict:
                condition_space=fm.get("condition_space"),
                importance=float(fm.get("importance", 0.5)),
                verification_basis=fm.get("verification_basis") or "test",
+               # A1（2026-10-05，复核补）：断言质量字段随副本携带（与
+               # verification_basis 同族；缺省 None 时 add 不落键，零行为变化）。
+               check_strength=fm.get("check_strength"),
+               # A2（2026-10-05）：幽灵引用标记随副本携带（正文属性——副本
+               # 正文与主支一致则标记有效；缺省 None 不落键）。
+               uncertain_refs=fm.get("uncertain_refs"),
                non_applicable_conditions=fm.get("non_applicable_conditions"),
                consistency=False,
                derived_from=[nid], relation="split_from",
@@ -156,8 +162,16 @@ def rewrite(cg, node_id, content, tags=None, importance=None,
     if isinstance(content, dict) or content is None:
         return {"ok": False, "error": "content 须为字符串"}
     for k in ("branch_id", "branched_from", "branch_note", "derived_from",
-              "relation", "merged_from_branch", "override", "consistency"):
-        extra.pop(k, None)   # 归属/血缘/写法闸不可经 extra 篡改
+              "relation", "merged_from_branch", "override", "consistency",
+              "uncertain_refs"):
+        extra.pop(k, None)   # 归属/血缘/写法闸/检测产物不可经 extra 篡改
+    # A2（2026-10-05，复核 yellow-1 修）：标记按**新正文**重算——本函数是
+    # 「改正文的唯一正路」，携带旧标记会与正文脱节（干净正文带陈旧标记 /
+    # 幽灵正文漏标，双向都错）；与 mdcg.add「正文属性、按当次检测重算」
+    # 的声明同口径。
+    from . import ghostref as _ghostref
+    _ur = _ghostref.find_ghost_phrases(
+        str(content or ""), known=set((cg.index.get("nodes") or {}).keys()))
     cg.add(nid, str(content or ""),
            layer=fm.get("layer") or e.get("layer") or "knowledge",
            tags=list(tags if tags is not None else (fm.get("tags") or [])),
@@ -165,6 +179,10 @@ def rewrite(cg, node_id, content, tags=None, importance=None,
                             else (fm.get("importance") or 0.5)),
            condition_space=fm.get("condition_space"),
            verification_basis=fm.get("verification_basis") or "test",
+           # A1（2026-10-05，复核补）：断言质量字段随重写携带（同上）。
+           check_strength=fm.get("check_strength"),
+           # A2（2026-10-05）：幽灵引用标记按新正文重算（见上）。
+           uncertain_refs=_ur or None,
            non_applicable_conditions=fm.get("non_applicable_conditions"),
            override=True, consistency=False,
            derived_from=list(fm.get("derived_from") or []),
@@ -203,13 +221,21 @@ def merge(cg, branch_id, reason=None) -> dict:
         chain = list(old_fm.get("derived_from") or [])
         if nid not in chain:
             chain.append(nid)
-        cg.add(orig, (src or {}).get("content") or "",
+        # A2（2026-10-05，复核 yellow-2① 修）：主支正文 = 分支正文 ⇒ 标记按
+        # 该正文重算（此前不携带 = 幽灵正文回写后无标记，方向与「宁标勿漏」
+        # 相反；fork/rewrite 已接线，此处补齐同族）。
+        from . import ghostref as _ghostref
+        _mcontent = (src or {}).get("content") or ""
+        _mur = _ghostref.find_ghost_phrases(
+            _mcontent, known=set((cg.index.get("nodes") or {}).keys()))
+        cg.add(orig, _mcontent,
                layer=old_fm.get("layer") or e.get("layer") or "knowledge",
                tags=list(old_fm.get("tags") or e.get("tags") or []),
                condition_space=src_fm.get("condition_space"),
                importance=float(old_fm.get("importance", 0.5)),
                verification_basis=old_fm.get("verification_basis") or "test",
                non_applicable_conditions=old_fm.get("non_applicable_conditions"),
+               uncertain_refs=_mur or None,
                override=True, consistency=False,
                derived_from=chain, relation="merged_from",
                merged_from_branch=bid, actor="branch_merge")

package/md_cg/consistency.py

@@ -51,6 +51,7 @@ import os
 import time
 
 from .mdcg import expand_query_terms_weighted
+from . import nodefile
 
 # --------------------------------------------------------------------------
 # 常量（全部可审计、可调）
@@ -250,21 +251,28 @@ def _ban_hit(content, neg_texts):
     return False
 
 
-# 生效条件：content 为真时按行过滤，跳过 strip 后以 "#" 开头且含全角或半角冒号的行，其余原行以换行连接返回；content 假值按空串返回 ""；
+# 生效条件：委托 nodefile._strip_ccg_segments(content, nodefile.CCG_MARKS)（剥除算法单点）——命中 CCG 要素标题行（判据单点 nodefile._ccg_heading_rest，`^#\s*<要素>` 冒号可有可无）即整段剥除：行内带值（`# 生效条件：v`／前缀式）只剥该行，裸标题（`# 不适用条件`）连同其后首个非空、非标题行（该字段的值行，取值口径同 nodefile.ccg_field_value）一并剥除；其余原行以换行连接返回；content 假值按空串返回 "";
 def _body_text(content):
-    """去掉 CCG 声明行（`# 字段：值`）后的正文。
+    """去掉 CCG 声明**整段字段**后的正文。
 
     自否定看的是「正文/生效条件是否与不适用条件矛盾」，不能把节点自己声明的
     `# 不适用条件：X` 当成 X 出现在正文里——否则**每个**声明了不适用条件的
     正常节点都会被误判为自相矛盾（真实 CCG 条目普遍带该字段）。
+
+    N238：判据复用**单点** `nodefile._ccg_heading_rest`（与写入闸门
+    data/policy.json 同一行语义、`mdcos._ccg_field` / `ccg_mark_present` 同源），
+    并连同**无冒号形态的值行**一起剥。此前本地判据是「以 # 开头**且含冒号**」，
+    裸标题 `# 不适用条件` 与其值行双双残留正文：同内容写成带冒号时
+    `_body_text == ''`（不命中），写成无冒号时 body 含禁令短语 ⇒ `_ban_hit`
+    恒中 ⇒ self_negation / strength=1.0 ⇒ REJECT（writepipe 下合法节点被拦入
+    review_queue 并自动建飞轮工单）。「冒号可有可无」已由
+    `nodefile.ccg_mark_present` / `ccg_field_value` 定案（test_ccg_form_parity
+    验收 PASS），本处是漏网的分叉。
+
+    A3 追认：剥除算法本身也已收单点 `nodefile._strip_ccg_segments`（六要素全剥）
+    ——本处不再自持循环，避免与 `nodefile.positive_body` 各写一份而再次漂移。
     """
-    out = []
-    for line in (content or "").splitlines():
-        s = line.strip()
-        if s.startswith("#") and ("：" in s or ":" in s):
-            continue
-        out.append(line)
-    return "\n".join(out)
+    return nodefile._strip_ccg_segments(content, nodefile.CCG_MARKS)
 
 
 # 生效条件：text 假值时按空串处理，返回把任意连续空白（半角/全角空格、\t、\r、\n）折叠为单个半角空格并去掉首尾空白后的字符串；纯空白文本返回空串 "";
@@ -484,16 +492,21 @@ 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 剔除空值语义哨兵——⑧ 漏斗单点）；选面（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；
+# 生效条件：以 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_write 为真时 log 并返回 rec；N276：精比环的索引代际探针循环外单探一次（环内 cg.get(nid, probe=False)；无探活面载体回落 cg.get(nid)，行为零变）；
 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,
-          query=None):
+          query=None, log_write=True):
     """节点间自动冲突检测（L0 情绪 → L1 反思 → L2 递归反思）。
 
     返回完整判据（可审计）：
       verdict / reason / conflict_strength / emotional / conflicts[] /
       recursion{} / missing[] / unresolved_id（若触发飞轮）
+
+    log_write（路线 C，2026-10-05）：缺省 True＝原行为（每次判定落
+    `_consistency.jsonl` 台账）。**只读消费面**（如 auditview 的证据审计）
+    须传 False——判定结果照常返回，但不写台账（复核 R2：审计面承诺
+    「纯读、不落盘」，而 log() 无条件追加会把每次审计变成一次写）。
       + 选面读数 scanned / kept / truncated（超限时另附 hint）
 
     verdict：
@@ -619,9 +632,20 @@ def check(cg, content, layer=None, condition_space=None,
     scanned = len(cand)                  # 预筛后候选数（截断前）
     kept = len(scan_face)                # 实际精比数（相关面 ∪ 保底面）
     truncated = scanned > kept
+    # N276（第 32 轮性能面）：scan_face 精比环内逐节点 cg.get 会各自重探索引
+    # 签名（快照 stat + listdir + 逐分片 stat，单点实测 ~38µs；本库 200 次/
+    # 调用全同签名重探）——循环外单探一次、环内 probe=False；语义窗口=本批
+    # 读期间「他进程写入」不被探知（毫秒级，与读缓存已声明的进程内一致性
+    # 边界同款）；无探活面的载体（测试桩）回落原 cg.get(nid)，行为零变。
+    _probe = getattr(cg, "_maybe_reload_index", None)
+    if callable(_probe):
+        _probe()
+    else:
+        _probe = None
     seeds = []
     for nid, e in scan_face:
-        node = cg.get(nid) or {}
+        node = (cg.get(nid, probe=False) if _probe is not None
+                else cg.get(nid)) or {}
         fm = node.get("frontmatter") or {}
         body = node.get("content") or ""
         e_pos, e_neg = _declared(fm, body)
@@ -769,7 +793,8 @@ def check(cg, content, layer=None, condition_space=None,
     if auto_flywheel and verdict in FLYWHEEL_TRIGGERS:
         rec["unresolved_id"] = _fire_flywheel(cg, query or content, verdict,
                                               reason, missing, allc)
-    log(cg, rec)
+    if log_write:
+        log(cg, rec)
     return rec
 
 

package/md_cg/datapath.py

@@ -50,22 +50,49 @@ ENV_AUX_ROOT = "MDCG_AUX_ROOT"
 DEFAULT_AUX_DIRNAME = ".mdcg"
 
 
+#: Windows 保留设备名全集（末段直判用；比对前统一 .upper()，故此处全大写）：
+#: DOS 设备名 CON/PRN/AUX/NUL、控制台伪设备 CONIN$/CONOUT$、COM1-9/LPT1-9，
+#: 以及 Windows 承认的上标数字变体 COM¹²³/LPT¹²³（上标 0 与 4-9 不是保留名）。
+_RESERVED_DEVICE_NAMES = frozenset(
+    ["CON", "PRN", "AUX", "NUL", "CONIN$", "CONOUT$"]
+    + [f"COM{i}" for i in range(1, 10)]
+    + [f"LPT{i}" for i in range(1, 10)]
+    + ["COM\u00b9", "COM\u00b2", "COM\u00b3",
+       "LPT\u00b9", "LPT\u00b2", "LPT\u00b3"])
+
+
+# 生效条件：纯字符串判定（不触盘、无平台分支——平台闸在调用处 _abs_host_path）；
+# 传入 path 归一（"/" → "\"）后去尾随反斜杠取末段，末段按首个 "." 截断取 stem、
+# 再去尾随空格，stem.upper() 命中 _RESERVED_DEVICE_NAMES 即返回 True，否则 False。
+# 末段直判不依赖 OS/Python 版本的 GetFullPathNameW 吞并行为——较新 Windows 构建
+# 不再把「目录\aux」吞成 \\.\aux（issue #57），前缀判据随之失效，本函数是稳定判据。
+def _reserved_device_tail(path: str) -> bool:
+    seg = path.replace("/", "\\").rstrip("\\").split("\\")[-1]
+    stem = seg.split(".", 1)[0].rstrip(" ")
+    return stem.upper() in _RESERVED_DEVICE_NAMES
+
+
 # 生效条件：p 按仓库既有口径 expanduser+abspath 归一；平台为 Windows（os.name=="nt"）
-# 且归一结果以设备命名空间前缀（"\\\\.\\"）开头时抛 ValueError——保留设备名末段
-# （aux/con/nul/prn/com1-9/lpt1-9 等）会被 GetFullPathNameW 吞成设备路径
-# （例 D:\sandbox\aux → \\.\aux），目录语义静默丢失，密钥/令牌/数据覆盖键随之
-# 静默失联；非 Windows 平台该形态是合法目录名字面量，不判定。归一是纯字符串
-# 操作不触盘，路径无需存在即可复现。env_key 传覆盖键名（env 变量名或 paths.json
-# 键），仅用于错误消息定位误配来源；为空时消息以「该路径」指代。
+# 且命中两因之一时抛 ValueError——① 归一结果以设备命名空间前缀（"\\\\.\\"）开头：
+# 保留设备名末段（aux/con/nul/prn/com1-9/lpt1-9 等）被 GetFullPathNameW 吞成设备
+# 路径（例 D:\sandbox\aux → \\.\aux）；② 归一结果末段直判为保留设备名
+# （_reserved_device_tail）：较新 Windows 构建不再吞并（issue #57），旧前缀判据
+# 失效，末段直判不依赖 OS 行为——两因并置互为兜底。后果同：目录语义静默丢失，
+# 密钥/令牌/数据覆盖键随之静默失联；非 Windows 平台该形态是合法目录名字面量，
+# 不判定。归一是纯字符串操作不触盘，路径无需存在即可复现。env_key 传覆盖键名
+# （env 变量名或 paths.json 键），仅用于错误消息定位误配来源；为空时消息以
+# 「该路径」指代。
 def _abs_host_path(p: str, env_key: str = "") -> str:
     r = os.path.abspath(os.path.expanduser(p))
-    if os.name == "nt" and r.startswith("\\\\.\\"):
+    if os.name == "nt" and (r.startswith("\\\\.\\")
+                            or _reserved_device_tail(r)):
         who = env_key or "该路径"
         raise ValueError(
-            f"{who} 归一后解析为 Windows 设备命名空间路径 {r!r}：末段是 Windows "
-            "保留设备名（aux/con/nul/prn/com1-9/lpt1-9 等），GetFullPathNameW 会把"
-            "整个目录吞成设备路径，目录语义静默丢失（落在此处的密钥/令牌/数据会"
-            f"静默失联）；请把 {who} 改指向末段不含保留设备名的普通目录。")
+            f"{who} 归一后末段是 Windows 保留设备名（{r!r}）：GetFullPathNameW "
+            "可能把整个目录吞成设备路径（\\\\.\\aux 形态，目录语义静默丢失）；"
+            "较新 Windows 构建即便不吞并，保留设备名末段也一律按误配拒绝——"
+            "本守卫末段直判不依赖 OS 吞并行为（issue #57）。请把 "
+            f"{who} 改指向末段不含保留设备名的普通目录。")
     return r
 
 

package/md_cg/forgetting.py

@@ -174,7 +174,7 @@ def self_coverage(cg, node_id, content):
     return round(_coverage(bigrams(payload(content)), body), 4)
 
 
-# 生效条件：content 经 payload/bigrams 得空集合时直接返回零值 best（max=0.0、with=None、compared=0）；否则遍历 cg.index 的 nodes，跳过 nid==exclude，layer 为真值时只比较 str(layer 字段 or "")==layer 的节点，cg.get(nid) 抛异常/返回假值、或该节点 content 的 bigrams 为空则跳过，每计入一个节点后若 n>=limit 立即 break（故 limit 为 0 或负数时只比较首项即停），返回覆盖度最大者 best（无覆盖度提升时不更新 with/jaccard，compared 为实际计入数）。
+# 生效条件：content 经 payload/bigrams 得空集合时直接返回零值 best（max=0.0、with=None、compared=0）；否则**循环外经 cg._maybe_reload_index() 单探一次**（N276：无该方法/不可调用的载体跳过，环内回落原 cg.get(nid)），遍历 cg.index 的 nodes，跳过 nid==exclude，layer 为真值时只比较 str(layer 字段 or "")==layer 的节点，cg.get(nid, probe=False)（无探活面的载体回落 cg.get(nid)）抛异常/返回假值、或该节点 content 的 bigrams 为空则跳过，每计入一个节点后若 n>=limit 立即 break（故 limit 为 0 或负数时只比较首项即停），返回覆盖度最大者 best（无覆盖度提升时不更新 with/jaccard，compared 为实际计入数）。
 def redundancy(cg, content, layer="contextual", exclude=None, limit=MAX_COMPARE):
     """Q1 重复？——新内容被既有同层节点覆盖的最大比例。"""
     new = bigrams(payload(content))
@@ -182,6 +182,18 @@ def redundancy(cg, content, layer="contextual", exclude=None, limit=MAX_COMPARE)
     if not new:
         return best
     nodes = ((getattr(cg, "index", None) or {}).get("nodes") or {})
+    # N276（第 32 轮性能面）：**批内代际探针只做一次**——循环里每次 cg.get
+    # 都会经 MdCG.get 首行重算索引签名（快照 stat + listdir + 逐分片 stat，
+    # 单点实测 ~38µs；本库 240 次/调用全同签名重探）。此处循环外探一次、
+    # 环内 cg.get(nid, probe=False)。语义窗口=**本调用期间「他进程写入」
+    # 不被探知**（毫秒级；读取环本就按当次快照判定，与读缓存/热缓存已声明
+    # 的进程内一致性边界同款，故注释记账即可）；无探活面的载体（测试桩）
+    # 回落原 cg.get(nid)，行为零变。
+    _probe = getattr(cg, "_maybe_reload_index", None)
+    if callable(_probe):
+        _probe()
+    else:
+        _probe = None
     n = 0
     for nid in list(nodes.keys()):
         if nid == exclude:
@@ -189,7 +201,8 @@ def redundancy(cg, content, layer="contextual", exclude=None, limit=MAX_COMPARE)
         if layer and str(nodes[nid].get("layer") or "") != layer:
             continue
         try:
-            node = cg.get(nid)
+            node = (cg.get(nid, probe=False) if _probe is not None
+                    else cg.get(nid))
         except Exception:
             node = None
         if not node:

package/md_cg/freshness.py

@@ -179,22 +179,31 @@ def resolve_gamma(gamma=None) -> float:
 # 核（一律经 time_core；本模块不写指数核）
 # --------------------------------------------------------------------------
 
-# 生效条件：gamma 与 dt_days（单位=天）任意可转 float 时，返回 time_core.cred_factor(gamma, dt_days, floor, ceil)；dt 非有限值（inf/nan）时同样交给 cred_factor（inf → 取 floor）；
+# 生效条件：gamma 与 dt_days（单位=天）任意可转 float 时，返回 time_core.cred_factor(gamma, dt_days, floor, ceil)；dt 非有限值（inf/nan）时同样交给 cred_factor（inf → 取 floor）；enabled 为 None（缺省）时自算（模块级 enabled()），显式传 bool 时按传入值——两者皆假值即恒返回 1.0；
 def decay_factor(gamma: float, dt_days: float, floor: float = SCORE_FLOOR,
-                 ceil: float = SCORE_CEIL) -> float:
+                 ceil: float = SCORE_CEIL, enabled=None) -> float:
     """时间衰减乘子 `e^(-γ·Δt)`（**核来自唯一权威** `time_core.cred_factor`）。
 
     ⚠ `dt_days` 的单位**必须**是「天」（`DT_UNIT`）；调用方负责换算，
     换算单点是 `entry_weight`（`(now - created_at) / SECONDS_PER_DAY`）。
+
+    `enabled`（N274）：None=自算（默认，行为与改动前逐位一致）；显式传
+    bool 时不再自算——供 `entry_weight`/`_score` 把开关**循环外解析一次**
+    后透传，消掉逐节点 env 读取。自算分支写 `globals()["enabled"]()` 而非
+    直接 `enabled()`：形参同名会遮蔽模块函数，而 `globals()` 的解析语义与
+    改前那句 `enabled()` 逐位一致（含测试对模块函数的打桩/替换面）。
     """
-    if not enabled():
+    if enabled is None:
+        enabled = globals()["enabled"]()
+    if not enabled:
         return 1.0
     return _tc.cred_factor(float(gamma), float(dt_days), float(floor),
                            float(ceil))
 
 
-# 生效条件：access_count 与 last_access 任意（不可转数值按 0 处理）、importance 任意可转 float；按 REFRESH_PARAMS 的三档判定返回 1.0+gain / 1.0−gain / 1.0；
-def refresh_factor(access_count=0, last_access=0, importance=0.0) -> float:
+# 生效条件：access_count 与 last_access 任意（不可转数值按 0 处理）、importance 任意可转 float；enabled 为 None（缺省）时自算（模块级 enabled()），显式传 bool 时按传入值——两者皆假值即恒返回 1.0；否则按 REFRESH_PARAMS 的三档判定返回 1.0+gain / 1.0−gain / 1.0；
+def refresh_factor(access_count=0, last_access=0, importance=0.0,
+                   enabled=None) -> float:
     """访问刷新/降权乘子（**门槛与步长照抄 AEIS** `consolidate_cycle`）。
 
     判定序（与 AEIS 同序同门）：
@@ -209,8 +218,13 @@ def refresh_factor(access_count=0, last_access=0, importance=0.0) -> float:
     在**从未被访问**（`access_count == 0`）时也为真——照抄原样会让「刚写、
     从未调用的高重要度节点」白拿一次刷新。加此闸后「未被调用」只能不刷新，
     不会反被奖励（语义仍与 §7.1「被经常调用的记忆其权重被刷新」一致）。
+
+    `enabled`（N274）：None=自算（默认，行为与改动前逐位一致）；显式传
+    bool 时不再自算——与 `decay_factor` 同一透传口径（见其 docstring）。
     """
-    if not enabled():
+    if enabled is None:
+        enabled = globals()["enabled"]()
+    if not enabled:
         return 1.0
     p = REFRESH_PARAMS
     try:
@@ -251,8 +265,8 @@ def protected_floor(entry) -> float:
     return max(SCORE_FLOOR, min(1.0, IMPORTANCE_PROTECT / imp))
 
 
-# 生效条件：entry 为可取 created_at / access_count / last_access / importance / protected 的映射；fm 为真值时上述五个键优先取自 fm（缺键回落 entry）；now 为假值（None）时取 freshness_now()；无条件返回 (乘子, 依据 dict)——乘子 = decay_factor(gamma, |now-created_at|/86400, protected_floor(取数后的映射), SCORE_CEIL) × refresh_factor(...)；created_at 缺失/不可转数值/≤0 时 dt_days 取 inf（判「距参照无穷远」，由 floor 兜住）；
-def entry_weight(entry, now=None, gamma=None, fm=None) -> tuple:
+# 生效条件：entry 为可取 created_at / access_count / last_access / importance / protected 的映射；fm 为真值时上述五个键优先取自 fm（缺键回落 entry）；now 为假值（None）时取 freshness_now()；enabled 为 None（缺省）时自算（模块级 enabled()），显式传 bool 时按传入值——两者皆假值即早退返回 (1.0, {"disabled": True})（早退先于 now/γ 解析，与改前同序）；否则无条件返回 (乘子, 依据 dict)——乘子 = decay_factor(gamma, |now-created_at|/86400, protected_floor(取数后的映射), SCORE_CEIL, enabled=…) × refresh_factor(..., enabled=…)；created_at 缺失/不可转数值/≤0 时 dt_days 取 inf（判「距参照无穷远」，由 floor 兜住）；
+def entry_weight(entry, now=None, gamma=None, fm=None, enabled=None) -> tuple:
     """索引条目 → 分数乘子 `(乘子, 依据)`（**检索期唯一取数点**，免读文件）。
 
     `entry` 直接来自索引快照（`_node_entry` 已落 `created_at` /
@@ -260,6 +274,11 @@ def entry_weight(entry, now=None, gamma=None, fm=None) -> tuple:
 
     `fm` 为可选覆盖源（写面刚落的 frontmatter 可能比索引条目新）：只为
     避免在热路径上拷贝 dict 而设，取数优先级 `fm > entry > 缺省`。
+
+    `enabled`（N274）：None=自算（默认，行为与改动前逐位一致）；显式传
+    bool 时不再自算，且向下透传给 `decay_factor`/`refresh_factor`——它们
+    同样不再各自读 env。自算分支经 `globals()["enabled"]()`（形参遮蔽，
+    解析语义同改前的 `enabled()`，见 `decay_factor` 同注）。
     """
     e = entry or {}
     keys = ("created_at", "access_count", "last_access", "importance",
@@ -269,7 +288,9 @@ def entry_weight(entry, now=None, gamma=None, fm=None) -> tuple:
                for k in keys}
     else:
         src = {k: e.get(k) for k in keys}
-    if not enabled():
+    if enabled is None:
+        enabled = globals()["enabled"]()
+    if not enabled:
         return 1.0, {"disabled": True}
     g = resolve_gamma(gamma)
     ref = freshness_now() if now is None else float(now)
@@ -286,9 +307,9 @@ def entry_weight(entry, now=None, gamma=None, fm=None) -> tuple:
         # 微变）且两侧跨语言同值。详见 DT_QUANTUM_DAYS 的说明。
         dt_days = float(int(dt_days / DT_QUANTUM_DAYS)) * DT_QUANTUM_DAYS
     floor = protected_floor(src)
-    d = decay_factor(g, dt_days, floor, SCORE_CEIL)
+    d = decay_factor(g, dt_days, floor, SCORE_CEIL, enabled=enabled)
     r = refresh_factor(src.get("access_count"), src.get("last_access"),
-                       src.get("importance"))
+                       src.get("importance"), enabled=enabled)
     return d * r, {"gamma": g, "dt_days": dt_days, "unit": DT_UNIT,
                    "decay": d, "refresh": r, "floor": floor,
                    "protected": bool(src.get("protected"))}