@furongjun1999/dsh-memory 0.7.1 → 0.7.3

package/md_cg/test_n238_body_text_parity.py

@@ -0,0 +1,156 @@
+# -*- coding: utf-8 -*-
+"""N238 · `_body_text` 剥除判据须与 CCG 形态单点同源（冒号可有可无）。
+
+运行：python -m md_cg.test_n238_body_text_parity
+
+缺陷（本会话实跑复现）：
+  `consistency._body_text` 的本地判据是「以 `#` 开头**且含冒号**」——
+  无冒号形态的六要素（`# 不适用条件` + 换行 + 值行）不满足该条件，标题行
+  与**值行**双双残留正文。后果：同一条内容
+    带冒号 `# 不适用条件：不得把甲当作乙` → `_body_text == ''`、不命中；
+    无冒号 `# 不适用条件` + `不得把甲当作乙` → body 含该短语 ⇒
+    `_ban_hit(body, neg)` 恒 True ⇒ self_negation / conflict_strength=1.0
+    ⇒ verdict=REJECT（writepipe 的 auto_flywheel 下合法节点被拦入
+    review_queue 并自动建飞轮工单）。
+  「冒号可有可无」已由单点 `nodefile._ccg_heading_rest` / `ccg_mark_present` /
+  `ccg_field_value` 定案（`test_ccg_form_parity` 验收），本处是漏网的分叉。
+
+修法：`_body_text` 复用单点判据，剥「标题行在即已声明」的**整段字段**——
+行内带值（冒号式/前缀式）只剥该行；裸标题连同其后首个非空、非标题行
+（值行，口径同 `nodefile.ccg_field_value`）一并剥除。
+
+本套断言（纯行为，不做源码文本匹配）：
+ ① 三种书写形态的声明段一律剥净（`_body_text == ''`），且判定结论同值
+ ② 判别力自证：禁令短语真出现在**正文**时仍命中 self_negation（不同形态各测）
+ ③ 值行剥除的边界（紧跟标题不吞／隔空行取值行／行内冒号不误剥后文）
+ ④ 逐要素 × 逐形态机械对拍：只声明该要素 + 一行正文 ⇒ `_body_text == 正文`
+ ⑤ 飞轮侧证据：合法无冒号节点不再触发 auto_flywheel 建单；真自否定仍触发
+"""
+from __future__ import annotations
+
+import os
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from md_cg import consistency, nodefile
+
+PASS = FAIL = 0
+FAILS = []
+
+
+# 生效条件：cond 为真时 PASS 加 1 并打印 [PASS]，否则 FAIL 加 1、把 label 记入 FAILS 并打印 [FAIL]。
+def ok(cond, label):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print("  [PASS] %s" % label)
+    else:
+        FAIL += 1
+        FAILS.append(label)
+        print("  [FAIL] %s" % label)
+
+
+MARKS = nodefile.CCG_MARKS                      # 六要素（真源，不另抄一份）
+VALS = {"功能名": "测试条目", "生效条件": "载体/位置：本地源码仓；时间：全时窗",
+        "子功能": "演示", "执行": "步骤一", "验证方式": "test",
+        "不适用条件": "不得把甲当作乙"}
+
+
+# 生效条件：form 取 "colon"／"bare"／"mixed"，返回按该形态书写的六要素声明段；
+def decls(form: str) -> str:
+    out = []
+    for i, m in enumerate(MARKS):
+        v = VALS[m]
+        use_colon = (form == "colon") or (form == "mixed" and i % 2 == 0)
+        out.append("# %s：%s\n" % (m, v) if use_colon else "# %s\n%s\n" % (m, v))
+    return "".join(out)
+
+
+class _CG:
+    """最小 cg 替身：空索引（无从比对 ⇒ 判定只看新节点自身）+ 飞轮计数。"""
+
+    def __init__(self, root):
+        self.index = {"nodes": {}}
+        self.root = root
+        self.flywheel_calls = []
+
+    def flywheel_step(self, payload):
+        self.flywheel_calls.append(payload)
+        return {"unresolved_id": "unr_test_%d" % len(self.flywheel_calls)}
+
+
+def main() -> int:
+    tmp = tempfile.mkdtemp()
+
+    print("== ① 三种形态的声明段一律剥净，且判定结论同值 ==")
+    verdicts = {}
+    for form in ("colon", "bare", "mixed"):
+        body = consistency._body_text(decls(form))
+        ok(body == "", "①%s：_body_text 剥净（得到 %r）" % (form, body))
+        cg = _CG(tmp)
+        rec = consistency.check(cg, decls(form), log_write=False)
+        verdicts[form] = (rec["verdict"], rec["conflict_strength"],
+                          tuple((c["type"], c["score"]) for c in rec["conflicts"]))
+        ok(not rec["conflicts"] and rec["conflict_strength"] == 0.0,
+           "①%s：无硬冲突、strength=0.0（%s）" % (form, verdicts[form][:2]))
+    ok(len(set(verdicts.values())) == 1,
+       "①同内容三形态判定结论一致（%s）" % (verdicts,))
+
+    print("== ② 判别力自证：禁令短语真在正文时仍判 self_negation ==")
+    for form in ("colon", "bare", "mixed"):
+        real = decls(form) + "本流程说明：不得把甲当作乙，否则告警。\n"
+        body = consistency._body_text(real)
+        ok(consistency._ban_hit(body, ["不得把甲当作乙"]),
+           "②%s：正文残留行命中禁令短语" % form)
+        rec = consistency.check(_CG(tmp), real, log_write=False)
+        ok(rec["verdict"] == "REJECT" and rec["conflict_strength"] == 1.0
+           and any(c["type"] == "self_negation" for c in rec["conflicts"]),
+           "②%s：仍判 REJECT/self_negation/1.0（%s）"
+           % (form, (rec["verdict"], rec["conflict_strength"])))
+
+    print("== ③ 值行剥除的边界 ==")
+    s = "# 功能名\n# 生效条件：x\n"
+    ok(consistency._body_text(s) == "" and nodefile.ccg_field_value(s, "功能名") == "",
+       "③裸标题后紧跟另一标题：值空、不吞下一要素")
+    s = "# 执行\n\n真实值行\n后文行\n"
+    ok(consistency._body_text(s) == "后文行\n"
+       and nodefile.ccg_field_value(s, "执行") == "真实值行",
+       "③裸标题后隔空行取值行：剥值行、留后文（与取值单点同口径）")
+    s = "# 生效条件：条件A\n正文第一行\n正文第二行\n"
+    ok(consistency._body_text(s) == "正文第一行\n正文第二行\n",
+       "③行内冒号式：后续正文不被误剥")
+    ok(consistency._body_text("") == "", "③空正文 → 空串")
+
+    print("== ④ 逐要素 × 逐形态机械对拍（只声明该要素 + 一行正文）==")
+    line = "正文一行\n"
+    for form in ("colon", "bare", "mixed"):
+        for i, m in enumerate(MARKS):
+            v = VALS[m]
+            use_colon = (form == "colon") or (form == "mixed" and i % 2 == 0)
+            one = ("# %s：%s\n" % (m, v)) if use_colon else ("# %s\n%s\n" % (m, v))
+            got = consistency._body_text(one + line)
+            ok(got == line, "④%s「%s」：剥净该要素段（得到 %r）" % (form, m, got))
+
+    print("== ⑤ 飞轮侧证据：合法无冒号节点不再自动建单 ==")
+    cg_ok = _CG(tmp)
+    rec = consistency.check(cg_ok, decls("bare"), auto_flywheel=True, log_write=False)
+    ok(rec["verdict"] != "REJECT" and not cg_ok.flywheel_calls,
+       "⑤合法无冒号节点：verdict=%s、flywheel_step 调用 %d 次（须 0，无工单）"
+       % (rec["verdict"], len(cg_ok.flywheel_calls)))
+    cg_bad = _CG(tmp)
+    consistency.check(cg_bad, decls("bare") + "本流程说明：不得把甲当作乙。\n",
+                      auto_flywheel=True, log_write=False)
+    ok(len(cg_bad.flywheel_calls) == 1,
+       "⑤真自否定仍建单：flywheel_step 调用 1 次（判别力未削弱）")
+
+    print()
+    print("ccg_body_text_n238: PASS=%d FAIL=%d" % (PASS, FAIL))
+    if FAILS:
+        print("FAILS: " + "; ".join(FAILS))
+    return 1 if FAIL else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_n276_probe_hoist.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""N276 守卫 · 批内单探针（写链读环的索引代际探活只做一次）。
+
+背景（第 32 轮性能面）：`MdCG.get` 首行无条件 `_maybe_reload_index()`，
+而写链读环（`forgetting.redundancy` 240 上限 / `consistency.check` 精比环）
+在环内逐节点 `cg.get(nid)` —— 每次重算同一个索引签名（快照 stat +
+listdir + 逐分片 stat）。修法：`get` 增可选 `probe=True`（默认零变），
+两环循环外单探一次、环内 `cg.get(nid, probe=False)`。
+
+覆盖判据（调用计数优先；墙钟只作辅助不作断言）：
+  C1 `forgetting.redundancy` 环内零重探：探针计数 == 1（修前 == 同层可比
+     节点数，上限 MAX_COMPARE）
+  C2 `consistency.check` 精比环零重探：探针计数 == 1（修前 == len(scan_face)）
+  C3 `get(node_id, probe=False)` 与 `get(node_id)` 返回逐位一致（默认语义零变）
+  C4 自证腿：旧签名 `get(nid)` 逐次探针（spy 有判别力；默认 probe=True 未变
+     ——若有人把默认改 False 或去掉环外探针，C1/C2/C4 必红）
+  C5 可见性不丢：他实例写入后，单探 + `probe=False` 组合读到新节点（不陈旧）
+  C6 无探活面载体（测试桩）回落原 `cg.get(nid)`（既有桩零破坏）
+  C7 等价性：redundancy/check 在「单探 + probe=False」与「逐节点 probe=True」
+     两形态下输出逐位一致（C7a/C7b）
+
+运行：python -X utf8 -m md_cg.test_n276_probe_hoist
+退出码：0 = 全绿；1 = 有失败。
+硬边界：库根一律 tempfile；不动在役数据根；不 git add/commit/push。
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import sys
+import tempfile
+
+_HERE = os.path.dirname(os.path.abspath(__file__))
+_REPO = os.path.dirname(_HERE)
+sys.path.insert(0, _REPO)
+
+from md_cg import consistency, forgetting                    # noqa: E402
+from md_cg.mdcos import MdCGSecure                           # noqa: E402
+from md_cg.security import Principal                         # noqa: E402
+
+PASS = FAIL = 0
+FAILS = []
+
+BODY = ("# 功能名：%s\n# 生效条件：载体=守卫夹具\n# 子功能：占位\n"
+        "# 执行：占位\n# 验证方式：compiler 复现\n# 不适用条件：无\n\n"
+        "蜂群调度 节点 %s 依赖门禁 收敛 检索\n")
+CONTENT = ("# 功能名：待写样本\n# 生效条件：载体=守卫夹具\n# 子功能：占位\n"
+           "# 执行：占位\n# 验证方式：compiler 复现\n# 不适用条件：无\n\n"
+           "蜂群调度 待写 依赖门禁 收敛 苹果 章节\n")
+
+
+def check(name, cond, detail=""):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  [PASS] {name}" + (f"  · {detail}" if detail else ""))
+    else:
+        FAIL += 1
+        FAILS.append(name)
+        print(f"  [FAIL] {name}  · {detail}")
+
+
+def _principal():
+    return Principal(actor="n276", clearance="secret", can_write=True,
+                     role="designer", auth_mode="test")
+
+
+def _lib(n=12):
+    root = tempfile.mkdtemp(prefix="n276_")
+    cg = MdCGSecure(root, principal=_principal())
+    for i in range(n):
+        cg.add("k_%02d" % i, BODY % (i, i), layer="knowledge")
+    cg.flush()
+    return root, cg
+
+
+def _spy(cg):
+    """spy `cg._maybe_reload_index`（实例属性；两类 get 与环外探针都经它）。"""
+    calls = {"n": 0}
+    orig = cg._maybe_reload_index
+
+    def s():
+        calls["n"] += 1
+        return orig()
+    cg._maybe_reload_index = s
+    return calls, orig
+
+
+def main():
+    root, cg = _lib()
+    calls, orig_probe = _spy(cg)
+    try:
+        # ---------- C1 redundancy 环内零重探 ----------
+        print("== C1 forgetting.redundancy 环内零重探 ==")
+        calls["n"] = 0
+        r1 = forgetting.redundancy(cg, CONTENT, layer="knowledge")
+        n1 = calls["n"]
+        check("C1a redundancy 探针 == 1（修前 == min(同层节点, 240)）",
+              n1 == 1, f"calls={n1}")
+        check("C1b redundancy 正常产出（compared>0）",
+              r1.get("compared", 0) > 0, str(r1))
+
+        # ---------- C4 自证腿：旧签名逐次探针 ----------
+        print("== C4 自证腿（旧签名照旧逐次探针）==")
+        ids = sorted(cg.index["nodes"].keys())
+        calls["n"] = 0
+        for nid in ids:
+            cg.get(nid)
+        n4 = calls["n"]
+        check("C4a 旧签名 get(nid) 逐次探针（spy 有判别力）",
+              n4 == len(ids), f"calls={n4} ids={len(ids)}")
+
+        # ---------- C2 check 精比环零重探 ----------
+        print("== C2 consistency.check 精比环零重探 ==")
+        calls["n"] = 0
+        rc = consistency.check(cg, CONTENT, layer="knowledge",
+                               log_write=False)
+        n2 = calls["n"]
+        check("C2a check 探针 == 1（修前 == len(scan_face)）",
+              n2 == 1, f"calls={n2} kept={rc.get('kept')}")
+        check("C2b check 正常产出（verdict 在场）",
+              isinstance(rc.get("verdict"), str), str(rc.get("verdict")))
+
+        # ---------- C3 probe=False 与默认逐位一致 ----------
+        print("== C3 get(probe=False) 与 get() 逐位一致 ==")
+        a = cg.get("k_00")
+        b = cg.get("k_00", probe=False)
+        check("C3a 两形态返回等值（id/frontmatter/content/path）",
+              a is not None and b is not None and a == b)
+
+        # ---------- C5 可见性不丢（他实例写入） ----------
+        print("== C5 他实例写入后单探 + probe=False 可见 ==")
+        cgB = MdCGSecure(root, principal=_principal())
+        cgB.add("k_new", BODY % ("new", "new"), layer="knowledge")
+        cgB.flush()
+        cgB.close()
+        calls["n"] = 0
+        cg._maybe_reload_index()                 # 循环外单探（生产探针位）
+        probe_calls_before_get = calls["n"]
+        node = cg.get("k_new", probe=False)
+        check("C5a 单探后 probe=False 读到新节点（不陈旧）",
+              bool(node) and "new" in (node.get("content") or ""),
+              f"node={'yes' if node else 'None'}")
+        check("C5b 该组合探针恰好 1 次（外面那次）",
+              probe_calls_before_get == 1 and calls["n"] == 1,
+              f"calls={calls['n']}")
+
+        # ---------- C6 无探活面载体回落 ----------
+        print("== C6 测试桩回落原 cg.get(nid) ==")
+        class _Stub:
+            def __init__(self):
+                self.index = {"nodes": {"s1": {"path": "knowledge/s1.md",
+                                               "layer": "knowledge"}}}
+
+            def get(self, nid):
+                return {"id": nid, "frontmatter": {},
+                        "content": "占位 苹果 章节", "path": "knowledge/s1.md"}
+        r6 = forgetting.redundancy(_Stub(), CONTENT, layer="knowledge")
+        check("C6a 无 _maybe_reload_index 的载体不崩且正常比对",
+              r6.get("compared") == 1, str(r6))
+
+        # ---------- C7 两形态等价 ----------
+        print("== C7 单探形态 vs 逐节点探针形态逐位一致 ==")
+        r_prod = forgetting.redundancy(cg, CONTENT, layer="knowledge")
+        rc_prod = consistency.check(cg, CONTENT, layer="knowledge",
+                                    log_write=False)
+        orig_get = cg.get
+
+        def _always_probe(nid, probe=True):
+            return orig_get(nid, probe=True)     # 强制回到逐节点探针
+        cg.get = _always_probe
+        try:
+            r_full = forgetting.redundancy(cg, CONTENT, layer="knowledge")
+            rc_full = consistency.check(cg, CONTENT, layer="knowledge",
+                                        log_write=False)
+        finally:
+            cg.get = orig_get
+        check("C7a redundancy 两形态逐位一致（max/with/jaccard/compared）",
+              r_prod == r_full, f"prod={r_prod} full={r_full}")
+        _strip = lambda d: {k: v for k, v in d.items() if k != "t"}  # noqa: E731
+        check("C7b check 两形态逐位一致（剔动态键 t）",
+              _strip(rc_prod) == _strip(rc_full),
+              f"prod={_strip(rc_prod).get('verdict')}/{_strip(rc_prod).get('kept')}"
+              f" full={_strip(rc_full).get('verdict')}/{_strip(rc_full).get('kept')}")
+    finally:
+        cg._maybe_reload_index = orig_probe
+        cg.close()
+        shutil.rmtree(root, ignore_errors=True)
+
+    print(f"\ntest_n276_probe_hoist: {PASS} 通过 / {FAIL} 失败")
+    if FAILS:
+        for f in FAILS:
+            print(f"  - {f}")
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_p4_freshness.py

