@furongjun1999/dsh-memory 0.7.1 → 0.7.3

package/md_cg/test_auditview.py

@@ -0,0 +1,277 @@
+# -*- coding: utf-8 -*-
+"""test_auditview · L5 证据审计面只读组装器（路线 C）的行为守卫。
+
+多主体世界模型对齐 v0.1 §4 路线 C：cg(op="audit") 给节点 id 输出五面
+（现值/出处链/两存备择/盲区/退役史）；**纯读、零写路径改动**。
+运行：python -m md_cg.test_auditview
+"""
+from __future__ import annotations
+
+import os
+import tempfile
+import time
+
+from . import auditview, evolution, lifecycle, nodefile, tokens, trust
+from .mdcos import MdCGOS
+from .mcp_server import _cg_call
+from .writepipe import default_pipeline
+
+_ok = 0
+_fail = []
+
+
+def check(name, cond, detail=""):
+    global _ok
+    if cond:
+        _ok += 1
+        print("[ok] " + name)
+    else:
+        _fail.append(name)
+        print("[FAIL] %s  · %s" % (name, str(detail)[:240]))
+
+
+H = ("# 功能名：审计面守卫\n# 生效条件：测试环境\n# 子功能：无\n"
+     "# 执行：无\n# 验证方式：test\n# 不适用条件：无\n")
+H2 = ("# 功能名：审计面守卫\n# 生效条件：测试环境\n# 子功能：无\n"
+      "# 执行：无\n# 验证方式：test\n# 不适用条件：无\n")
+
+
+def main():
+    tmp = tempfile.mkdtemp(prefix="mdcg_av_test_")
+    cg = MdCGOS(os.path.join(tmp, "root"))
+    pipe = default_pipeline()
+
+    def W(nid, body, **kw):
+        a = {"op": "write", "node_id": nid, "content": H + body + "\n",
+             "layer": "knowledge", "content_kind": "text",
+             "verification_basis": "test"}
+        a.update(kw)
+        return pipe.execute(cg, a)
+
+    # ---- 1. 结构：五面在场 ----
+    W("av_base", "基准记录：集市采购。")
+    W("av_subject", "依据见 av_base 记载。上次说的那件事。",
+      check_strength="hoop")
+    out = _cg_call(cg, {"op": "audit", "node_id": "av_subject", "cap": 5})
+    check("T1a ok=True", out.get("ok") is True, out.get("error"))
+    for face in ("present", "sources", "alternatives", "blindspots", "history"):
+        check("T1b 面在场：%s" % face, isinstance(out.get(face), dict),
+              sorted(out.keys()))
+
+    # ---- 2. 现值面：A1/A2 字段 ----
+    p = out.get("present") or {}
+    check("T2a check_strength 透传（写链）", p.get("check_strength") == "hoop",
+          p.get("check_strength"))
+    check("T2b uncertain_refs 呈现", p.get("uncertain_refs") == ["上次说"],
+          p.get("uncertain_refs"))
+    check("T2c 生命态/验证态/时效在场",
+          p.get("lifecycle_state") == "active" and p.get("verification_state")
+          and p.get("validity"), p)
+
+    # ---- 3. 出处链：refers_to（正向）与 referenced_by（反查） ----
+    src = out.get("sources") or {}
+    rt = src.get("refers_to") or {}
+    check("T3a refers_to 含 av_base", any(
+        e.get("target") == "av_base" for e in (rt.get("items") or [])), rt)
+    rb = src.get("referenced_by") or {}
+    out_b = _cg_call(cg, {"op": "audit", "node_id": "av_base"})
+    rb_b = (out_b.get("sources") or {}).get("referenced_by") or {}
+    check("T3b 反查：av_base 的引用者含 av_subject", any(
+        it.get("from") == "av_subject" for it in (rb_b.get("items") or [])), rb_b)
+
+    # ---- 4. 两存/备择：同条件空间分歧 ⇒ verdict 非 ACCEPT 且可比节点在 ----
+    W("av_dup_a", "集市购物，周末进行。")
+    W("av_dup_b", "集市购物，改到工作日进行。")
+    out_d = _cg_call(cg, {"op": "audit", "node_id": "av_dup_b", "cap": 5})
+    alt = out_d.get("alternatives") or {}
+    check("T4a 备择面可比非零", (alt.get("comparable") or 0) >= 1, alt)
+    check("T4b 同槽分歧如实透出（verdict/missing 至少其一）",
+          alt.get("verdict") in ("DEFER", "REJECT", "ACCEPT") and
+          (alt.get("reason") is not None or alt.get("verdict") == "ACCEPT"),
+          {k: alt.get(k) for k in ("verdict", "reason")})
+
+    # ---- 5. 盲区面 ----
+    bs = out.get("blindspots") or {}
+    check("T5a 盲区面含幽灵标记与证据计数",
+          bs.get("uncertain_refs") == ["上次说"]
+          and bs.get("negative_evidence") == 0
+          and isinstance(bs.get("note"), str), bs)
+
+    # ---- 6. 退役史：状态迁移与验证迁移入史 ----
+    lifecycle.set_state(cg, "av_subject", "converged", reason="守卫用例")
+    trust.set_state(cg, "av_subject", "verified", reason="守卫用例",
+                    method="test", actor="guard")
+    out_h = _cg_call(cg, {"op": "audit", "node_id": "av_subject"})
+    hist = out_h.get("history") or {}
+    check("T6a state_history 记录在场", any(
+        it.get("to") == "converged" for it in (hist.get("state_history") or [])),
+        hist.get("state_history"))
+    check("T6b verification_history 记录在场", any(
+        it.get("to") == "verified"
+        for it in (hist.get("verification_history") or [])),
+        hist.get("verification_history"))
+    _ev = evolution.record(cg, node_id="av_subject", pattern="审计面守卫",
+                           missing="无", action="留痕", evidence="av_guard")
+    out_h2 = _cg_call(cg, {"op": "audit", "node_id": "av_subject"})
+    check("T6c evolution 台账纳入", bool(
+        ((out_h2.get("history") or {}).get("evolution") or [])),
+        (out_h2.get("history") or {}).get("evolution"))
+
+    # ---- 7. 错误面：类型错 / 不存在 / 空串 ----
+    e1 = _cg_call(cg, {"op": "audit", "node_id": 123})
+    check("T7a 类型错结构化", e1.get("error") == "node_id_not_str"
+          and e1.get("got_type") == "int", e1)
+    e2 = _cg_call(cg, {"op": "audit", "node_id": "av_no_such"})
+    check("T7b 不存在结构化", e2.get("error") == "node_not_found", e2)
+    e3 = _cg_call(cg, {"op": "audit", "node_id": "  "})
+    check("T7c 空串结构化", e3.get("error") == "node_id_not_str", e3)
+
+    # ---- 8. cap 截断如实 ----
+    # 目标 id 段长须 ≥3（linkref.ID_SHAPE；av_t0 段 "t0" 不合法会不建边）；
+    # 单节点一次引用 9 个目标（避免覆写触发 confirm 档出单）。
+    _refs = "、".join("av_tk%d" % i for i in range(9))
+    for i in range(9):
+        W("av_tk%d" % i, "尾目标 %d。" % i)
+    pipe.execute(cg, {"op": "write", "node_id": "av_hub",
+                      "content": H + "引用 %s。" % _refs + "\n",
+                      "layer": "knowledge", "content_kind": "text",
+                      "verification_basis": "test"})
+    out_c = _cg_call(cg, {"op": "audit", "node_id": "av_hub", "cap": 3})
+    rt2 = (out_c.get("sources") or {}).get("refers_to") or {}
+    check("T8a cap 截断（items=3）", len(rt2.get("items") or []) == 3, rt2)
+    check("T8b total/truncated 如实", (rt2.get("total") or 0) == 9
+          and rt2.get("truncated") is True, rt2)
+
+    # ---- 9. 纯读：调用前后**全库级**文件清单不变（复核 R2 升级口径：
+    # 原实现只比单文件，测不到 `_consistency.jsonl` 的隐式追加）。----
+    def _snapshot(root):
+        out = {}
+        for dp, _dns, fns in os.walk(root):
+            for fn in fns:
+                fp = os.path.join(dp, fn)
+                try:
+                    out[os.path.relpath(fp, root)] = (os.path.getsize(fp),
+                                                      open(fp, "rb").read())
+                except OSError:
+                    out[os.path.relpath(fp, root)] = None
+        return out
+
+    cg.flush()
+    snap0 = _snapshot(cg.root)
+    _cg_call(cg, {"op": "audit", "node_id": "av_subject"})
+    _cg_call(cg, {"op": "audit", "node_id": "av_base"})
+    snap1 = _snapshot(cg.root)
+    check("T9a 纯读（全库级）：审计调用不改任何文件",
+          snap0 == snap1,
+          sorted(set(snap0) ^ set(snap1)) or
+          [k for k in snap0 if snap0.get(k) != snap1.get(k)][:4])
+    # 直调面同款（auditview.build 本身也须零写）
+    snap1b = _snapshot(cg.root)
+    auditview.build(cg, "av_subject")
+    check("T9b 纯读（直调面）", snap1b == _snapshot(cg.root),
+          [k for k in snap1b if snap1b.get(k) != _snapshot(cg.root).get(k)][:4])
+
+    # ---- 10. 角色面：ops 表登记（fail-closed 缺省不给） ----
+    check("T10a ALL_OPS 含 audit", "audit" in tokens.ALL_OPS)
+    _verify_ops = tokens.ROLE_SPECS["verify"]["ops_allow"]
+    check("T10b verify 角色含 audit", "audit" in _verify_ops, _verify_ops)
+    check("T10c 非授权角色不含 audit（fail-closed 缺省）",
+          "audit" not in tokens.ROLE_SPECS["output"]["ops_allow"]
+          and "audit" not in tokens.ROLE_SPECS["guest"]["ops_allow"],
+          tokens.ROLE_SPECS["output"]["ops_allow"])
+
+    # ---- 11. auditview 直调面：node_not_found 与 cap 钳制 ----
+    direct = auditview.build(cg, "av_no_such")
+    check("T11a 直调不存在结构化", direct.get("error") == "node_not_found", direct)
+    out_cl = _cg_call(cg, {"op": "audit", "node_id": "av_subject", "cap": 999})
+    check("T11b cap 上钳 64", (out_cl.get("cap") or 0) == 64, out_cl.get("cap"))
+
+    # ---- 12. link_ledger 真 schema（复核 R1 修：原按 target/source 匹配恒读空）----
+    W("av_led_child", "派生用例。", derived_from=["av_base"], relation="derived_from")
+    out_l = _cg_call(cg, {"op": "audit", "node_id": "av_led_child"})
+    ll = (out_l.get("sources") or {}).get("link_ledger") or {}
+    check("T12 link_ledger 按 child/parent 呈现派生行",
+          (ll.get("total") or 0) >= 1 and any(
+              it.get("child") == "av_led_child" and it.get("parent") == "av_base"
+              for it in (ll.get("items") or [])), ll)
+
+    # ---- 13. 读隔离（复核 R3 修：反查须过 _readable，不可读节点不泄漏）----
+    _nodes = cg.index["nodes"]
+    _nodes["sec_iso_node"] = {"layer": "knowledge", "sensitivity": "secret",
+                              "edges": [{"target": "av_base",
+                                         "relation_type": "reference"}]}
+    _nodes["int_iso_node"] = {"layer": "knowledge", "sensitivity": "internal",
+                              "edges": [{"target": "av_base",
+                                         "relation_type": "reference"}]}
+    _orig_rd = getattr(cg, "_readable", None)
+    try:
+        cg._readable = lambda e: e.get("sensitivity") != "secret"
+        out_iso = auditview.build(cg, "av_base")
+        names = [it.get("from") for it in
+                 ((out_iso.get("sources") or {}).get("referenced_by") or {}).get("items", [])]
+        check("T13 读隔离：secret 引用者不出现在反查",
+              "sec_iso_node" not in names and "int_iso_node" in names, names)
+        # T13b（复验 R4）：link_ledger 的**行级**隔离——另一端不可见的行不出
+        _lp = os.path.join(cg.root, "_link.jsonl")
+        with open(_lp, "a", encoding="utf-8") as f:
+            f.write('{"schema": 1, "child": "sec_iso_node", "parent": "av_base",'
+                    ' "rel": "derived_from", "t": 1}\n')
+            f.write('{"schema": 1, "child": "int_iso_node", "parent": "av_base",'
+                    ' "rel": "derived_from", "t": 2}\n')
+        out_iso2 = auditview.build(cg, "av_base")
+        ll_names = [it.get("child") for it in
+                    ((out_iso2.get("sources") or {}).get("link_ledger") or {}).get("items", [])]
+        check("T13b link_ledger 行级隔离：不可见另一端不出行",
+              "sec_iso_node" not in ll_names and "int_iso_node" in ll_names,
+              ll_names)
+    finally:
+        if _orig_rd is None:
+            try:
+                del cg._readable
+            except AttributeError:
+                pass
+        else:
+            cg._readable = _orig_rd
+        _nodes.pop("sec_iso_node", None)
+        _nodes.pop("int_iso_node", None)
+
+    # ---- 14. cap 直调防御（复核 Y2 修：非数不裸抛，钳 [1,64]）----
+    try:
+        o_c1 = auditview.build(cg, "av_base", cap="abc")
+        check("T14a cap 非数回落缺省", o_c1.get("cap") == auditview.DEFAULT_CAP,
+              o_c1.get("cap"))
+    except TypeError as e:
+        check("T14a cap 非数回落缺省", False, "TypeError 冒泡：%s" % e)
+    check("T14b cap 负值钳 1", auditview.build(cg, "av_base", cap=-7).get("cap") == 1)
+    check("T14c cap 上钳 64", auditview.build(cg, "av_base", cap=999).get("cap") == 64)
+
+    # ---- 15. mdcg_remember 两分支透传（复核 Y3 修：此前两条落点无断言）----
+    from .mcp_server import _dispatch
+    o_d = _dispatch(cg, "mdcg_remember", {
+        "content": "# 功能名：直写透传守卫\n# 生效条件：测试\n# 子功能：无\n"
+                   "# 执行：无\n# 验证方式：test\n# 不适用条件：无\n",
+        "node_id": "mem_direct_wire", "layer": "knowledge",
+        "verification_basis": "test", "check_strength": "hoop"})
+    fm_d = (cg.get("mem_direct_wire") or {}).get("frontmatter") or {}
+    check("T15a mdcg_remember 直写分支透传", fm_d.get("check_strength") == "hoop",
+          (o_d.get("ok"), fm_d.get("check_strength")))
+    o_g = _dispatch(cg, "mdcg_remember", {
+        "content": "# 功能名：gated 透传守卫\n# 生效条件：测试\n# 子功能：无\n"
+                   "# 执行：无\n# 验证方式：test\n# 不适用条件：无\n",
+        "node_id": "mem_gated_wire", "layer": "contextual",
+        # "gated": True 必须有（复验 Y3：缺它则走直写分支、gated 分支零覆盖）。
+        "gated": True,
+        "verification_basis": "test", "consistency": False,
+        "check_strength": "smoking_gun"})
+    fm_g = (cg.get("mem_gated_wire") or {}).get("frontmatter") or {}
+    check("T15b mdcg_remember gated 分支透传",
+          fm_g.get("check_strength") == "smoking_gun",
+          (o_g.get("verdict") or o_g.get("ok"), fm_g.get("check_strength")))
+
+    print("\ntest_auditview: %d 通过 / %d 失败" % (_ok, len(_fail)))
+    if _fail:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()

