@furongjun1999/dsh-memory 0.4.6 → 0.4.8

package/md_cg/test_transfer.py

@@ -0,0 +1,180 @@
+# -*- coding: utf-8 -*-
+"""transfer_test 迁移成功率实测（补测②，矩阵 #8 / P-V-15）。
+
+理论定义（P-V-15 / aeis_core api.py 同口径）：
+  条件空间内新实体预测成功率，2×SE 显著性；样本 < 20 不构成迁移判定（DEVIATION-005）。
+补测设计（矩阵 §4.1）：固定题族（同条件空间、新实体）× 新旧知识库对照：
+  Phase A 旧库：仅旧实体 → 基线题命中 + 新实体题（预期 0）
+  Phase B 学习：写入新实体（纯 add，无重训——写入即生效）
+  Phase C 新库：同题族复测 → 迁移成功率 + 旧任务不遗忘对照
+判定口径：hit = 目标节点在 search top5 且资格非 REJECT（检索性能与资格标注正交）。
+显著性：Δ=pC−pA>2×SE；完全分离（pA=0,pC=1，SE=0）时直接判显著（强于推断检验）。
+"""
+import math
+import os
+import sys
+import tempfile
+import shutil
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from md_cg.mdcg import MdCG
+
+PASS = 0
+FAIL = 0
+FAILS = []
+
+
+def check(name, ok, detail=""):
+    global PASS, FAIL
+    if ok:
+        PASS += 1
+        print(f"  [PASS] {name}  · {detail}")
+    else:
+        FAIL += 1
+        FAILS.append(name)
+        print(f"  [FAIL] {name}  · {detail}")
+
+
+# ---------------- 题族：金属导电域（同条件空间 · 旧/新实体） ----------------
+OLD_METALS = ["铜", "铁", "铝", "金", "银", "锌", "镍", "锡", "铅", "钨",
+              "铂", "汞", "钠", "钾", "钙", "钡", "钛", "铬", "锰", "钴"]
+NEW_METALS = ["铯", "铷", "铍", "镁", "镉", "铋", "锑", "锶", "铟", "镓",
+              "铊", "锗", "铪", "钽", "铌", "钒", "钼", "锆", "镧", "铈"]
+assert len(OLD_METALS) >= 20 and len(NEW_METALS) >= 20, "DEVIATION-005：样本<20 不构成迁移判定"
+
+
+CONDITION_SPACE = {
+    "observation_position": "常温实验台",
+    "time_window": [0.0, 9999999999.0],
+    "observation_tool": "万用表电阻测量",
+    "existence_constraint": "被测对象为{m}且表面干燥",
+}
+
+
+def node_body(m):
+    """CCG 六要素标题行正文（ccg_completeness 只认「# 要素：」形态）：
+    生效条件行由 condition_space_text 四槽渲染（唯一合成入口，不手写冒充），
+    约束槽含实体词面——供 judge 正条件确认命中。"""
+    from md_cg.nodefile import condition_space_text
+    cs = {k: (v.format(m=m) if isinstance(v, str) else v)
+          for k, v in CONDITION_SPACE.items()}
+    eff = condition_space_text(cs)
+    assert eff, "四槽不全不构成生效条件（fail-closed）"
+    return (f"# 功能名：金属{m}导电性检测\n\n"
+            f"{m}是金属，常态下可导电，电阻率可由万用表测得。\n\n"
+            f"# 生效条件：{eff}\n\n"
+            f"# 子功能：对象识别；电阻测量；结果判读\n\n"
+            f"# 执行：确认对象为{m} → 万用表测量 → 读出电阻率\n\n"
+            f"# 验证方式：实测电阻率落在{m}标准值区间即通过（measurement）\n\n"
+            f"# 不适用条件：对象非{m}或表面潮湿时测量结果不适用\n")
+
+
+def seed(cg, metals):
+    """同一条件空间四槽 + 六要素标题行正文——「同条件空间、新实体」的理论口径。"""
+    for m in metals:
+        cs = {k: (v.format(m=m) if isinstance(v, str) else v)
+              for k, v in CONDITION_SPACE.items()}
+        cg.add(f"metal_{m}", node_body(m), layer="knowledge",
+               tags=["测试-迁移题族"], condition_space=cs,
+               verification_basis="measurement")
+
+
+# 检索任务情境（两阶段同口径）：实体词面由 query 提供（检索命中），
+# 条件词面由情境提供（正条件确认）——检索性能与资格确认各司其职。
+SCENE_CTX = {"task": "在常温实验台检查金属样本导电性，须按各样本声明条件执行"}
+
+
+def probe(cg, metals, k=5):
+    """题级命中：目标节点在 top5 且资格非 REJECT。返回 (hits, qual_counts)。"""
+    hits, quals = 0, {}
+    for m in metals:
+        res, _ = cg.search(f"{m}导电吗", k=k, context=SCENE_CTX, record=False)
+        target = f"metal_{m}"
+        ok = False
+        for node, score, qual in res:
+            q = qual.get("state") if isinstance(qual, dict) else (qual or "?")
+            quals[q] = quals.get(q, 0) + 1
+            if node.get("id") == target and q != "REJECT":
+                ok = True
+                break
+        hits += 1 if ok else 0
+    return hits, quals
+
+
+def two_se(pA, nA, pC, nC):
+    """2×SE 比例差检验；完全分离（SE=0 且 Δ>0）判显著。"""
+    se = math.sqrt(pA * (1 - pA) / nA + pC * (1 - pC) / nC)
+    delta = pC - pA
+    if se == 0:
+        return se, delta, delta > 0
+    return se, delta, delta > 2 * se
+
+
+def run_transfer(n_old, n_new, verbose=False):
+    """三阶段对照，返回指标 dict。n 由参数控制（供样本守卫测试）。"""
+    root = tempfile.mkdtemp(prefix="mdcg_transfer_")
+    try:
+        cg = MdCG(root)
+        olds, news = OLD_METALS[:n_old], NEW_METALS[:n_new]
+        # Phase A：旧库（仅旧实体）
+        seed(cg, olds)
+        a_old, _ = probe(cg, olds)
+        a_new, _ = probe(cg, news)
+        # Phase B：学习新实体（纯 add，无重训）
+        seed(cg, news)
+        # Phase C：新库复测
+        c_new, quals_c_new = probe(cg, news)
+        c_old, _ = probe(cg, olds)
+        pA, pC = a_new / n_new, c_new / n_new
+        se, delta, sig = two_se(pA, n_new, pC, n_new)
+        return {
+            "n_old": n_old, "n_new": n_new,
+            "a_old": a_old, "a_new": a_new,
+            "c_new": c_new, "c_old": c_old,
+            "quals_c_new": quals_c_new,
+            "pA": round(pA, 3), "pC": round(pC, 3),
+            "delta": round(delta, 3), "se": round(se, 4), "significant": sig,
+            "retention_ok": c_old >= a_old,
+            "n_judgable": n_new >= 20,
+            "verdict": ("insufficient_sample" if n_new < 20 else
+                        ("transfer_confirmed" if sig and c_old >= a_old
+                         else "transfer_not_confirmed")),
+        }
+    finally:
+        shutil.rmtree(root, ignore_errors=True)
+
+
+def main():
+    global PASS, FAIL
+    print("\n[1] 主对照：20 旧实体 × 20 新实体（同条件空间题族）")
+    r = run_transfer(20, 20)
+    print(f"    Phase A 旧库：基线题 {r['a_old']}/20，新实体题 {r['a_new']}/20")
+    print(f"    Phase C 新库：迁移题 {r['c_new']}/20（qual 分布 {r['quals_c_new']}），"
+          f"基线复测 {r['c_old']}/20")
+    print(f"    成功率 {r['pA']}→{r['pC']}（Δ={r['delta']}, SE={r['se']}, "
+          f"2×SE 显著={r['significant']}），不遗忘={r['retention_ok']}")
+    print(f"    判定 verdict={r['verdict']}（n={r['n_new']}）")
+
+    print("\n[2] 断言")
+    check("① Phase A 基线题命中（旧库自身健康 ≥19/20）", r["a_old"] >= 19, f"{r['a_old']}/20")
+    check("② Phase A 新实体题成功率为 0（旧库无新实体知识）", r["a_new"] == 0, f"{r['a_new']}/20")
+    check("③ Phase C 迁移成功率 ≥19/20（写入即生效）", r["c_new"] >= 19, f"{r['c_new']}/20")
+    check("④ 2×SE 显著性成立", r["significant"], f"Δ={r['delta']} SE={r['se']}")
+    check("⑤ 旧任务不遗忘（基线复测不降）", r["retention_ok"], f"{r['a_old']}→{r['c_old']}")
+    check("⑥ 判定为 transfer_confirmed（n≥20 达判定门槛）",
+          r["verdict"] == "transfer_confirmed", r["verdict"])
+
+    print("\n[3] 样本守卫：n=10（<20）须拒绝判定")
+    small = run_transfer(5, 10)
+    check("⑦ 小样本 verdict=insufficient_sample（DEVIATION-005）",
+          small["verdict"] == "insufficient_sample",
+          f"n={small['n_new']} verdict={small['verdict']}")
+
+    print(f"\n{'=' * 60}\n通过 {PASS} / {PASS + FAIL}")
+    if FAILS:
+        print("失败：" + "、".join(FAILS))
+    return FAIL == 0
+
+
+if __name__ == "__main__":
+    sys.exit(0 if main() else 1)