@@ -285,8 +285,14 @@ def g5_same_multiplier_slot():
               0 < kd - jd <= 12
               and all(l.strip() for l in seg[jd + 1:kd]),
               f"pooling 行={jd} 乘子行={kd}")
+        # N274：乘子行改为「调用跨两行」形态（循环外提升后追加
+        # now/gamma/enabled 关键字透传）——判据性质不变（仍要求乘子**直接
+        # 乘在 raw 上**、同一乘子位、以 [0] 取乘子），仅匹配形态同步为
+        # 跨行；并顺带收紧为「行首即 raw = raw * …」。
         check("乘子直接乘在 raw 上（同一乘子位，不新开乘子链）",
-              "raw * freshness.entry_weight(e, fm=fm)[0]" in seg[kd])
+              seg[kd].strip().startswith("raw = raw * freshness.entry_weight(")
+              and "[0]" in (seg[kd] + seg[kd + 1]),   # 单行/跨行两形态皆可
+              f"kd 行={seg[kd]!r} 次行={seg[kd + 1]!r}")
         # 行为：同内容两节点，仅 created_at 不同 → 分数比 == 乘子比
         scored = _score_pair(cg)
         m_new = F.entry_weight(cg.index["nodes"]["k_new"], now=REF)[0]
@@ -577,6 +583,93 @@ def g12_rust_parity_e2e():
         shutil.rmtree(root, ignore_errors=True)
 
 