package/md_cg/test_autonomy_modes.py

@@ -1584,8 +1584,9 @@ _SRC_MUTATIONS = (
      '                if False:', 3),
     # ⑭ SHIM 登记丢失（**常量型变异**，kind="attr"）——baseline 假包缺
     # autonomy_modes（补强一 的原形态：容器栈一 37/1 的那条红）。
+    # 锚点随 _SHIMS 文本演进同步（2026-10-05 A2：_SHIMS 尾部新增 ghostref）。
     ("SHIM 登记丢失（_SHIMS 去掉 autonomy_modes）", "attr", _tpc, "_SHIMS",
-     '"autonomy_modes")',
+     '"autonomy_modes", "ghostref")',
      'tuple(x for x in _SHIMS if x != "autonomy_modes")', 2),
     # ⑮ 执行桥不拍前像（批次③）——三字段的「执行时点」半支失效：before 空、
     # rollback 空，回滚句柄不存在、影响面缺失。

package/md_cg/test_boot_openblas_guard.py

@@ -0,0 +1,197 @@
+# -*- coding: utf-8 -*-
+"""守卫：md_cg MCP server 的**入口自保证 OpenBLAS 线程数**（2026-10-05 返修）
+
+病灶（本机取证，2026-10-05）：numpy（md_cg 可选依赖，经 whitebox_kb 系列模块
+加载）在**导入期**由 OpenBLAS 按线程数（默认 = 核数）申请每线程缓冲——32 核机
+实测单进程 ``import numpy`` 的全机提交内存增量 **0.73 GiB**。启动链上的代校验
+（``verify_delegations`` → 导入含 numpy 的目标模块）把这笔分配带到**服务应答
+之前**：机器提交内存吃紧、或**多进程同启**（并行测试套件 / 多会话并存）时，
+OpenBLAS 重试 10 次后放弃并 ``exit(1)``——进程在 initialize 应答前死亡，桥侧
+只见「握手失败 / 插件激活失败」（TS 套件实测失败用例的子进程 stderr 逐字为
+``OpenBLAS error: Memory allocation still failed after 10 retries``）。
+
+修法（本件守门）：``md_cg/mcp_server.py`` **模块级**（早于 main 的代校验，即
+numpy 的首个导入点之前）在未设/空白时置 ``OPENBLAS_NUM_THREADS=1``——实测单
+进程提交增量 0.73 → 0.013 GiB，12 个并发 ``import numpy`` 由 4~9/12 失败（两轮
+独立读数，随机器提交内存压力波动）转为 0/12（两轮）；单线程对现有数值面无已观测
+的性能意义（⚠ 未做基准实测，见 mcp_server.py 入口块注释）。
+
+断言（红基线 = 去掉该入口块；HEAD worktree 实测：G1/G3/G4/G6a/G6b 转红；
+G2 两侧皆绿＝独立于入口块的口径锚；G5 为压力依赖，本轮未触发红）：
+  G1 缺省：子进程 import md_cg.mcp_server 后 env 值 = "1"（进程自保证）
+  G2 显式设值优先：预置 "4" → 保持 "4"（不覆盖部署方调优）
+  G3 空白视为未设：预置 "   " → 归一 "1"（仓库口径：空白视为未设置）
+  G4 时序：import 完成后 numpy 尚未加载（模块级早于 main 的代校验）；随后同
+     进程 import numpy 成功——自保证早于首个 numpy 导入生效
+  G5 实弹并发：6 个并发子进程各走「import mcp_server + verify_delegations」
+     全部成功（本套件红案的收敛形态：并行下子进程启动不得死于 OpenBLAS）
+  G6 站点锚（AST）：入口块是**模块体顶层**的赋值语句且行号早于该文件首个模块级
+     `def`（须早于一切模块级 I/O 的既有锚口径，与 test_utf8_boot_guard 的
+     ANCHOR ⑤ 同款；防未来把保证挪进函数/挪到文件尾）
+
+定点变异自证（本守卫做不了运行期反证——保证是 import 期一次性副作用，故按
+仓内惯例在**临时物化副本**上做，绝不改工作树；本机实测读数记录于此）：
+  取 md_cg 树副本、删掉入口块后跑 G1/G4/G5 同款子进程：
+    G1 → env 值为 None（红）；G5 → 6 并发在提交内存吃紧时出现 OpenBLAS 失败
+    （同机同压力量级实测：不导入 mcp_server 的同形并发 12 个默认 9/12 败）。
+  本守卫自带 G1~G6 判据不含变异装置（保持套件轻量）；上表为一次性变异取证。
+
+运行：python -X utf8 -m md_cg.test_boot_openblas_guard
+"""
+from __future__ import annotations
+
+import ast
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+
+REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+PASS = FAIL = 0
+FAILS = []
+
+
+def check(name, cond, detail=""):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  OK   {name}")
+    else:
+        FAIL += 1
+        FAILS.append(name)
+        print(f"  FAIL {name}  {detail}")
+
+
+# 生效条件：总是返回一份「清掉 OPENBLAS_NUM_THREADS、锚定本仓 PYTHONPATH、隔离
+# 记忆根到 tmp 之下」的子进程 env（extra 最后覆盖，供 G2/G3 预置取值）。
+def _child_env(tmp, extra=None):
+    env = dict(os.environ)
+    env.pop("OPENBLAS_NUM_THREADS", None)
+    env["PYTHONPATH"] = REPO
+    env["PYTHONUTF8"] = "1"
+    env["PYTHONIOENCODING"] = "utf-8"
+    # 防御性隔离：本守卫只 import 模块与跑代校验（纯读），但仍把记忆根钉在
+    # 临时面——绝不因未来代码路径变化回落到真实 ~/.mdcg。
+    env.setdefault("MDCG_ROOT", os.path.join(tmp, "cgroot"))
+    env.setdefault("MDCG_AUX_ROOT", os.path.join(tmp, "auxroot"))
+    env.setdefault("MDCG_STATE_ROOT", os.path.join(tmp, "state"))
+    env.setdefault("MDCG_DATA_ROOT", os.path.join(tmp, "data"))
+    if extra:
+        env.update(extra)
+    return env
+
+
+# 生效条件：code 在子解释器中执行（cwd=仓根、argv 列表、显式 UTF-8），返回
+# (returncode, stdout 去尾空白, stderr 末 400 字符)。
+def _run_child(code, env, timeout=180):
+    r = subprocess.run([sys.executable, "-c", code], cwd=REPO, env=env,
+                       capture_output=True, text=True, encoding="utf-8",
+                       errors="replace", timeout=timeout, shell=False)
+    return r.returncode, (r.stdout or "").strip(), (r.stderr or "")[-400:]
+
+
+_G1_CODE = "import os\nimport md_cg.mcp_server\nprint(os.environ.get('OPENBLAS_NUM_THREADS'))\n"
+
+_G4_CODE = ("import os\nimport sys\nimport md_cg.mcp_server\n"
+            "pre = 'numpy' in sys.modules\n"
+            "import numpy\n"
+            "print(os.environ.get('OPENBLAS_NUM_THREADS'), pre)\n")
+
+# 收敛形态：与 TS 套件受害路径同构——「服务启动期：导入模块 → 代校验导入 numpy」。
+_G5_CODE = ("import md_cg.mcp_server\n"
+            "from md_cg import generation\n"
+            "r = generation.verify_delegations()\n"
+            "print('OK', r['ok'])\n")
+
+
+# 生效条件：能读到被守卫源码与 G6 需要的两处行号时返回 (module_body 首个
+# def 行号, 入口块行号)；入口块（模块体顶层的 os.environ["OPENBLAS_NUM_THREADS"]
+# 赋值所在 If）不存在时返回 (def 行号, None)。
+def _entry_block_lines():
+    ap = os.path.join(REPO, "md_cg", "mcp_server.py")
+    with open(ap, encoding="utf-8") as fh:
+        tree = ast.parse(fh.read(), filename="md_cg/mcp_server.py")
+    defs = [n.lineno for n in tree.body
+            if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))]
+    first_def = min(defs) if defs else None
+    block = None
+    for node in tree.body:                          # 只认模块体顶层（函数内不算）
+        if not isinstance(node, ast.If):
+            continue
+        for sub in node.body:
+            if not (isinstance(sub, ast.Assign) and sub.targets):
+                continue
+            tgt = sub.targets[0]
+            if (isinstance(tgt, ast.Subscript)
+                    and isinstance(tgt.value, ast.Attribute)
+                    and tgt.value.attr == "environ"
+                    and isinstance(tgt.slice, ast.Constant)
+                    and tgt.slice.value == "OPENBLAS_NUM_THREADS"):
+                block = node.lineno
+    return first_def, block
+
+
+def main():
+    tmp = tempfile.mkdtemp(prefix="mdcg_openblas_guard_")
+    try:
+        print("== G1~G3 env 口径（进程自保证 / 显式优先 / 空白归一）==")
+        rc, out, err = _run_child(_G1_CODE, _child_env(tmp))
+        check("G1 缺省：import md_cg.mcp_server 后 OPENBLAS_NUM_THREADS=1",
+              rc == 0 and out == "1", f"rc={rc} out={out!r} err={err!r}")
+
+        rc, out, err = _run_child(_G1_CODE, _child_env(
+            tmp, {"OPENBLAS_NUM_THREADS": "4"}))
+        check("G2 显式设值优先：预置 4 → 保持 4（不覆盖部署方调优）",
+              rc == 0 and out == "4", f"rc={rc} out={out!r} err={err!r}")
+
+        rc, out, err = _run_child(_G1_CODE, _child_env(
+            tmp, {"OPENBLAS_NUM_THREADS": "   "}))
+        check("G3 空白视为未设：预置空白 → 归一为 1",
+              rc == 0 and out == "1", f"rc={rc} out={out!r} err={err!r}")
+
+        print("== G4 时序：自保证早于首个 numpy 导入，且 numpy 随后可导入 ==")
+        rc, out, err = _run_child(_G4_CODE, _child_env(tmp))
+        check("G4 import mcp_server 后 numpy 未加载；numpy 导入成功且值=1",
+              rc == 0 and out == "1 False", f"rc={rc} out={out!r} err={err!r}")
+
+        print("== G5 实弹并发：6 个「启动期（import + 代校验）」子进程全部成功 ==")
+        env5 = _child_env(tmp)
+        procs = [subprocess.Popen([sys.executable, "-c", _G5_CODE], cwd=REPO,
+                                  env=env5, stdout=subprocess.PIPE,
+                                  stderr=subprocess.PIPE)
+                 for _ in range(6)]
+        bad = []
+        for i, p in enumerate(procs):
+            o, e = p.communicate(timeout=300)
+            o = (o or b"").decode("utf-8", "replace")
+            e = (e or b"").decode("utf-8", "replace")
+            if p.returncode != 0 or "OK True" not in o:
+                bad.append("child%d rc=%s out=%r err=%r" % (i, p.returncode,
+                                                            o[-120:], e[-320:]))
+        check("G5 6 个并发启动期子进程全部成功（无 OpenBLAS 分配失败）",
+              not bad, "；".join(bad)[:600])
+
+        print("== G6 站点锚（AST）：入口块在模块体顶层且早于首个模块级 def ==")
+        first_def, block = _entry_block_lines()
+        check("G6a 入口块存在且为模块体顶层语句（函数内不算）",
+              block is not None,
+              "md_cg/mcp_server.py 模块体未见 os.environ['OPENBLAS_NUM_THREADS'] 赋值")
+        check("G6b 入口块早于首个模块级 def（不晚于一切模块级 I/O 的既有锚口径）",
+              block is not None and first_def is not None and block < first_def,
+              f"入口块行={block} 首个 def 行={first_def}")
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+    print("\n" + "=" * 64)
+    print(f"PASS={PASS}  FAIL={FAIL}")
+    if FAILS:
+        print("失败项：" + "；".join(FAILS))
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8")
+    sys.exit(main())