package/md_cg/test_twophase.py

@@ -0,0 +1,286 @@
+# -*- coding: utf-8 -*-
+"""test_twophase · 写入两段式提交（Pi 可学习优点 ③）
+
+验收口径（交接文档 §3③）：
+- 写入在**闸门通过后先落 intent**（含内容指纹），落盘完成再落 outcome；
+- 「kill -9 模拟半途写入后重启」→ 对账**正确补账**（内容确已落盘）或
+  **如实标记**（未落盘 / 指纹不符），不假装成功；
+- 对账幂等、账本 append-only、不重放写入；
+- 未落盘的分支（闸门拒绝 / 入队）不产生 intent——没打算写就不记账。
+
+运行：python -m md_cg.test_twophase
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import tempfile
+import traceback
+
+from . import twophase, writepipe
+from .mdcos import MdCGSecure
+from .security import Principal
+
+_ok = 0
+_fail = []
+_seq = [0]
+
+
+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]))
+
+
+def _mk_cg(tmp, role="designer"):
+    _seq[0] += 1
+    root = os.path.join(tmp, "root_%02d_%s" % (_seq[0], role))
+    p = Principal(tenant="default", actor="t_" + role, role=role,
+                  can_write=(role != "guest"), can_admin=(role == "designer"))
+    return MdCGSecure(root, principal=p)
+
+
+def _policy(tmp, required=("PASSED",), forbidden=("FORBIDDEN_WORD",)):
+    path = os.path.join(tmp, "policy.json")
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump({"forbidden": list(forbidden),
+                   "required": list(required)}, f)
+    os.environ["MDCG_POLICY_FILE"] = path
+    return path
+
+
+def _lines(cg):
+    p = twophase.log_path(cg)
+    if not os.path.isfile(p):
+        return []
+    with open(p, encoding="utf-8", errors="replace") as f:
+        return [x for x in f.read().splitlines() if x.strip()]
+
+
+def _recs(cg):
+    return twophase.records(cg)
+
+
+def _idx(cg, nid):
+    return (cg.index.get("nodes") or {}).get(nid) or {}
+
+
+def _phases(cg, nid=None):
+    return [r.get("phase") for r in _recs(cg)
+            if nid is None or r.get("id") == nid]
+
+
+def _run(tmp):
+    _policy(tmp)
+    pipe = writepipe.install_default_gates(writepipe.WritePipeline())
+
+    # ---------- ① 正常落盘：intent + outcome 成对 ----------
+    cg = _mk_cg(tmp)
+    out = pipe.execute(cg, {"content_kind": "text",
+                            "content": "两段式正常落盘 PASSED",
+                            "layer": "knowledge"})
+    nid = out.get("id")
+    check("①1 写入成功（committed）", out.get("committed") is True, out)
+    recs = _recs(cg)
+    ph = [r["phase"] for r in recs if r.get("id") == nid]
+    check("①2 账本两行成对（intent → outcome）", ph == ["intent", "outcome"], ph)
+    intent = [r for r in recs if r.get("id") == nid
+              and r["phase"] == "intent"][0]
+    oc = [r for r in recs if r.get("id") == nid and r["phase"] == "outcome"][0]
+    check("①3 intent 带内容指纹（对账的判据）",
+          bool(intent.get("content_hash")), intent)
+    check("①4 outcome 记 committed + 同 iid",
+          oc.get("status") == twophase.STATUS_COMMITTED
+          and oc.get("iid") == intent.get("iid"), oc)
+    check("①5 指纹走 nodefile 唯一真源（含写盘尾换行归一）",
+          intent.get("content_hash")
+          == twophase.nodefile.content_hash("两段式正常落盘 PASSED"),
+          (intent.get("content_hash"),
+           twophase.nodefile.content_hash("两段式正常落盘 PASSED")))
+    check("①6 正常写入后无未结清意图", cg.pending_writes() == [])
+
+    # ---------- ② intent 真的**先于**落盘（真实执行路径内观测） ----------
+    cg2 = _mk_cg(tmp)
+    _orig = writepipe._executor
+    seen = {}
+
+    def _probe(ctx):
+        seen["has_intent"] = any(
+            r.get("phase") == "intent" and r.get("id") == ctx["nid"]
+            for r in _recs(ctx["cg"]))
+        seen["has_outcome"] = any(
+            r.get("phase") == "outcome" and r.get("id") == ctx["nid"]
+            for r in _recs(ctx["cg"]))
+        seen["node_exists"] = bool(ctx["cg"].get(ctx["nid"]))
+        return _orig(ctx)
+
+    writepipe._executor = _probe
+    try:
+        pipe.execute(cg2, {"content_kind": "text",
+                           "content": "先行持久化探针 PASSED",
+                           "layer": "knowledge"})
+    finally:
+        writepipe._executor = _orig
+    check("②1 进入执行器时 intent 已落账（先行持久化成立）",
+          seen.get("has_intent") is True, seen)
+    check("②2 进入执行器时**尚无** outcome 且节点未落盘",
+          seen.get("has_outcome") is False
+          and seen.get("node_exists") is False, seen)
+
+    # ---------- ③ 半途崩溃：落盘已完成、outcome 未写 ----------
+    cg3 = _mk_cg(tmp)
+    nid3 = "mem_2pc_c3"
+    tok = twophase.begin(cg3, nid3, "崩溃在落盘之后 PASSED", layer="knowledge",
+                         actor="test:crash")
+    cg3.add(nid3, "崩溃在落盘之后 PASSED", layer="knowledge")
+    check("③1 崩溃现场：有 intent 无 outcome",
+          _phases(cg3, nid3) == ["intent"]
+          and len(cg3.pending_writes()) == 1)
+    rep = cg3.reconcile_writes()
+    check("③2 对账补账（内容指纹吻合 → committed）",
+          rep.get("unpaired") == 1 and rep.get("committed") == 1
+          and rep.get("interrupted") == 0, rep)
+    check("③3 补出的 outcome 标 reconciled + 判据可审计",
+          any(r.get("phase") == "outcome" and r.get("reconciled")
+              and r.get("reason") == twophase.R_NODE_OK
+              for r in _recs(cg3)), _recs(cg3)[-1])
+    check("③4 对账后 pending 归零",
+          cg3.pending_writes() == [])
+
+    # ---------- ④ 半途崩溃：根本没落盘 ----------
+    cg4 = _mk_cg(tmp)
+    twophase.begin(cg4, "mem_2pc_c4", "崩溃在落盘之前 PASSED",
+                   layer="knowledge")
+    rep4 = cg4.reconcile_writes()
+    check("④1 未落盘 → 如实标记 interrupted（不假装成功）",
+          rep4.get("unpaired") == 1 and rep4.get("interrupted") == 1
+          and rep4.get("committed") == 0, rep4)
+    check("④2 interrupted 判据 = node_missing",
+          rep4["details"][0]["reason"] == twophase.R_NODE_MISSING, rep4)
+    check("④3 未落盘节点确实不在库（标记与实际一致）",
+          cg4.get("mem_2pc_c4") is None)
+
+    # ---------- ⑤ 指纹不符：落了别的正文 ----------
+    cg5 = _mk_cg(tmp)
+    twophase.begin(cg5, "mem_2pc_c5", "意图写的是这一段 PASSED")
+    cg5.add("mem_2pc_c5", "实际落的是另一段 PASSED", layer="knowledge")
+    rep5 = cg5.reconcile_writes()
+    check("⑤1 指纹不符 → interrupted（content_mismatch）",
+          rep5.get("interrupted") == 1
+          and rep5["details"][0]["reason"] == twophase.R_MISMATCH, rep5)
+    check("⑤2 对账**不覆盖**既有正文（只标记不重放）",
+          "实际落的是另一段" in (cg5.get("mem_2pc_c5") or {}).get("content", ""))
+
+    # ---------- ⑥ dry-run / 幂等 / append-only ----------
+    cg6 = _mk_cg(tmp)
+    twophase.begin(cg6, "mem_2pc_c6", "dry-run 用例 PASSED")
+    before = _lines(cg6)
+    dry = cg6.reconcile_writes(apply=False)
+    check("⑥1 dry-run 报告未结清但不改账本",
+          dry.get("unpaired") == 1 and dry.get("applied") is False
+          and _lines(cg6) == before, dry)
+    cg6.reconcile_writes()
+    n_after_first = len(_lines(cg6))
+    rep6b = cg6.reconcile_writes()
+    check("⑥2 对账幂等（二次无未结清、不追加行）",
+          rep6b.get("unpaired") == 0
+          and len(_lines(cg6)) == n_after_first, rep6b)
+    check("⑥3 账本 append-only（原记录逐字保留）",
+          _lines(cg6)[:len(before)] == before)
+    snap = _lines(cg6)
+    cg6.pending_writes()
+    check("⑥4 pending 只读（不改账本）", _lines(cg6) == snap)
+
+    # ---------- ⑦ 执行器抛异常 → outcome=error，异常照抛 ----------
+    cg7 = _mk_cg(tmp, role="guest")     # guest 无写权限 → 库层拒绝
+    pipe7 = writepipe.WritePipeline()   # 不装闸：直接打执行器
+    raised = None
+    try:
+        pipe7.execute(cg7, {"content": "无权限写入 PASSED",
+                            "layer": "knowledge"})
+    except Exception as exc:            # AccessDenied 或其子类
+        raised = type(exc).__name__
+    check("⑦1 库层权限拒绝照抛（两段式不改错误语义）", raised is not None,
+          raised)
+    check("⑦2 失败也留痕：outcome=error 且无 committed",
+          any(r.get("phase") == "outcome"
+              and r.get("status") == twophase.STATUS_ERROR
+              for r in _recs(cg7)), _recs(cg7))
+    check("⑦3 失败不留未结清意图（已配对）", cg7.pending_writes() == [])
+
+    # ---------- ⑧ 未落盘的分支不记账 ----------
+    cg8 = _mk_cg(tmp)
+    out8 = pipe.execute(cg8, {"content_kind": "text",
+                              "content": "这段含 FORBIDDEN_WORD 应被拒",
+                              "layer": "knowledge"})
+    check("⑧1 闸门拒绝分支：committed=False",
+          out8.get("committed") is False, out8.get("moved_to"))
+    check("⑧2 未落盘 → **不产生** intent（没打算写就不记账）",
+          _phases(cg8) == [], _recs(cg8))
+    check("⑧3 对账在空账本上恒无未结清",
+          cg8.reconcile_writes().get("unpaired") == 0)
+
+    # ---------- ⑨ gated 替代执行路径也成对 ----------
+    cg9 = _mk_cg(tmp)
+    out9 = pipe.execute(cg9, {"content_kind": "text",
+                              "content": "gated 主动遗忘路径 PASSED",
+                              "layer": "contextual", "gated": True,
+                              "importance": 0.5})
+    nid9 = out9.get("id")
+    ph9 = _phases(cg9, nid9)
+    check("⑨1 gated 路径账本成对（intent → outcome）",
+          ph9 == ["intent", "outcome"], ph9)
+    oc9 = [r for r in _recs(cg9)
+           if r.get("id") == nid9 and r["phase"] == "outcome"][0]
+    check("⑨2 结局与 verdict 一致（committed 当且仅当落盘）",
+          (oc9.get("status") == twophase.STATUS_COMMITTED)
+          == bool(out9.get("committed")), (oc9, out9.get("committed")))
+    check("⑨3 gated 结局无未结清（自己落盘的路径也结清）",
+          cg9.pending_writes() == [])
+
+    # ---------- ⑩ 边界 ----------
+    cg10 = _mk_cg(tmp)
+    check("⑩1 空账本：records/pending/reconcile 均不炸",
+          _recs(cg10) == [] and cg10.pending_writes() == []
+          and cg10.reconcile_writes().get("unpaired") == 0)
+    bad = os.path.join(cg10.root, "_write_2pc.jsonl")
+    with open(bad, "a", encoding="utf-8") as f:
+        f.write("{坏行不是 json\n")
+    check("⑩2 坏行跳过不炸（账本读侧容错）",
+          isinstance(_recs(cg10), list))
+    check("⑩3 指纹算法与 nodefile 同源（唯一真源，防漂移）",
+          twophase.nodefile.content_hash("abc")
+          == __import__("hashlib").sha256(b"abc").hexdigest()[:12])
+    check("⑩4 账本文件在 root 下（随记忆库一起备份/迁移）",
+          os.path.dirname(twophase.log_path(cg10)) == cg10.root)
+    check("⑩5 对账只增行不删行（append-only 结构保证）",
+          len(_lines(cg10)) >= 1 and all(l.strip() for l in _lines(cg10)))
+
+
+def main():
+    tmp = tempfile.mkdtemp(prefix="twophase_")
+    old = os.environ.pop("MDCG_POLICY_FILE", None)
+    try:
+        _run(tmp)
+    except Exception:
+        traceback.print_exc()
+        _fail.append("未捕获异常")
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+        if old is not None:
+            os.environ["MDCG_POLICY_FILE"] = old
+        else:
+            os.environ.pop("MDCG_POLICY_FILE", None)
+    print("\ntest_twophase: %d 通过 / %d 失败" % (_ok, len(_fail)))
+    if _fail:
+        print("失败项：" + "、".join(_fail))
+    raise SystemExit(1 if _fail else 0)
+
+
+if __name__ == "__main__":
+    main()

package/md_cg/test_verify_answer.py

@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*-
+"""test_verify_answer.py —— 回答三层自校验专项测试（矩阵 v0.2 #22 · B→A）
+
+背景（§2A-5）：verify_answer + chat_engine 强制闸代码齐备，但无专项测试、
+无拒绝输出案例留痕；anchor 层 4 节点全部 vb=null（锚点自身无验证基底）。
+
+本测试三部分：
+  [1] 三层校验确定性用例矩阵（L1 结构 / L2 来源 / L3 边界：拦截 + 通过 + 边界值）
+  [2] chat_engine 出口强制闸接线静态断言（所有回答出口必过 verify_answer，
+      失败替换诚实声明——「写错会被拒绝」是机制非人肉）
+  [3] 拒绝案例留痕：逐案例打印 ok + 校验明细（可复放），并以 anchor 规范
+      锚点自指案例收尾（锚点描述的泄漏形态正是校验拦截的形态）
+"""
+import os
+import sys
+
+if hasattr(sys.stdout, "buffer"):
+    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+_WISDOM = os.path.join(os.path.dirname(os.path.abspath(__file__)), "whitebox_kb", "wisdom")
+sys.path.insert(0, _WISDOM)
+
+from verify_answer import verify_answer, detect_card_format, LEGITIMATE_KINDS  # noqa: E402
+
+PASS, FAIL = 0, 0
+
+
+def check(name, cond, detail=""):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  [PASS] {name}" + (f"  · {detail}" if detail else ""))
+    else:
+        FAIL += 1
+        print(f"  [FAIL] {name}" + (f"  · {detail}" if detail else ""))
+
+
+# ------------------------------------------------------------------
+# [1] 三层校验用例矩阵
+# ------------------------------------------------------------------
+print("\n[1] 三层校验用例矩阵（拦截 / 通过 / 边界值）\n")
+
+# 每条：(名称, reply, meta, 期望ok, checks 必含关键词或 None)
+CASES = [
+    # ---- L1 结构：拦截 ----
+    ("L1 空回答拦截", "", {"kind": "honest"}, False, "空/过短"),
+    ("L1 过短拦截（1字）", "好", {"kind": "chitchat"}, False, "空/过短"),
+    ("L1 矛盾句式拦截（整卡内部格式）",
+     "自律是『即时奖励』vs『延迟满足』的矛盾——需要平衡短期与长期。",
+     {"kind": "knowledge", "hits": [{"name": "自律"}]}, False, "内部格式泄漏"),
+    ("L1 真相标记拦截", "延迟满足的真相：越能等待的孩子未来成就越高。",
+     {"kind": "knowledge", "hits": [{"name": "延迟满足"}]}, False, "内部格式泄漏"),
+    ("L1 括号密度拦截（6个且>8%）", "（甲）（乙）（丙）（丁）（戊）（己）",
+     {"kind": "knowledge", "hits": [{"name": "卡"}]}, False, "内部格式泄漏"),
+    ("L1 超长拦截（501字疑似整卡）", "字" * 501, {"kind": "knowledge", "hits": [{"name": "卡"}]},
+     False, "超长"),
+    # ---- L2 来源：拦截 ----
+    ("L2 未知出口类别拦截", "正常回答内容。", {"kind": "hack"}, False, "未知出口类别"),
+    ("L2 knowledge 无 hits 拦截", "这是一个带卡导航的正常回答，可以看「某卡」。",
+     {"kind": "knowledge", "hits": []}, False, "无 hits"),
+    ("L2 knowledge 缺卡导航拦截", "这是一个没有导航的知识性回答。",
+     {"kind": "knowledge", "hits": [{"name": "某卡"}]}, False, "缺卡导航"),
+    # ---- L3 边界：拦截 ----
+    ("L3 多处省略号截断拦截", "第一部分...第二部分...第三部分...还有",
+     {"kind": "chitchat"}, False, "疑似截断"),
+    ("L3 TODO 占位拦截", "这个回答还没写完 TODO", {"kind": "chitchat"}, False, "占位残留"),
+    ("L3 函数占位拦截", "计算结果见 {fn}", {"kind": "chitchat"}, False, "占位残留"),
+    ("L3 占位字样拦截", "此处为占位内容，后续补充。", {"kind": "chitchat"}, False, "占位残留"),
+    # ---- 通过面 ----
+    ("通过：knowledge 带hits+卡导航",
+     "常温下金属可以导电，细节可以看「金属导电卡」。",
+     {"kind": "knowledge", "hits": [{"name": "金属导电卡"}]}, True, None),
+    ("通过：knowledge 带hits+条件空间",
+     "常温下金属可以导电（这条知识属于金属导电卡的条件空间：常温干燥）。",
+     {"kind": "knowledge", "hits": [{"name": "金属导电卡"}]}, True, None),
+    ("通过：honest 诚实边界", "我没有把握回答这个问题，需要先查证。",
+     {"kind": "honest"}, True, None),
+    ("通过：chitchat 闲聊", "今天过得不错，谢谢关心。", {"kind": "chitchat"}, True, None),
+    ("通过：emotion 情感", "我理解你的感受，慢慢来。", {"kind": "emotion"}, True, None),
+    ("通过：memory 回忆", "我们上次聊过类似的话题。", {"kind": "memory"}, True, None),
+    ("通过：缺省 kind 视为 knowledge 且须合规",
+     "答案如下，可以看「规则卡」。", {"hits": [{"name": "规则卡"}]}, True, None),
+    # ---- 边界值（正确放行 / 正确拦截的临界）----
+    ("边界：恰500字不超长", "答" * 500, {"kind": "chitchat"}, True, None),
+    ("边界：恰2处省略号不拦", "第一...第二...", {"kind": "chitchat"}, True, None),
+    ("边界：5个括号不触发密度（需>=6）", "（一）（二）（三）（四）（五）个要点总结",
+     {"kind": "chitchat"}, True, None),
+]
+
+refusals = []  # 拒绝案例留痕
+for name, reply, meta, want_ok, key in CASES:
+    ok, checks = verify_answer(reply, meta)
+    detail = "；".join(checks)
+    if want_ok:
+        check(f"{name} → ok=True", ok is True, detail)
+    else:
+        hit = (key in detail) if key else True
+        check(f"{name} → ok=False 且命中「{key}」", (ok is False) and hit, detail)
+        if ok is False:
+            refusals.append({"case": name, "reply": reply[:40], "checks": checks})
+
+# L1 检测函数直接断言（矛盾句式 / 真相标记特征源）
+check("detect_card_format 矛盾句式特征名", detect_card_format(
+    "这是『A』vs『B』的矛盾——说明") == "矛盾句式")
+check("detect_card_format 正常人话返回 None", detect_card_format("正常的一句话回答。") is None)
+check("LEGITIMATE_KINDS 出口类别表非空", len(LEGITIMATE_KINDS) >= 10,
+      f"{len(LEGITIMATE_KINDS)} 类")
+
+# ------------------------------------------------------------------
+# [2] chat_engine 出口强制闸接线静态断言
+# ------------------------------------------------------------------
+print("\n[2] chat_engine 出口强制闸接线（静态断言，不拉起全家桶）\n")
+eng = open(os.path.join(_WISDOM, "chat_engine.py"), encoding="utf-8").read()
+check("接线：chat_engine 内 import verify_answer", "from verify_answer import verify_answer" in eng)
+check("接线：失败替换为诚实声明（拒绝输出内部格式）", "未能通过白箱回答验证" in eng)
+check("接线：失败处置记录 stderr 留痕", "[verify_answer] 拒绝输出内部格式" in eng)
+spec = open(os.path.join(_WISDOM, "answer_spec_anchor.py"), encoding="utf-8").read()
+check("规范锚点源：answer_spec_anchor 声明三层校验纪律",
+      "verify_answer" in spec and "immutable" in spec)
+
+# ------------------------------------------------------------------
+# [3] 拒绝案例留痕汇总（可复放）+ 规范锚点自指案例
+# ------------------------------------------------------------------
+print(f"\n[3] 拒绝案例留痕（{len(refusals)} 条，全部拦截成功）")
+for i, r in enumerate(refusals, 1):
+    fails = "；".join(c for c in r["checks"] if c.startswith("✗"))
+    print(f"  {i:>2}. {r['case']}  →  {fails}")
+
+# 自指案例：规范锚点警告的泄漏形态（『A』vs『B』矛盾句式）被校验精准拦截
+leak_demo = "自律是『即时奖励』vs『延迟满足』的矛盾——这是内部格式的样子。"
+ok, checks = verify_answer(leak_demo, {"kind": "knowledge", "hits": [{"name": "卡"}]})
+check("自指：规范锚点所述泄漏形态被校验拦截", ok is False,
+      "；".join(c for c in checks if c.startswith("✗")))
+
+# ------------------------------------------------------------------
+print("\n" + "=" * 60)
+print(f"verify_answer 专项测试：{PASS} 通过 / {FAIL} 失败"
+      f"（拒绝案例留痕 {len(refusals)} 条）")
+sys.exit(0 if FAIL == 0 else 1)