+def g13_hot_loop_reads():
+    """N274：freshness 读取点全部提升到 `_score` 循环外（调用计数判据）。
+
+    判据＝**与文档数无关**：同一 `_score` 调用于 2 节点与 20 节点两批文档
+    时，`enabled`/`freshness_now`/`resolve_gamma`/`temporal_gamma` 的调用
+    计数相同。修前（8000 池实测，2026-10-05）为每节点 7 次（enabled 4×N
+    + now/γ/temporal 各 N）；墙钟只作辅助，不作判据。
+    """
+    print("== G13 freshness 读取提升到 _score 循环外（N274）==")
+    import md_cg.mdcos as MC
+    root, cg = _lib()
+    c = {"enabled": 0, "now": 0, "gamma": 0, "temporal": 0}
+    orig = {n: getattr(F, n) for n in ("enabled", "freshness_now",
+                                       "resolve_gamma")}
+    orig_tg = MC.temporal_gamma
+
+    def _wrap(fn, key):
+        def _w(*a, **k):
+            c[key] += 1
+            return fn(*a, **k)
+        return _w
+
+    F.enabled = _wrap(orig["enabled"], "enabled")
+    F.freshness_now = _wrap(orig["freshness_now"], "now")
+    F.resolve_gamma = _wrap(orig["resolve_gamma"], "gamma")
+    MC.temporal_gamma = _wrap(orig_tg, "temporal")
+    try:
+        def _mk_docs(n):
+            return [({"path": "knowledge/k%d.md" % i},
+                     {"id": "k%d" % i, "tags": [],
+                      "created_at": REF - i * DAY, "access_count": 0,
+                      "last_access": 0, "importance": 0.5},
+                     BODY.format(n="k%d" % i, t="k%d 正文 苹果 章节" % i))
+                    for i in range(n)]
+
+        def _count(docs):
+            for k in c:
+                c[k] = 0
+            cg._score(docs, "苹果 章节",
+                      M.bigrams(M.normalize_en("苹果 章节")))
+            return dict(c)
+
+        c2 = _count(_mk_docs(2))
+        c20 = _count(_mk_docs(20))
+        # 判据面＝**env 读取三面**（enabled / freshness_now / temporal_gamma
+        # ——后者是 γ 的实际读取点：resolve_gamma 的 early-return 分支不碰
+        # temporal_gamma，故「temporal_gamma 常数」即「γ 的 env 读取归零」）。
+        # 诚实边界：resolve_gamma 的**函数调用**仍每节点一次（early-return
+        # 直通已解析的 float，~0.15µs/节点、不读 env）——保留它是因为
+        # resolve_gamma 还承担「非法 gamma 回落缺省」的单点边界语义，跳过
+        # 调用会改变该边界。
+        check("env 读取面与文档数无关（enabled/now/temporal；修前各 N×）",
+              {k: c2[k] for k in ("enabled", "now", "temporal")}
+              == {k: c20[k] for k in ("enabled", "now", "temporal")},
+              f"c2={c2} c20={c20}")
+        check("enabled() 常数级（修前 = 4×N）", c20["enabled"] <= 2, str(c20))
+        check("freshness_now() 常数级（修前 = 1×N）", c20["now"] <= 1, str(c20))
+        check("temporal_gamma() 常数级（修前 = 1×N；γ 的实际读取点）",
+              c20["temporal"] <= 1, str(c20))
+        # 自证腿（常驻）：全缺省签名的旧路径仍自算，四个 spy 数得到——证明
+        # 上面的「零/常数」不是 spy 失效造成的假绿（判别力在位）。
+        for k in c:
+            c[k] = 0
+        F.entry_weight({"created_at": REF, "importance": 0.5})
+        check("自证腿：全缺省签名仍自算（四路 spy 各 ≥1，判别力在位）",
+              c["enabled"] >= 1 and c["now"] >= 1 and c["gamma"] >= 1
+              and c["temporal"] >= 1, str(c))
+        # 语义等价：显式透传与自算逐位同值；关闭恒 1.0（三面同口径）
+        e0 = {"created_at": REF - 30 * DAY, "importance": 0.5}
+        check("显式 enabled+now+γ 透传与自算同值（逐位一致）",
+              F.entry_weight(e0, now=REF)[0]
+              == F.entry_weight(e0, now=REF, gamma=F.resolve_gamma(None),
+                                enabled=True)[0])
+        check("enabled=False 恒 1.0（entry/decay/refresh 三面同口径）",
+              F.entry_weight(e0, now=REF, enabled=False)[0] == 1.0
+              and F.decay_factor(0.023, 100.0, enabled=False) == 1.0
+              and F.refresh_factor(0, 0, 0.9, enabled=False) == 1.0)
+    finally:
+        F.enabled = orig["enabled"]
+        F.freshness_now = orig["freshness_now"]
+        F.resolve_gamma = orig["resolve_gamma"]
+        MC.temporal_gamma = orig_tg
+        cg.close()
+        import shutil
+        shutil.rmtree(root, ignore_errors=True)
+
+
 def _mut_floor_zero():
     return _patch(F, "SCORE_FLOOR", 0.0)
 
