@furongjun1999/dsh-memory 0.4.6 → 0.4.8

package/md_cg/test_ccg_perturb.py

@@ -0,0 +1,184 @@
+# -*- coding: utf-8 -*-
+"""条件扰动反事实实验（P-T-42/43 · 理论仓 §15 命题的可执行化）。
+
+理论命题（docs/theory/智能的公理化基石.md §15 + 附录二可证伪标准）：
+  「如果保持候选能力不变，只改变条件词，路由归属按条件发生变化，
+    那么路由控制因素就是条件，而不是单纯的语义相似度。」
+  可证伪口径：在保持候选能力不变、仅改变条件词的实验中，
+  路由结果不按条件变化 → 命题被推翻。
+
+本测试把该命题落为确定性反事实对照（tempdir，可复现）：
+  ① 结果变：同一节点，条件词互换 → judge 四态翻转（ACCEPT↔REJECT/DEFER），3/3 组
+  ② 路由变：两节点正文逐字相同（除条件行）、仅条件空间域词不同 → bucket 不同，
+     且镜像对称（互换构造后桶恰好互换）
+  ③ 计划变：检索路线（T0/T1 桶路 ↔ T2/T3 全局路）与 top1 归属随条件词切换；
+     无路由对照下两候选得分完全相等——「分数相同、归属不同」即路由控制因素
+     =条件的直接证据（相似度无法区分它们）
+  ④ 混合条件 BLINDSPOT：条件声明不完整（CCG 要素残缺）→ BLINDSPOT（停止猜测）；
+     如实边界：要素齐全但条件行混域词面 → 非 BLINDSPOT（当前判定序无矛盾检测）
+
+运行：python -m md_cg.test_ccg_perturb
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import tempfile
+
+from .mdcg import (STATE_ACCEPT, STATE_BLINDSPOT, STATE_DEFER, STATE_REJECT,
+                   MdCG, TIER_BUCKET_LIKE, TIER_BUCKET_SCAN,
+                   TIER_GLOBAL_LIKE, TIER_GLOBAL_SCAN)
+from .nodefile import condition_space_text
+
+PASS = FAIL = 0
+FAILS = []
+
+# 3 组条件域对（3/3 切换口径）：域词 ≥2 字（_cond_terms 滤 len<2）
+PAIRS = [("电路", "光学"), ("离线", "在线"), ("急救", "保健")]
+
+
+def ok(cond, label):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+    else:
+        FAIL += 1
+        FAILS.append(label)
+        print(f"  FAIL {label}")
+
+
+def node_body(domain: str, other: str, *, mix: bool = False,
+              drop_exec: bool = False) -> str:
+    """CCG 六要素正文。除条件两行外逐字相同（能力不变口径）：
+    生效条件由 condition_space_text 四槽合成（唯一入口，不手写冒充），
+    域词同时落在观测位置与约束槽，供 judge 正条件词面确认。"""
+    cs = {"observation_position": f"{domain}实验台",
+          "time_window": [0.0, 9999999999.0],
+          "observation_tool": "规程走查",
+          "existence_constraint": f"{domain}域，台面设备"}
+    eff = condition_space_text(cs)
+    assert eff, "四槽不全不构成生效条件（fail-closed）"
+    cond_line = f"# 生效条件：{eff}"
+    if mix:  # 混合域词面（要素齐全，用于④边界断言）
+        cond_line += f"与{other}混合域"
+    lines = [f"# 功能名：域路由实验规程\n\n",
+             f"本规程在声明条件域内执行标准检查流程，输出结论与依据。\n\n",
+             cond_line + "\n\n",
+             f"# 子功能：条件识别；规程执行；结论输出\n\n",
+             f"# 执行：确认条件域 → 执行规程 → 输出结论\n\n",
+             f"# 验证方式：规程执行结果落在声明条件域内即通过（measurement）\n\n",
+             f"# 不适用条件：{other}\n"]
+    if drop_exec:
+        lines = [l for l in lines if not l.startswith("# 执行：")]
+    return "".join(lines)
+
+
+def strip_cond_lines(content: str) -> str:
+    """剥条件两行——「能力不变」的对照口径。"""
+    return "\n".join(l for l in content.splitlines()
+                     if not (l.startswith("# 生效条件：")
+                             or l.startswith("# 不适用条件：")))
+
+
+def _node(domain: str, other: str, **kw) -> dict:
+    """judge 单元测输入：fm 显式负条件（不依赖盘上解析形态）。"""
+    return {"frontmatter": {"verification_basis": "measurement",
+                            "non_applicable_conditions": [other]},
+            "content": node_body(domain, other, **kw)}
+
+
+def run(verbose: bool = False):
+    global PASS, FAIL
+    # ---------- ① 结果变：条件词互换 → judge 四态翻转（3/3） ----------
+    for x, y in PAIRS:
+        jx = MdCG.judge_qualification(_node(x, y), f"问{x}域的规程", None)
+        jy = MdCG.judge_qualification(_node(x, y), f"问{y}域的规程", None)
+        ok(jx["state"] == STATE_ACCEPT and "生效条件已确认" in jx["reason"],
+           f"①[{x}/{y}] 本域情境 → ACCEPT（reason 记录命中）")
+        ok(jy["state"] == STATE_REJECT,
+           f"①[{x}/{y}] 反域情境 → REJECT（负条件命中，翻转①结果变）")
+        # 镜像节点对称：条件词互换后判定恰好互换
+        mjx = MdCG.judge_qualification(_node(y, x), f"问{x}域的规程", None)
+        mjy = MdCG.judge_qualification(_node(y, x), f"问{y}域的规程", None)
+        ok(mjx["state"] == STATE_REJECT and mjy["state"] == STATE_ACCEPT,
+           f"①[{x}/{y}] 镜像节点判定对称（双向反事实）")
+    # 无验证基底 → 反域下 DEFER 而非 REJECT 的次序确认（负条件优先于基底检查）
+    naker = {"frontmatter": {"non_applicable_conditions": ["光学"]},
+             "content": node_body("电路", "光学")}
+    j = MdCG.judge_qualification(naker, "问光学域的规程", None)
+    ok(j["state"] == STATE_REJECT, "①负条件 REJECT 先于验证基底 DEFER（判定序）")
+
+    # ---------- ②③ 写入库 + 路由变 + 计划变（链路） ----------
+    root = tempfile.mkdtemp(prefix="mdcg_ccg_perturb_")
+    try:
+        cg = MdCG(root)
+        buckets = {}
+        for i, (x, y) in enumerate(PAIRS):
+            for side, (dom, oth) in ((f"{i}a", (x, y)), (f"{i}b", (y, x))):
+                nid = f"perturb_{side}_{dom}"
+                cg.add(nid, node_body(dom, oth), layer="knowledge",
+                       tags=[f"domain:{dom}"], condition_space=None,
+                       verification_basis="measurement")
+                e = cg.index["nodes"].get(nid) or {}
+                buckets[nid] = e.get("bucket")
+        # ② 路由变：同能力（剥条件行后逐字相同）、不同条件域 → 不同桶
+        for i, (x, y) in enumerate(PAIRS):
+            a, b = f"perturb_{i}a_{x}", f"perturb_{i}b_{y}"
+            ca = strip_cond_lines(cg.get(a)["content"])
+            cb = strip_cond_lines(cg.get(b)["content"])
+            ok(ca == cb, f"②[{x}/{y}] 两节点剥条件行后正文逐字相同（能力不变）")
+            ok(buckets[a] and buckets[b] and buckets[a] != buckets[b],
+               f"②[{x}/{y}] 条件域词不同 → 路由桶不同（路由归属按条件变化）")
+        # ③ 计划变：检索路线与 top1 归属随条件词切换
+        # （context 带 tags 定路由桶 + scene 域词面供正条件确认——两者同属情境）
+        for i, (x, y) in enumerate(PAIRS):
+            a, b = f"perturb_{i}a_{x}", f"perturb_{i}b_{y}"
+            res, meta = cg.search("问实验规程", k=5, record=False,
+                                  context={"tags": [f"domain:{x}"],
+                                           "scene": f"{x}域情境检查"})
+            ok(meta["tier"] in (TIER_BUCKET_LIKE, TIER_BUCKET_SCAN),
+               f"③[{x}/{y}] 条件路由开启 → T0/T1 桶路（检索路线随条件变）")
+            ok(bool(res) and res[0][0]["id"] == a,
+               f"③[{x}/{y}] {x} 情境 → top1={a}")
+            ok(res and res[0][2]["state"] == STATE_ACCEPT,
+               f"③[{x}/{y}] top1 资格 ACCEPT（条件已确认）")
+            res2, meta2 = cg.search("问实验规程", k=5, record=False,
+                                    context={"tags": [f"domain:{y}"],
+                                             "scene": f"{y}域情境检查"})
+            ok(bool(res2) and res2[0][0]["id"] == b,
+               f"③[{x}/{y}] {y} 情境 → top1={b}（归属随条件切换）")
+            # 无路由对照：context=None → 全局路；同文两候选得分完全相等
+            res3, meta3 = cg.search("问实验规程", k=8, record=False, context=None)
+            ok(meta3["tier"] in (TIER_GLOBAL_LIKE, TIER_GLOBAL_SCAN),
+               f"③[{x}/{y}] 无情境 → T2/T3 全局路（路由关闭对照）")
+            sc = {r[0]["id"]: r[1] for r in res3}
+            ok(a in sc and b in sc and abs(sc[a] - sc[b]) < 1e-9,
+               f"③[{x}/{y}] 无路由时两候选得分相等——"
+               f"相似度无法区分，归属由条件决定（命题直接证据）")
+        # ④ 混合条件 BLINDSPOT
+        j = MdCG.judge_qualification(
+            _node("电路", "光学", drop_exec=True), "问电路域的规程", None)
+        ok(j["state"] == STATE_BLINDSPOT and "CCG 要素不全" in j["reason"],
+           "④条件声明不完整（缺执行要素）→ BLINDSPOT 停止猜测")
+        j = MdCG.judge_qualification(
+            _node("电路", "光学", mix=True), "问电路域的规程", None)
+        ok(j["state"] == STATE_ACCEPT,
+           "④边界（如实）：要素齐全+混域词面 → 非 BLINDSPOT（判定序无矛盾检测）")
+        cg.close()
+    finally:
+        shutil.rmtree(root, ignore_errors=True)
+
+    if verbose or FAIL:
+        print(f"ccg_perturb: {PASS} passed, {FAIL} failed")
+        for f in FAILS:
+            print(f"  - {f}")
+    return FAIL == 0
+
+
+def main():
+    okall = run(verbose=True)
+    raise SystemExit(0 if okall else 1)
+
+
+if __name__ == "__main__":
+    main()

package/md_cg/test_ccgc.py

@@ -0,0 +1,423 @@
+# -*- coding: utf-8 -*-
+"""ccgc 验收：对话记录 → CCG 六要素编译器（V1-V20）。
+
+运行：python -m md_cg.test_ccgc
+
+三条判据在实现层为何是**机械可判定**的（不依赖自觉）：
+  ① 「LLM 不得自己验证自己」——候选结构里没有签章字段，且 attest 机械比对
+     `verifier != compiled_by`（E041）；link 再挡一次（双闸）。
+  ② 「幻觉」——名实门 E010/E011：每个写入值必须是源文本字面子串，零灰区。
+  ③ 「缺参数」——是编译错误（E001-E004）而非 DEFER，`success = (errors == [])`。
+
+V16-V20 覆盖**跨调用形态**（三次独立 MCP 调用传不动对象，只能落盘）：
+  候选与签章绑定在 `_ccgc_pending/`（hash 防篡改）+ 复核通道三态 + 蜂巢契约
+  端到端（假执行器模拟 serve，无网络无密钥也能确定性验收「通道与签章」）。
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import sys
+import tempfile
+import threading
+import time
+
+from . import audit, backfill, ccgc, nodefile, units
+from .mdcos import MdCGOS
+
+PASS = FAIL = 0
+FAILS = []
+
+DIALOG = ("文件摄取分派：按扩展名把文件路由到对应摄取器"
+          "。该方法使用扩展名映射表进行路由"
+          "。此功能在本地文件系统中生效"
+          "。仅对本地可读文件生效"
+          "。2026-09-16"
+          "。通过回放测试验证"
+          "。二进制文件不适用")
+
+SLOTS = {
+    "observation_position": {"value": "此功能在本地文件系统中生效"},
+    "observation_tool": {"value": "该方法使用扩展名映射表进行路由"},
+    "time_window": {"value": [0.0, 9999999999.0]},
+    "existence_constraint": {"value": "仅对本地可读文件生效"},
+}
+
+MARKS = {
+    "功能名": {"value": "文件摄取分派：按扩展名把文件路由到对应摄取器"},
+    "子功能": {"value": "按扩展名把文件路由到对应摄取器"},
+    "执行": {"value": "使用扩展名映射表进行路由"},
+    "验证方式": {"value": "回放测试", "basis": "test"},
+    "不适用条件": {"value": "二进制文件不适用"},
+}
+
+
+def ok(cond, label):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+    else:
+        FAIL += 1
+        FAILS.append(label)
+        print("  FAIL " + label)
+
+
+def _has(errs, code):
+    return any(str(e).startswith(code) for e in (errs or []))
+
+
+def _seed(root):
+    cg = MdCGOS(root)
+    cg.add("tgt", "# 功能名：待编译节点\n\n占位正文。\n", layer="knowledge")
+    cg.flush()
+    cg.rebuild_index()
+    return cg
+
+
+def _fake_serve(jobs, stop, seen):
+    """假蜂巢执行器：读 spec.json 写 result.json（契约与 hive 的 LLM 委托型一致）。
+
+    用线程模拟 serve 侧的单元执行，使**复核通道与签章搬运**在无网络无密钥下
+    可确定性验收——被测的是通道契约，不是模型质量。seen 记录 spec 形态供断言。
+    """
+    while not stop.is_set():
+        try:
+            names = sorted(os.listdir(jobs))
+        except OSError:
+            names = []
+        for jid in names:
+            d = os.path.join(jobs, jid)
+            sp = os.path.join(d, units.SPEC_FILE)
+            rp = os.path.join(d, units.RESULT_FILE)
+            if not jid.startswith("h") or not os.path.isfile(sp) or os.path.exists(rp):
+                continue
+            try:
+                with open(sp, encoding="utf-8") as f:
+                    spec = json.load(f)
+            except (OSError, ValueError):
+                continue
+            prompt = str(spec.get("user_prompt") or spec.get("prompt") or "")
+            seen.update({"role": spec.get("role"), "model": spec.get("model"),
+                         "prompt_len": len(prompt),
+                         "prompt_has_dialog": "文件摄取分派" in prompt})
+            payload = {"verdict": seen.get("verdict") or "accept",
+                       "reason": "假单元复核：候选与对话原文一致",
+                       "slot_corrections": {}}
+            try:
+                with open(rp, "w", encoding="utf-8") as f:
+                    json.dump({"ok": True, "model": spec.get("model"),
+                               "content": json.dumps(payload, ensure_ascii=False)},
+                              f, ensure_ascii=False)
+            except OSError:
+                continue
+        time.sleep(0.05)
+
+
+def _import_mcp():
+    """延迟导入工具面（避免测试顶部把 server 依赖一并拉起）。"""
+    try:
+        from . import mcp_server
+        return mcp_server
+    except Exception:                                       # noqa: BLE001
+        return None
+
+
+def main():
+    global PASS, FAIL
+    tmp = tempfile.mkdtemp(prefix="mdcg_ccgc_")
+    try:
+        root = os.path.join(tmp, "root")
+        os.makedirs(root, exist_ok=True)
+        cg = _seed(root)
+
+        # ---------- V1 缺参即编译错误（裁定 B） ----------
+        r = ccgc.compile_dialog("", "tgt", "agent:a1")
+        ok((not r.success) and _has(r.errors, "E001"), "V1a 缺 dialog → E001")
+        r = ccgc.compile_dialog(DIALOG, "", "agent:a1")
+        ok((not r.success) and _has(r.errors, "E002"), "V1b 缺 node_id → E002")
+        r = ccgc.compile_dialog(DIALOG, "tgt", "")
+        ok((not r.success) and _has(r.errors, "E003"), "V1c 缺 actor → E003")
+        r = ccgc.compile_dialog(DIALOG, "nope", "agent:a1", cg=cg)
+        ok((not r.success) and _has(r.errors, "E002"), "V1d 节点不存在 → E002")
+        ok(bool(r.verdict) and r.verdict.get("authority") == "VERIFICATION_UNIT",
+           "V1e 终裁 authority=VERIFICATION_UNIT")
+
+        # ---------- V2 名实门：幻觉在编译期被机械检出 ----------
+        bad_slots = dict(SLOTS)
+        bad_slots["observation_tool"] = {"value": "该方法使用神经网络进行路由",
+                                         "span": "该方法使用神经网络进行路由"}
+        r_bad = ccgc.compile_dialog(DIALOG, "tgt", "agent:a1",
+                                    slots=bad_slots, marks=MARKS, cg=cg)
+        ok((not r_bad.success) and _has(r_bad.errors, "E011"), "V2a 捏造值 → E011")
+        ok(len(r_bad.ungrounded) >= 1, "V2b 未过门项进入 ungrounded 台账")
+
+        bad2 = dict(SLOTS)
+        bad2["observation_position"] = {"value": "此功能在本地文件系统中生效",
+                                        "span": "不存在的引用文本"}
+        r2 = ccgc.compile_dialog(DIALOG, "tgt", "agent:a1",
+                                 slots=bad2, marks=MARKS, cg=cg)
+        ok((not r2.success) and _has(r2.errors, "E010"), "V2c 引用定位失败 → E010")
+
+        class EvilParser(object):
+            """冒充 LLM 通道：给出看起来合理但源文本里没有的值。"""
+
+            def candidates(self, dialog, ctx):
+                return {"marks": dict(MARKS), "slots": dict(bad_slots)}
+
+        r3 = ccgc.compile_dialog(DIALOG, "tgt", "agent:a1",
+                                 parser=EvilParser(), cg=cg)
+        ok((not r3.success) and _has(r3.errors, "E011"),
+           "V2d 外部 parser 幻觉同样被 E011 拦截（结构级阻断）")
+
+        # ---------- V3 四槽强制 ----------
+        r4 = ccgc.compile_dialog(DIALOG, "tgt", "agent:a1",
+                                 slots={"observation_position": SLOTS["observation_position"]},
+                                 marks=MARKS, cg=cg)
+        ok((not r4.success) and _has(r4.errors, "E020"), "V3a 四槽不全 → E020")
+
+        # ---------- V4/V5 唯一合成入口 + 六要素齐备 ----------
+        plain_slots = {k: v.get("value") for k, v in SLOTS.items()}
+        r = ccgc.compile_dialog(DIALOG, "tgt", "agent:a1",
+                                slots=SLOTS, marks=MARKS, cg=cg)
+        ok(r.success, "V4a 完整入参编译成功")
+        ok(r.lines.get("生效条件") == nodefile.condition_space_text(plain_slots),
+           "V4b 生效条件 == nodefile.condition_space_text（唯一入口）")
+        ok(set(r.lines) == set(nodefile.CCG_MARKS), "V5a 六要素齐备")
+        ok(r.sources.get("verification_basis") == "test", "V5b 验证基底 test")
+
+        # ---------- V7 自证拒绝（裁定 A 核心） ----------
+        a_self = ccgc.attest("tgt", ccgc.ACCEPT, "agent:a1", "agent:a1", cg=cg)
+        ok((not a_self.ok) and "E041" in a_self.error, "V7a 验证方==编译方 → E041")
+        a_defer = ccgc.attest("tgt", ccgc.DEFER, "designer", "agent:a1", cg=cg)
+        ok((not a_defer.ok) and "E042" in a_defer.error, "V7b DEFER 不构成签章")
+        a_ok = ccgc.attest("tgt", ccgc.ACCEPT, "designer", "agent:a1",
+                           evidence="设计者核对原文一致", cg=cg)
+        ok(a_ok.ok and bool(a_ok.token), "V7c 编外验证方 ACCEPT → 有效签章")
+
+        # ---------- V8 无章不写 ----------
+        l0 = ccgc.link(r, None, cg=cg, apply=True)
+        ok((not l0.ok) and any("E040" in e for e in l0.errors), "V8a 无签章 → E040 拒绝")
+        l1 = ccgc.link(r, a_self, cg=cg, apply=True)
+        ok(not l1.ok, "V8b 自证签章 → link 拒绝")
+        l2 = ccgc.link(r, a_ok, cg=cg, apply=False)
+        ok(l2.ok and l2.dry_run and l2.written == 0, "V8c dry-run 不写入")
+        _fm_b, c_before = cg._read(cg.index["nodes"]["tgt"])
+        ok(not nodefile.ccg_completeness(c_before)["complete"], "V5c link 前六要素不全")
+
+        # ---------- link 落库 ----------
+        l3 = ccgc.link(r, a_ok, cg=cg, apply=True)
+        ok(l3.ok and l3.written == 6, "V8d 签章通过 → 写入六行")
+        fm_after, c_after = cg._read(cg.index["nodes"]["tgt"])
+        ok(nodefile.ccg_completeness(c_after)["complete"],
+           "V5d link 后六要素齐备（可判定性提升）")
+        ok(fm_after.get("condition_space") == plain_slots, "V4c condition_space 落 frontmatter")
+        ok(fm_after.get("verification_basis") == "test", "V5e verification_basis 落盘")
+
+        # ---------- V6 未制造条件污染 ----------
+        rep = backfill.verify_conditions(cg)
+        ok(rep.get("legacy_position") == 0, "V6a 弱等价残留 legacy_position == 0")
+        ok(rep.get("from_synthesis", 0) >= 1, "V6b 生效条件来源=合成")
+
+        # ---------- V9 缺验证器恒 DEFER（能力外置） ----------
+        v = audit.audit("ccg_marks", {"node": "tgt"}, {})
+        ok(v.get("state") == "DEFER", "V9a 未注入验证器 → DEFER（不假装通过）")
+        ok(audit.kinds()["ccg_marks"]["basis"] == "test", "V9b ccg_marks 基底建议=test")
+
+        # ---------- V11 用后续验证修正生效条件 ----------
+        rc = ccgc.recalibrate("tgt", {"existence_constraint": "仅对本地可读文件生效"},
+                              "agent:a1", "agent:a1", cg=cg, apply=False)
+        ok(any("E041" in e for e in rc.errors), "V11a 修正方==编译方 → E041")
+        rc = ccgc.recalibrate("tgt", {"生效条件": "手写条件"}, "designer", "agent:a1",
+                              cg=cg, apply=False)
+        ok(any("E043" in e for e in rc.errors), "V11b 非四槽键 → E043（无第二通路）")
+        rc = ccgc.recalibrate("tgt", {"observation_tool": "该方法使用扩展名映射表进行路由"},
+                              "designer", "agent:a1", evidence="实测复核：方法槽无误",
+                              cg=cg, apply=True)
+        ok(rc.ok, "V11c 编外验证方修正获准")
+        _fm_r, c_r = cg._read(cg.index["nodes"]["tgt"])
+        ok(nodefile.ccg_completeness(c_r)["complete"], "V11d 修正后仍齐备")
+        logs = ccgc._read_jsonl(ccgc._log_path(cg))
+        ok(any(x.get("action") == "ccgc_recalibrate" and x.get("slots_before") is not None
+               and x.get("slots_after") is not None for x in logs),
+           "V11e 修正留痕含 before/after（可溯源）")
+        ok(any(x.get("action") == "ccgc_attest" for x in logs), "V11f 签章留痕可查")
+
+        # ---------- V13 内生规则解析器：诚实下界 ----------
+        r_rule = ccgc.compile_dialog(DIALOG, "tgt", "agent:a1", cg=cg)
+        ok(any("下界能力" in w for w in r_rule.warnings), "V13a 未注入解析器时如实声明下界")
+        bad_spans = [s for arr in r_rule.spans.values() for s in arr
+                     if s and s not in DIALOG]
+        ok(not bad_spans, "V13b 内生解析器引用全部 grounded")
+
+        # ---------- V14 产物无占位残留 ----------
+        ok(not any(nodefile.is_placeholder_text(x) for x in r.lines.values()),
+           "V14 产物无占位残留")
+
+        # ---------- V15 裁定 B 术语落地：单一真源 + 六要素一一对应 ----------
+        ok(ccgc.CONTRACT_ROLES is nodefile.CCG_CONTRACT_ROLES,
+           "V15a 术语真源唯一（ccgc 引用 nodefile，不另定义一份）")
+        ok(tuple(nodefile.CCG_CONTRACT_ROLES) == tuple(nodefile.CCG_MARKS),
+           "V15b 契约角色与六要素一一对应（顺序一致）")
+        ok(nodefile.CCG_CONTRACT_ROLES["生效条件"] == "前置条件 precondition",
+           "V15c 生效条件角色 = precondition（裁定 B）")
+
+        # ---------- V16 pending：候选与签章绑定（跨 MCP 三次独立调用形态） ----------
+        p_path = ccgc.pending_path(cg, "tgt")
+        ok(bool(p_path) and ccgc.PENDING_DIR in p_path, "V16a pending 落 LAYERS 之外的冷区")
+        sv = ccgc.save_pending(cg, r)
+        ok(bool(sv.get("ok")) and os.path.isfile(sv["path"]) and bool(sv.get("hash")),
+           "V16b 候选落盘并留内容摘要")
+        got = ccgc.load_pending(cg, "tgt")
+        ok(bool(got.get("ok")) and bool(got.get("hash_ok")), "V16c 读回摘要一致（原件未被改写）")
+        ok(got["compiled"].lines == r.lines, "V16d 读回六行 == 编译产物（无损搬运）")
+        with open(sv["path"], encoding="utf-8") as f:
+            rec = json.load(f)
+        rec["compiled"]["lines"]["功能名"] = "被篡改的功能名"
+        with open(sv["path"], "w", encoding="utf-8") as f:
+            json.dump(rec, f, ensure_ascii=False)
+        lx = ccgc.link_pending(cg, "tgt", apply=True)
+        ok((not lx.ok) and any("hash" in e for e in lx.errors),
+           "V16e 候选被改写 → hash 不符，拒绝写入（签章只忠于原件）")
+        sv = ccgc.save_pending(cg, r, a_ok)
+        lz = ccgc.link_pending(cg, "tgt", apply=True, actor="agent:a1")
+        ok(lz.ok and lz.written == 6, "V16f 读回原件+签章 → 落库成功")
+        ok(not os.path.isfile(sv["path"]), "V16g 落库成功即清 pending（暂存非存档）")
+        ok(not any(ccgc.PENDING_DIR in str(k) for k in (cg.index.get("nodes") or {})),
+           "V16h pending 不进索引（冷区对检索隐身）")
+
+        # ---------- V17 闸门：只认编外裁决，绝不假装通过 ----------
+        v = audit.audit("ccg_marks", {"node_id": "tgt", "unit_verdict": "ACCEPT",
+                                      "verifier": "hive:reflect:h1",
+                                      "evidence": "假单元复核：与原文一致"}, {})
+        ok(v.get("state") == "ACCEPT", "V17a 编外裁决+依据 → ACCEPT")
+        v = audit.audit("ccg_marks", {"node_id": "tgt", "unit_verdict": "ACCEPT",
+                                      "verifier": "hive:reflect:h1"}, {})
+        ok(v.get("state") == "DEFER", "V17b ACCEPT 但无依据 → DEFER（无依据不通过）")
+        v = audit.audit("ccg_marks", {"node_id": "tgt", "unit_verdict": "ACCEPT",
+                                      "verifier": "agent:a1", "evidence": "我自己验的"},
+                        {"compiled_by": "agent:a1"})
+        ok(v.get("state") == "REJECT", "V17c 自证 → REJECT（E041 在闸门层再挡一次）")
+        v = audit.audit("ccg_marks", {"node_id": "tgt", "unit_verdict": "ACCEPT",
+                                      "evidence": "无验证方"}, {})
+        ok(v.get("state") == "DEFER", "V17d 有裁决缺验证方标识 → DEFER")
+        v = audit.audit("ccg_marks", {"node_id": "tgt"}, {})
+        d = v.get("detail") or {}
+        ok(v.get("state") == "DEFER" and bool(d.get("next")) and d.get("channel_state") in units.STATES,
+           "V17e 无裁决 → DEFER 且给出下一步通道（不阻塞写路径）")
+        v = audit.audit("ccg_marks", {}, {})
+        ok(v.get("state") == "DEFER", "V17f 缺 node_id → DEFER")
+
+        # ---------- V18 复核通道：三态如实 + 来源标识结构上非编译者 ----------
+        ok(units.transport_name(units.HIVE, units.REFLECT, "h1") == "hive:reflect:h1",
+           "V18a 蜂巢来源标识 = hive:<role>:<job>")
+        ok(units.transport_name(units.HIVE, units.REFLECT, "h1") != "agent:a1",
+           "V18b 来源标识结构上不可能等于编译者（裁定 A 不被误伤）")
+        u = units.verdict_of('前置说明\n```json\n{"verdict":"accept","reason":"一致"}\n```')
+        ok(u["verdict"] == units.ACCEPT and bool(u["parsed"]), "V18c 围栏 JSON 可解析 → ACCEPT")
+        u = units.verdict_of("我无法判断这件事")
+        ok(u["verdict"] == units.DEFER and not u["parsed"], "V18d 解析不出 → DEFER（不猜测）")
+        u = units.verdict_of({"verdict": "drop", "reason": "与原文不符",
+                              "slot_corrections": {"observation_tool": "x"}})
+        ok(u["verdict"] == units.REJECT and bool(u["slot_corrections"]),
+           "V18e drop → REJECT（四槽修正随裁决带回）")
+        aa = units.to_attest_args({"verdict": units.ACCEPT, "reason": "一致"}, state=units.HIVE,
+                                  role=units.REFLECT, job_id="h1",
+                                  compiled_by=units.transport_name(units.HIVE, units.REFLECT, "h1"))
+        ok(aa.get("self_verify") is True, "V18f 万一自证 → 显式标记（供上层拒绝）")
+        aa = units.to_attest_args({"verdict": units.ACCEPT, "reason": "一致"}, state=units.HIVE,
+                                  role=units.REFLECT, job_id="h1", compiled_by="agent:a1")
+        ok(not aa.get("self_verify") and aa["verifier"].startswith("hive:reflect:"),
+           "V18g 非自证：verifier 取蜂巢来源标识（不设自证标记）")
+        pr = units.probe(jobs=os.path.join(tmp, "nojobs"))
+        ok(pr["state"] == units.CONFIGURE and units.ENV_MODEL in pr["hint"],
+           "V18h 蜂巢不可用 → 返回配置指引（不自动拉起、不假装可用）")
+        pr = units.probe(jobs=os.path.join(tmp, "nojobs"), allow_degrade=True)
+        ok(pr["state"] == units.SUBAGENT, "V18i 显式 allow_degrade → 子代理降级（不冒充 hive）")
+
+        # ---------- V19/V20 端到端：假蜂巢 → 编外裁决 → 签章 → 落库 ----------
+        jobs = os.path.join(tmp, "jobs")
+        os.makedirs(jobs, exist_ok=True)
+        with open(os.path.join(jobs, units.SERVE_FILE), "w", encoding="utf-8") as f:
+            json.dump({"ts": int(time.time() * 1000), "pid": os.getpid()}, f)
+        seen = {}
+        stop = threading.Event()
+        th = threading.Thread(target=_fake_serve, args=(jobs, stop, seen), daemon=True)
+        th.start()
+        _old_model = os.environ.get(units.ENV_MODEL)
+        os.environ[units.ENV_MODEL] = "fake-unit-model"
+        try:
+            pr = units.probe(jobs=jobs)
+            ok(pr["state"] == units.HIVE, "V19a 心跳新鲜+模型已配 → HIVE 可派发")
+            rv = units.review(digest=r, dialog=DIALOG, role=units.REFLECT, node_id="tgt",
+                              jobs=jobs, blocking=True, wait_s=30, cg=cg, actor="agent:a1")
+            ok(rv["state"] == units.HIVE and bool(rv.get("unit")), "V19b 派发并取回编外裁决")
+            ok((rv["unit"] or {}).get("verdict") == units.ACCEPT, "V19c 单元裁决解析为 ACCEPT")
+            ok(seen.get("role") == units.REFLECT and seen.get("model") == "fake-unit-model"
+               and seen.get("prompt_has_dialog"),
+               "V19d spec 形态合蜂巢契约（role/model/复核包正文）")
+            ok(str((rv.get("attest") or {}).get("verifier") or "").startswith("hive:reflect:"),
+               "V19e 签章方 = 蜂巢单元标识（结构上非编译者）")
+            at = ccgc.attest("tgt", rv["attest"]["verdict"], rv["attest"]["verifier"],
+                             "agent:a1", evidence=rv["attest"]["evidence"] or "单元复核",
+                             cg=cg)
+            ok(at.ok, "V19f 蜂巢裁决可直接签章（E041 不被误伤）")
+            logs = ccgc._read_jsonl(os.path.join(str(cg.root), units.LOG_NAME))
+            ok(any(x.get("action") == "review" and x.get("job_id") for x in logs),
+               "V19g 派发留痕（job_id 可追溯）")
+
+            # --- V20 MCP 工具面：compile → review → attest/link 三段式 ---
+            mcp = _import_mcp()
+            ok(mcp is not None, "V20a 工具面可加载")
+            c1 = mcp._ccg_call(cg, {"ccg": {"action": "catalog"}})
+            ok(c1["ok"] and "compile" in c1["actions"] and "E041" in c1["errors"],
+               "V20b catalog 自描述（动作清单 + 错误码）")
+            c2 = mcp._ccg_call(cg, {"ccg": {"action": "compile", "node_id": "tgt",
+                                            "dialog": DIALOG, "marks": MARKS, "slots": SLOTS}})
+            ok(c2["ok"] and c2["compiled"]["success"] and c2["pending"]["ok"],
+               "V20c compile 成功并落 pending（不当场写库）")
+            ok("E041" in c2["hint"], "V20d hint 指向编外复核（裁定 A 对调用方可见）")
+            c3 = mcp._ccg_call(cg, {"ccg": {"action": "attest", "node_id": "tgt",
+                                            "verdict": "ACCEPT", "verifier": c2["compiled_by"],
+                                            "compiled_by": c2["compiled_by"],
+                                            "evidence": "我自己验的"}})
+            ok((not c3["ok"]) and "E041" in str(c3["attest"]["error"]),
+               "V20e MCP 面自证 → E041（机械拒绝，不靠自觉）")
+            c4 = mcp._ccg_call(cg, {"ccg": {"action": "link", "node_id": "tgt", "apply": True}})
+            ok(not c4["ok"], "V20f 自证章不构成准入 → link 拒绝")
+            c5 = mcp._ccg_call(cg, {"ccg": {"action": "review", "node_id": "tgt",
+                                            "jobs": jobs, "blocking": True, "wait_s": 30}})
+            ok(c5["state"] == units.HIVE and c5["verdict"] == "ACCEPT" and c5["passed"] is True,
+               "V20g review 取回裁决：ok/verdict/passed 三者分离")
+            ok(bool((c5.get("attest") or {}).get("ok")), "V20h 拿到裁决即自动签章")
+            c7 = mcp._ccg_call(cg, {"ccg": {"action": "review", "node_id": "tgt",
+                                            "jobs": jobs, "blocking": False}})
+            ok(c7["state"] == units.HIVE and c7["verdict"] is None and c7["passed"] is False,
+               "V20j 非阻塞：派发成功但裁决未回（verdict=None，不冒充通过）")
+            c6 = mcp._ccg_call(cg, {"ccg": {"action": "link", "node_id": "tgt", "apply": True}})
+            ok(c6["ok"] and c6["link"]["written"] == 6, "V20i link 落库（三段式闭环）")
+            c10 = mcp._ccg_call(cg, {"ccg": {"action": "link", "node_id": "tgt", "apply": True}})
+            ok(not c10["ok"], "V20m 落库后 pending 已清 → 再 link 明确报错（暂存非存档）")
+            c8 = mcp._ccg_call(cg, {"ccg": {"action": "units", "jobs": jobs, "doctor": True}})
+            ok(c8["ok"] and c8["action"] == "units", "V20k units/doctor 走三级链体检")
+            c9 = mcp._ccg_call(cg, {"ccg": {"action": "nope"}})
+            ok(not c9["ok"], "V20l 未知 action → 明确报错（不静默降级）")
+        finally:
+            stop.set()
+            th.join(timeout=3)
+            if _old_model is None:
+                os.environ.pop(units.ENV_MODEL, None)
+            else:
+                os.environ[units.ENV_MODEL] = _old_model
+
+    finally:
+        print()
+        print("ccgc: PASS=%d FAIL=%d" % (PASS, FAIL))
+        if FAILS:
+            print("FAILS: " + "; ".join(FAILS))
+        shutil.rmtree(tmp, ignore_errors=True)
+    return 1 if FAIL else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())