package/md_cg/test_ccg_form_parity.py

@@ -15,13 +15,18 @@
 （冒号可有可无），`mdcos._ccg_field`、`ccgc._has_ccg_line`、
 `consolidate._has_ccg_line`、`tasks._field_line` 一律委托该单点。
 
-本套的六组断言：
+本套的七组断言：
  ① 两形态都判齐（形态不改变「齐不齐」）
  ② 缺要素仍判不全（放宽的是标点，不是要求——判别力自证，两种形态各测）
  ③ 写入闸门与检索面**结论一致**（读真源 data/policy.json 复算，直接钉住分叉）
  ④ 取值面同源：无冒号的「值」= 标题后首个非空非标题行
  ⑤ 四个副本函数与单点结论一致（防未来再长出第五、第六套口径）
  ⑥ 写读闭环：无冒号节点经 upsert 后取得到新值（不出现「写进去读不出」）
+ ⑦ 「不适用条件」两函数（`has_non_applicable` / `positive_body`）× 两形态同权：
+   无冒号形态同样算「已声明」（旧码只认冒号写法），且 positive_body 连**值行**
+   一并剥净（旧码只剥标题行 ⇒ 同一条正文写不写冒号会给出两种召回面）；
+   并含**红基线自证**——`git show HEAD:md_cg/nodefile.py` 物化后跑同一批断言，
+   HEAD 版对无冒号形态必须失手（否则本节断言空转；本改动入库后该腿 SKIP）。
 """
 from __future__ import annotations
 
@@ -29,12 +34,15 @@ import io
 import json
 import os
 import re
+import subprocess
 import sys
+import types
 
-from . import ccgc, consolidate, nodefile, tasks
+from . import ccgc, consistency, consolidate, nodefile, tasks
+from .mdcg import MdCG
 from .mdcos import _ccg_field
 
-PASS = FAIL = 0
+PASS = FAIL = SKIPPED = 0
 FAILS = []
 
 
@@ -49,6 +57,34 @@ def ok(cond, label):
         print("  [FAIL] %s" % label)
 
 
+def skip(label, why):
+    """不适用/前提缺失的腿：只报不判——不计入 FAIL（如红基线随 HEAD 前移而不可复现）。"""
+    global SKIPPED
+    SKIPPED += 1
+    print("  [SKIP] %s（%s）" % (label, why))
+
+
+def _load_head_nodefile():
+    """物化 HEAD 版 `md_cg/nodefile.py` 并 exec 成模块（红基线自证用）。
+
+    nodefile 只依赖 stdlib、顶层无副作用（无包内相对导入、无模块级 I/O），故
+    HEAD 字节可独立 exec 进一个空模块命名空间。取不到（无 git / 无提交 / 路径
+    不在仓内）时返回 (None, 原因)——由调用方 SKIP，不静默当成功。
+    """
+    root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    r = subprocess.run(["git", "-c", "core.quotepath=false", "show",
+                        "HEAD:md_cg/nodefile.py"],
+                       cwd=root, capture_output=True, text=True,
+                       encoding="utf-8", errors="replace")
+    if r.returncode != 0 or not (r.stdout or "").strip():
+        return None, ("git show 失败 rc=%s %s"
+                      % (r.returncode, (r.stderr or "").strip()[:200]))
+    mod = types.ModuleType("_head_nodefile_legacy")
+    mod.__file__ = os.path.join(root, "md_cg", "nodefile.py")
+    exec(compile(r.stdout, "HEAD:md_cg/nodefile.py", "exec"), mod.__dict__)
+    return mod, ""
+
+
 MARKS = ("功能名", "生效条件", "子功能", "执行", "验证方式", "不适用条件")
 
 # ① 带冒号形态（既有惯例形态）
@@ -177,8 +213,63 @@ def main() -> int:
         except ValueError:
             ok(True, "⑥%s：值含换行被拒（N208 fail-closed）" % enc)
 
+    print("== ⑦ 「不适用条件」两函数 × 两形态同权（A3：N238 同族残面收口）==")
+    # 被测：`has_non_applicable`（判「有没有声明」）与 `positive_body`（剥声明段后再作召回键）。
+    # 判据全部在单点（`ccg_mark_present` / `_ccg_heading_rest` / `ccg_field_value`，①-⑤ 已验收）
+    # ——两函数都不得自带一套「冒号可有可无」的本地口径。
+    NEG = "不适用条件"
+    COLON_NEG = "# 功能名：p\n# 不适用条件：ZXQ7\n正文第一行\n"
+    BARE_NEG = "# 功能名：p\n# 不适用条件\nZXQ7\n正文第一行\n"
+    for name, body in (("带冒号", COLON), ("无冒号", NONCOLON), ("混形态", MIXED)):
+        ok(nodefile.has_non_applicable(body) == nodefile.ccg_mark_present(body, NEG),
+           "⑦%s：has_non_applicable 与单点同判（%s）"
+           % (name, nodefile.has_non_applicable(body)))
+    ok(nodefile.has_non_applicable(BARE_NEG) is True,
+       "⑦无冒号形态：通体判 True（旧码 False——真声明被判成没声明）")
+    ok(nodefile.has_non_applicable(COLON_NEG) is True
+       and nodefile.has_non_applicable("") is False
+       and nodefile.has_non_applicable("正文提到不适用条件，但不是 CCG 行\n") is False,
+       "⑦带冒号 True / 空正文 False / 行内提及 False（放宽的是标点，不是判据）")
+
+    pb_bare = nodefile.positive_body(BARE_NEG)
+    pb_colon = nodefile.positive_body(COLON_NEG)
+    ok(pb_bare == pb_colon,
+       "⑦positive_body 两形态剥除结论一致（无冒号得到 %r）" % pb_bare)
+    ok("ZXQ7" not in pb_bare and "正文第一行" in pb_bare,
+       "⑦无冒号形态：值行一并剥净、正文保留（旧码残留值行 ZXQ7）")
+    ok(nodefile.positive_body("# 不适用条件\n# 执行：x\n后文\n") == "# 执行：x\n后文\n",
+       "⑦裸标题后紧跟另一标题：不吞下一要素（取值口径同 ccg_field_value）")
+    plain_line = "正文提到不适用条件这个词，但不是 CCG 行。\n"
+    ok(nodefile.positive_body(plain_line) == plain_line,
+       "⑦普通句子不误伤（只剥 CCG 行）")
+    only_neg = "# 不适用条件\nZXQ7\n正文第一行\n"
+    ok(consistency._body_text(only_neg) == nodefile.positive_body(only_neg),
+       "⑦只声明该要素时：positive_body 与 consistency._body_text 同口径（同一剥除算法单点）")
+    # 消费点用中文反例词面（不做大小写归一——`_like` 只小写 body/tags，
+    # 拿大写词面测会因边被消而空转，测不出「值行残留 ⇒ 反例被召回」）
+    BARE_NEG_CN = "# 功能名：p\n# 不适用条件\n不得把甲当作乙\n正文第一行\n"
+    ok(MdCG._like(BARE_NEG_CN, {}, ["不得把甲当作乙"]) is False,
+       "⑦消费点 _like：无冒号形态的反例词不作召回键（旧码残留值行 ⇒ 会被召回）")
+    ok(MdCG._like(BARE_NEG_CN, {}, ["正文第一行"]) is True,
+       "⑦消费点 _like：正条件行照常命中（判别力未削弱）")
+
+    print("-- ⑦红基线自证：HEAD 版 nodefile 对无冒号形态必须失手 --")
+    head, why = _load_head_nodefile()
+    if head is None:
+        skip("⑦红基线自证", "取不到 HEAD 版：%s" % why)
+    else:
+        h_present = head.has_non_applicable(BARE_NEG)
+        h_leak = "ZXQ7" in head.positive_body(BARE_NEG)
+        if h_present is True and not h_leak:
+            skip("⑦红基线自证",
+                 "HEAD 版已含修复（本改动已入库）——红基线只在其提交前可复现")
+        else:
+            ok(h_present is False and h_leak,
+               "⑦红基线可复现：HEAD 版判 has_non_applicable=%s、positive_body 残留值行=%s"
+               % (h_present, h_leak))
+
     print()
-    print("ccg_form_parity: PASS=%d FAIL=%d" % (PASS, FAIL))
+    print("ccg_form_parity: PASS=%d FAIL=%d SKIP=%d" % (PASS, FAIL, SKIPPED))
     if FAILS:
         print("FAILS: " + "; ".join(FAILS))
     return 1 if FAIL else 0

package/md_cg/test_cons200_scan_selection.py

@@ -328,10 +328,12 @@ class _CountGet:
     def __getattr__(self, k):
         return getattr(self.__dict__["_cg"], k)
 
-    def get(self, nid):
+    def get(self, nid, probe=True):
+        # N276：get 增可选 probe 形参（批内单探针）；夹具同步接口并原样透传
+        # ——计数语义不变（每次 get 仍计一次，不论探针与否），判据一字未动。
         self.__dict__["gets"] += 1
         self.__dict__["ids"].append(nid)
-        return self.__dict__["_cg"].get(nid)
+        return self.__dict__["_cg"].get(nid, probe=probe)
 
 
 # ---------------------------------------------------------------- G1 选面