@@ -641,6 +734,7 @@ def _collect():
     g10_weights_autoprotect_kept()
     g11_rust_parity()
     g12_rust_parity_e2e()
+    g13_hot_loop_reads()
     return list(FAILS)
 
 

package/md_cg/test_policy_required_ccg.py

@@ -109,9 +109,11 @@ _BASELINE_MUTATIONS = {
 # autonomy_modes（2026-10-02 补，三档自治批次②）：writepipe.py 新增链尾档位闸
 # `_gate_autonomy`，其函数内 `from . import autonomy_modes as _am` 被本文件的
 # AST 相对-import 扫描命中——不登记则假包缺模块（SHIM-MISS 红，容器栈一实测）。
+# ghostref（2026-10-05 补，A2 幽灵引用批次）：writepipe.py 新增 `_gate_ghostref`，
+# 其函数内 `from . import ghostref as _ghostref` 同款被扫描命中——同规则登记。
 _SHIMS = ("twophase", "trust", "linkref", "mcp_server", "mdcg", "forgetting",
           "units", "coldverify", "hotcache", "hyperedge", "nodefile",
-          "autonomy_modes")
+          "autonomy_modes", "ghostref")
 _SHIM_TPL = ("import md_cg.%s as _m\n"
              "globals().update({k: v for k, v in vars(_m).items()\n"
              "                 if not k.startswith('__')})\n")

package/md_cg/test_readcache_prodpath.py

@@ -77,6 +77,28 @@ def count_opens(fn):
         builtins.open = real
 
 
+def count_pb(fn):
+    """打桩 md_cg.nodefile.positive_body 计数（N273 召回键派生物调用面）。
+
+    计数面覆盖直调与钩子内直调（`MdCG._positive_body` 默认实现即调它）——
+    readcache 缓存版命中时该函数零调用，「未缓存实现」下每候选一次。
+    """
+    import md_cg.nodefile as _nf
+    n = 0
+    real = _nf.positive_body
+
+    def _spy(content):
+        nonlocal n
+        n += 1
+        return real(content)
+
+    _nf.positive_body = _spy
+    try:
+        return fn(), n
+    finally:
+        _nf.positive_body = real
+
+
 def main():
     root = tempfile.mkdtemp(prefix="mdcg_readcache_")
     os.environ.pop("MDCG_READ_CACHE", None)
@@ -148,9 +170,53 @@ def main():
         check("P6a 热缓存后二次检索派生物零重算（identity 不变）",
               same and len(snap) > 0, f"snap={len(snap)}")
 
+        # P8 `_positive_body` 派生物缓存（N273，`_like` 召回键面）——与 P6
+        # 同形判定：调用计数为主判据（修前实现每候选一次、8000 池实测
+        # 8000 次/查询），identity 快照为辅。
+        print("== P8 召回键派生物缓存（_positive_body，N273）==")
+        pbc = getattr(cg, "_positive_body_cache", {})
+        snap_pb = {k: v[1] for k, v in pbc.items()}
+        check("P8pre 召回键派生物缓存已装载", len(snap_pb) > 0,
+              f"entries={len(snap_pb)}")
+        (_res8, n_pb), = (count_pb(lambda: cg.search("蜂群调度")),)
+        check("P8a 热态二次检索 _positive_body 零重调（修前 = 每候选一次）",
+              n_pb == 0, f"calls={n_pb}")
+        pbc2 = getattr(cg, "_positive_body_cache", {})
+        same_pb = all(pbc2[k][1] is snap_pb[k] for k in snap_pb if k in pbc2)
+        check("P8b 热态二次检索派生物零重算（identity 不变）",
+              same_pb and len(snap_pb) > 0, f"snap={len(snap_pb)}")
+        # 写 1 节点 → 脏集精确失效：仅新 path 重算（旧条目零重算）
+        cg.add("pb_new", "# 功能名：召回键样本\n# 正文：蜂群调度 新增节点 独有标记PB\n"
+                         "# 不适用条件：仅当 排除场景PB 时", layer="knowledge")
+        cg.flush()
+        (_res8c, n_pb8), = (count_pb(lambda: cg.search("蜂群调度")),)
+        check("P8c 写 1 节点后仅该节点重算（脏集精确失效）", n_pb8 == 1,
+              f"calls={n_pb8}")
+        check("P8c2 写后新内容可检索（不陈旧）",
+              any(x[0].get("id") == "pb_new" for x in _res8c[0]),
+              f"ids={[x[0].get('id') for x in _res8c[0]][:5]}")
+        # P8d 红基线自证腿：摘回**未缓存**实现（类上原方法）跑同一查询，
+        # 调用计数必须 >0——证明 P8a 的「零重调」判据对「无缓存层」形态有
+        # 判别力（不依赖 git 回退的常驻自证）。
+        from md_cg.mdcg import MdCG as _MdCG
+        _saved_pb = cg._positive_body
+        cg._positive_body = _MdCG.__dict__["_positive_body"].__get__(
+            cg, type(cg))
+        try:
+            (_res8d, n_pb_uncached), = (count_pb(lambda: cg.search("蜂群调度")),)
+        finally:
+            cg._positive_body = _saved_pb
+        check("P8d 红基线自证：未缓存实现下同查询调用计数 >0",
+              n_pb_uncached > 0, f"calls={n_pb_uncached}")
+        check("P8e 恢复缓存版后再次零重调",
+              count_pb(lambda: cg.search("蜂群调度"))[1] == 0,
+              "缓存版未复原")
+
         # P5 clear 兜底（破坏性，放最后）
         n = rc.clear(cg)
         check("P5 clear 返回清空条目数", n > 0, f"cleared={n}")
+        check("P5b clear 一并清空召回键派生物缓存",
+              len(getattr(cg, "_positive_body_cache", {})) == 0)
 
         # P7 写代际单调（批次 23，issue #31 D-4 / v20 复现场景，能红 len 代际）
         print("== P7 flush 后同量写入不回退（D-4 陈旧读）==")

package/md_cg/test_sleep.py

@@ -11,6 +11,10 @@
        `state_root` 侧而非数据根；**绝不在数据根内建 `.git`**；
     ④ 回滚**只提供 `revert`**（不提供抹历史的强推档）。
 
+⚠ **口径更新（2026-10-06 · issue #60）**：① 的「逐字节不变」是**物化窗口内的读数**
+（`materialize.face_stable`），**不再是「跳过迭代」的闸**——窗口内漂移由 ③ 对账段
+的并发闸按「主库优先」逐项裁决；`materialize.ok` 只说「影子挂上了没」（见 G8）。
+
 断言分组：
 
   G0 隔离与落点——沙箱四根全落守卫临时目录；锁文件在 `state_root` 侧、**不在数据根**；
@@ -32,6 +36,9 @@
      `busy=True` 且不取得锁；父进程释放后同一子进程脚本转 `ok=True`。
   G7 判据自身有判别力（正对照）——改动一个 .md 后 `face_delta` 必须报 changed；
      给根里加一个非白名单 .md 之外的件不改变判据（负对照）。
+  G8 物化窗口内漂移（issue #60）——`ok` = **物化动作成功**（挂上影子即 True），
+     `face_stable` = 真源面窗口内逐字节未变（原 ok 的真值）；漂移时
+     `source_face_delta.added` 照旧逐项报出，`baseline_face` 照旧记录。
 
 运行：python -X utf8 -m md_cg.test_sleep
       python -X utf8 -m md_cg.test_sleep --mutate         # 定点变异自证
@@ -485,7 +492,57 @@ def g7():
        "G7c 正对照：删除 .md 被报为 removed", d2)
 
 
-_GROUPS = (g0, g1, g2, g3, g4, g5, g6, g7)
+# ---------------------------------------------------------------- G8
+def g8():
+    print("== G8 物化窗口内漂移：ok=物化动作成功、face_stable=真源面未变（issue #60）==")
+    S = globals()["SL"]
+    gen, root, state = _fixture()
+    G = os.path.join(state, "sleep", "lib.git")
+    SH = os.path.join(state, "sleep", "shadow")
+    # 补丁要打在**函数实际读取的命名空间**上（`materialize.__globals__`），而不是
+    # 模块属性：变异自证时 `SL` 是 exec 出来的模块，其函数读 exec 命名空间，而模块
+    # 对象的 `__dict__` 只是它的副本——打在模块属性上，变异后的模块内部调用看不到
+    # 补丁（本机实测：该断言会在变异下空转，反而误红）。真源码下两者是同一个 dict。
+    ns = S.materialize.__globals__
+    real = ns["source_face_hashes"]
+    seen = {"n": 0}
+
+    def _drift(r):
+        """只在物化窗口的**第二次**取样（= after）注入一条新增路径。"""
+        seen["n"] += 1
+        d = dict(real(r))
+        if seen["n"] == 2:
+            d["knowledge/n_drift.md"] = "0" * 64
+        return d
+
+    try:
+        ns["source_face_hashes"] = _drift
+        m = S.materialize(root=root, git_dir_path=G, shadow=SH, ts="G8T1")
+    finally:
+        ns["source_face_hashes"] = real
+    ok(m.get("ok") is True and m.get("busy") is False,
+       "G8a **物化成功即 ok=True**（不再因窗口内真源面漂移自我否决）",
+       {k: m.get(k) for k in ("ok", "busy", "error", "hint")})
+    ok(m.get("face_stable") is False,
+       "G8b face_stable=False（窗口内确有漂移——原 ok 的真值迁到该读数）",
+       m.get("face_stable"))
+    ok(m["source_face_delta"]["added"] == ["knowledge/n_drift.md"]
+       and not m["source_face_delta"]["removed"]
+       and not m["source_face_delta"]["changed"],
+       "G8c source_face_delta.added 逐项报出漂移路径（原读数保留）",
+       m["source_face_delta"])
+    ok(bool(m.get("baseline_face")) and os.path.isdir(SH)
+       and os.path.exists(os.path.join(SH, ".git")),
+       "G8d 漂移不阻断挂影子：baseline_face 已记录、影子在位",
+       (bool(m.get("baseline_face")), SH))
+    # 负对照：窗口内无漂移 ⇒ face_stable=True（该读数不是恒假）
+    m2 = S.materialize(root=root, git_dir_path=G, shadow=SH, ts="G8T2")
+    ok(m2.get("ok") is True and m2.get("face_stable") is True,
+       "G8e 负对照：窗口内无漂移 ⇒ face_stable=True",
+       {k: m2.get(k) for k in ("ok", "face_stable", "busy")})
+
+
+_GROUPS = (g0, g1, g2, g3, g4, g5, g6, g7, g8)
 
 
 def _run_groups() -> int: