@furongjun1999/dsh-memory 0.4.4 → 0.4.6

package/md_cg/test_p10_identity.py

@@ -0,0 +1,173 @@
+# -*- coding: utf-8 -*-
+"""md_cg · 第 10 篇：身份特征识别（智能论 v3.4 位置效应 + 扮演论三接口）
+
+覆盖：
+  A 位置效应推断（五大单元）
+      记录=全 / 反思=新 / 验证=稳 / 输出=通 / 维生=存 ·
+      多证据投票 · 证据不足→unknown · 平票 tie 提示 · votes/confidence 可审计
+  B 身份锚点（anchor 接口）
+      self→self 层（不可遗忘） · role/user→anchor 层 · 覆盖被拒 · override 放行 ·
+      扮演论边界：role 不得进 self 层
+  C 条件特征（values 接口）
+      structural 层 · 条件空间=触发时机 · 画像汇总
+  D 位置分布 / 自描述
+  E 留痕 / 写保护联动
+
+运行：python -m md_cg.test_p10_identity
+"""
+from __future__ import annotations
+
+import tempfile
+
+from .mdcos import MdCGOS
+from . import identity, protect
+
+PASS = FAIL = 0
+FAILS = []
+
+
+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 blocked(fn):
+    """执行 fn，返回是否被 ProtectionError / ValueError 拦下。"""
+    try:
+        fn()
+        return False
+    except (protect.ProtectionError, ValueError):
+        return True
+
+
+def main():
+    root = tempfile.mkdtemp(prefix="mdcg_p10_")
+    cg = MdCGOS(root)
+
+    # ---------- A. 位置效应推断 ----------
+    print("\n[A] 位置效应推断（智能论 v3.4 §十三 五大单元）")
+
+    cg.identity_observe("agent:rec", "执行了一次抓取命令", node_id="o_rec1",
+                        role="command")
+    cg.identity_observe("agent:rec", "回传工具输出", node_id="o_rec2",
+                        role="tool-output")
+    p = cg.identity_profile("agent:rec")
+    check("记录单元（全）：command/tool-output → record",
+          p["position"] == "record" and p["unit"] == "记录单元",
+          f'{p["position"]}/{p["position_confidence"]}')
+    check("位置携带职责与效应", p["effect"] == "全" and bool(p["duty"]),
+          f'{p["effect"]}/{p["duty"]}')
+    check("votes / evidence_count 可审计",
+          p["votes"].get("record") == 2 and p["evidence_count"] == 2, str(p["votes"]))
+
+    cg.identity_observe("user:alice", "提出了一个需求", node_id="o_out1", role="user")
+    p2 = cg.identity_profile("user:alice")
+    check("输出单元（通）：user 协作表达 → output",
+          p2["position"] == "output" and p2["effect"] == "通",
+          f'{p2["position"]}/{p2["position_confidence"]}')
+
+    cg.identity_observe("role:whale", "发现了遗漏条件", node_id="o_ref1",
+                        tags=["reflect", "遗漏条件"])
+    p3 = cg.identity_profile("role:whale")
+    check("反思单元（新）：发现差异/遗漏条件 → reflect",
+          p3["position"] == "reflect" and p3["effect"] == "新", p3["position"])
+
+    cg.identity_observe("agent:ver", "判断该规则是否有效", node_id="o_ver1",
+                        tags=["verify"])
+    p4 = cg.identity_profile("agent:ver")
+    check("验证单元（稳）：判断有效性 → verify",
+          p4["position"] == "verify" and p4["effect"] == "稳", p4["position"])
+
+    cg.identity_observe("self:lingshu", "维护存在与预算回滚", node_id="o_sus1",
+                        tags=["goal", "budget"])
+    p5 = cg.identity_profile("self:lingshu")
+    check("维生系统（存）：维护存在/预算/回滚 → sustain",
+          p5["position"] == "sustain" and p5["effect"] == "存", p5["position"])
+
+    cg.identity_observe("user:newbie", "只有一条模糊证据", node_id="o_unk1")
+    pu = cg.identity_profile("user:newbie")
+    check("证据不足 → unknown（不假装确定）",
+          pu["position"] == "unknown" and pu["position_confidence"] == 0.0,
+          pu["position"])
+
+    cg.identity_observe("agent:tie", "既执行又验证", node_id="o_tie1",
+                        role="command", tags=["verify"])
+    pt = cg.identity_profile("agent:tie")
+    check("平票时置 tie 提示歧义（不假装唯一）",
+          bool(pt["tie"]) and pt["position"] in ("record", "verify"),
+          f'{pt["position"]}/{pt["tie"]}')
+
+    # ---------- B. 身份锚点 ----------
+    print("\n[B] 身份锚点（anchor 接口 / 扮演论边界）")
+    a1 = cg.identity_anchor("self:lingshu", "我是灵枢：记忆操作系统的自我锚点")
+    check("self 锚点落 self 层（智能体自身）",
+          a1["layer"] == "self" and a1["protected"], str(a1)[:100])
+    check("锚点不可遗忘（protect 判定）",
+          protect.is_protected(cg, a1["node_id"])[0], a1["node_id"])
+    check("锚点覆盖被拒（不可覆盖）",
+          blocked(lambda: cg.identity_anchor("self:lingshu", "试图改写自我锚点")),
+          "ProtectionError")
+
+    a2 = cg.identity_anchor("self:lingshu", "我是灵枢：经确认修订的自我锚点",
+                            override=True)
+    check("override 后锚点可修订", a2["ok"])
+
+    a3 = cg.identity_anchor("role:whale", "我是鲸鱼，负责深潜检索")
+    check("role 锚点落 anchor 层（不占用 self 层）",
+          a3["layer"] == "anchor", a3["layer"])
+    check("扮演论边界：role 不得写入 self 层",
+          blocked(lambda: cg.identity_anchor("role:whale", "伪装成灵枢自身",
+                                             requested_layer="self")),
+          "ValueError")
+
+    # ---------- C. 条件特征 ----------
+    print("\n[C] 条件特征（values 接口：条件空间=触发时机）")
+    t1 = cg.identity_trait("self:lingshu", "遇到权限问题时先查写保护清单",
+                           condition_space={"trigger": "permission_error"})
+    check("特征落结构层（特化价值观）", t1["layer"] == "structural", t1["layer"])
+    check("特征携带条件空间（触发时机）",
+          t1["condition_space"].get("trigger") == "permission_error",
+          str(t1["condition_space"]))
+    prof = cg.identity_profile("self:lingshu")
+    check("画像汇总特征条目", prof["traits_count"] == 1, str(prof["traits_count"]))
+    check("特征保留条件空间",
+          (prof["traits"][0]["condition_space"] or {}).get("trigger")
+          == "permission_error", str(prof["traits"][0])[:120])
+
+    # ---------- D. 分布 / 自描述 ----------
+    print("\n[D] 位置分布 / 自描述")
+    ps = cg.identity_positions()
+    kinds = {s["position"] for s in ps}
+    check("positions 覆盖多主体多位置",
+          len(ps) >= 5 and {"record", "output", "reflect", "verify", "sustain"} <= kinds,
+          str(sorted(kinds)))
+    cat = identity.catalog()
+    check("catalog 五单元齐备", set(cat["positions"]) == set(identity.POSITION_ORDER),
+          str(list(cat["positions"])))
+    check("catalog 三接口齐备（memory/anchor/values）",
+          set(cat["interfaces"]) == {"memory", "anchor", "values"},
+          str(list(cat["interfaces"])))
+
+    # ---------- E. 留痕 / 写保护联动 ----------
+    print("\n[E] 留痕 / 写保护联动")
+    hs = cg.identity_history(limit=50)
+    ops = {r.get("op") for r in hs}
+    check("身份操作留痕可查", {"observe", "anchor", "trait"} <= ops, str(sorted(ops)))
+    check("受保护锚点 forget 被拒",
+          blocked(lambda: cg.forget(a1["node_id"], "测试删除")), "ProtectionError")
+
+    print(f"\n==== P10 结果：{PASS} 通过 / {FAIL} 失败 ====")
+    if FAILS:
+        print("失败项：" + "、".join(FAILS))
+    return FAIL == 0
+
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(0 if main() else 1)

package/md_cg/test_p11_consistency.py

@@ -0,0 +1,233 @@
+# -*- coding: utf-8 -*-
+"""md_cg · 第 11 篇：节点间自动冲突检测（三级决策：情绪 → 反思 → 递归反思）
+
+理论出处（本仓原文）：
+  · 情绪 = 信息差二阶变化 d²D/dt²（`docs/智能的公理化基石.md` §十一）
+    —— L0，独立通道，**不参与信任计算**
+  · 反题 = 预测与事实冲突（同文档 :529，条件论七操作）—— L1 条件级冲突检测
+  · 递归受深度/节点数/循环/信息增益门槛约束（同文档 :273）—— L2 递归反思
+  · 四态路由 ACCEPT/REJECT/DEFER/BLINDSPOT（同文档 :721）
+  · 知识飞轮：误差 → 补条件 → 结构更新（同文档 :725）
+  · 纪律四要素同构（`docs/工作纪律_认知图条目_v1.1.json`）
+
+覆盖：
+  A L0 情绪通道：三态 / 二阶差分 / 不参与信任计算
+  B L1 反思四态：ACCEPT / 自否定 REJECT / 违反纪律 REJECT / 条件互斥 DEFER / BLINDSPOT
+  C L2 递归反思：沿边收敛 / 增益门槛停搜 / 深度上限 / 循环不爆炸
+  D 冲突自动触发飞轮（落 unresolved）
+  E 写入接入：add(consistency) 抛错 / defer 不落盘 / record 放行 / 闸门叠加
+  F 留痕 / 统计 / 自描述 / health 面
+
+运行：python -m md_cg.test_p11_consistency
+"""
+from __future__ import annotations
+
+import tempfile
+
+from .mdcos import MdCGOS
+from . import consistency
+
+PASS = FAIL = 0
+FAILS = []
+
+
+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 main():
+    root = tempfile.mkdtemp(prefix="mdcg_p11_")
+    cg = MdCGOS(root)
+
+    # 既有结构：条件节点 + 纪律节点 + 无条件节点
+    cg.add("k_offline",
+           "# 功能：离线批处理\n# 生效条件：离线环境\n# 不适用条件：生产环境\n",
+           layer="knowledge", tags=["batch"],
+           non_applicable_conditions=["生产环境"], importance=0.4)
+    cg.add("discipline_prod", "# 功能：生产纪律\n# 执行：禁止删除生产数据\n",
+           layer="self", tags=["discipline"],
+           non_applicable_conditions=["删除生产数据"], importance=0.5)
+    cg.add("k_plain", "普通笔记，没有任何条件声明。", layer="knowledge",
+           importance=0.3)
+    cg.add("c_plain", "情景笔记，也没有条件声明。", layer="contextual",
+           importance=0.3)
+
+    # ---------- A. L0 情绪通道 ----------
+    print("\n[A] L0 情绪通道（信息差二阶变化 d²D/dt²，§十一）")
+    em = consistency.emotional_bias(0.1)
+    check("低冲突 → approaching（信息差收敛）",
+          em["bias"] == "approaching", str(em))
+    check("高冲突 → avoiding（信息差扩大）",
+          consistency.emotional_bias(0.9)["bias"] == "avoiding")
+    check("二阶差分：冲突强度上升 → avoiding",
+          consistency.emotional_bias(0.5, 0.2)["bias"] == "avoiding",
+          str(consistency.emotional_bias(0.5, 0.2)))
+    check("二阶差分：冲突强度回落 → 非 avoiding",
+          consistency.emotional_bias(0.5, 0.6)["bias"] != "avoiding")
+    check("情绪通道独立，不参与信任计算（§十一 强制）",
+          "不参与信任" in em["note"], em["note"])
+
+    # ---------- B. L1 反思四态 ----------
+    print("\n[B] L1 反思（反题检测 → 四态路由）")
+    r = cg.check_consistency("这是一条全新的普通记录，与既有结构无关。",
+                             layer="knowledge")
+    check("B1 无冲突 → ACCEPT", r["verdict"] == "ACCEPT", r["reason"])
+
+    r = cg.check_consistency("删除生产数据", layer="self")
+    check("B2 违反纪律 → REJECT（正文命中 negative.reject）",
+          r["verdict"] == "REJECT"
+          and any(c["type"] == "discipline" for c in r["conflicts"]),
+          r["reason"])
+
+    r = cg.check_consistency("# 功能：X\n# 生效条件：删除生产数据\n",
+                             non_applicable_conditions=["删除生产数据"],
+                             layer="knowledge")
+    check("B3 自否定 → REJECT（自己的负条件排除自己的正条件）",
+          r["verdict"] == "REJECT"
+          and any(c["type"] == "self_negation" for c in r["conflicts"]),
+          r["reason"])
+
+    r = cg.check_consistency("# 功能：生产批处理\n# 生效条件：生产环境\n",
+                             layer="knowledge")
+    check("B4 条件互斥 → DEFER（新适用条件落在既有不适用区）",
+          r["verdict"] == "DEFER" and r["conflict_strength"] >= consistency.CLASH_LOW,
+          f'{r["verdict"]}/{r["conflict_strength"]}')
+
+    r = cg.check_consistency("# 功能：某情景\n# 生效条件：某个特殊条件\n",
+                             layer="contextual")
+    check("B5 无可比对条件 → BLINDSPOT（不假装确定）",
+          r["verdict"] == "BLINDSPOT", r["reason"])
+
+    # ---------- C. L2 递归反思 ----------
+    print("\n[C] L2 递归反思（:273 深度/节点/循环/增益门槛）")
+    cg.add("e_conf", "# 功能：冲突源\n# 生效条件：条件A\n", layer="contextual",
+           edges=[{"to": "s_disc"}], importance=0.4, override=True)
+    cg.add("s_disc", "# 功能：区分节点\n", layer="structural",
+           non_applicable_conditions=["生产环境"], importance=0.4)
+    r = cg.check_consistency(
+        "# 功能：待检\n# 生效条件：生产环境\n",
+        non_applicable_conditions=["条件A"], layer="contextual", depth=3)
+    rec = r.get("recursion") or {}
+    check("C1 沿关系边两跳找到区分条件 → resolved",
+          rec.get("stopped_by") == "resolved" and bool(rec.get("resolved_by")),
+          str(rec))
+
+    cg.add("e_conf", "# 功能：冲突源\n# 生效条件：条件A\n", layer="contextual",
+           edges=[], importance=0.4, override=True)
+    r = cg.check_consistency(
+        "# 功能：待检\n# 生效条件：某条件\n",
+        non_applicable_conditions=["条件A"], layer="contextual", depth=3)
+    rec = r.get("recursion") or {}
+    check("C2 增益门槛：候选空间不减少即停搜（:273）",
+          rec.get("stopped_by") in ("gain_below_threshold", "frontier_exhausted"),
+          str(rec))
+
+    cg.add("e_conf", "# 功能：冲突源\n# 生效条件：条件A\n", layer="contextual",
+           edges=[{"to": "s_disc"}], importance=0.4, override=True)
+    r = cg.check_consistency(
+        "# 功能：待检\n# 生效条件：生产环境\n",
+        non_applicable_conditions=["条件A"], layer="contextual", depth=1)
+    rec = r.get("recursion") or {}
+    check("C3 深度上限受约束（depth=1 不越界）",
+          rec.get("depth", 99) <= 1, str(rec))
+
+    cg.add("l1", "# 功能：环1\n# 生效条件：条件A\n", layer="contextual",
+           edges=[{"to": "l2"}], importance=0.4)
+    cg.add("l2", "# 功能：环2\n# 生效条件：条件A\n", layer="contextual",
+           edges=[{"to": "l1"}], importance=0.4)
+    r = cg.check_consistency("# 功能：待检\n",
+                             non_applicable_conditions=["条件A"],
+                             layer="contextual", depth=3)
+    rec = r.get("recursion") or {}
+    check("C4 循环检测：环不导致无限展开",
+          0 < rec.get("nodes_visited", 0) <= consistency.MAX_NODES, str(rec))
+
+    # ---------- D. 冲突自动触发飞轮 ----------
+    print("\n[D] 冲突自动触发飞轮（误差 → 补条件 → 结构更新，:725）")
+    r = cg.check_consistency("# 功能：生产批处理\n# 生效条件：生产环境\n",
+                             layer="knowledge", auto_flywheel=True)
+    check("D1 冲突自动投递飞轮并返回 unresolved_id",
+          bool(r.get("unresolved_id")), str(r.get("unresolved_id")))
+    un = [n for n, e in (cg.index.get("nodes") or {}).items()
+          if e.get("layer") == "unresolved"]
+    check("D2 飞轮落 unresolved 条目", len(un) >= 1, str(un[:3]))
+
+    # ---------- E. 写入接入 ----------
+    print("\n[E] 写入接入（信息的修改必须与已有规则校验）")
+    nid = cg.add("ok_1", "完全无关的一条新记录", layer="knowledge",
+                 consistency=True)
+    fm = (cg.get("ok_1") or {}).get("frontmatter") or {}
+    check("E1 无冲突写入成功且留痕判定",
+          bool(nid) and (fm.get("consistency") or {}).get("verdict") == "ACCEPT",
+          str(fm.get("consistency")))
+
+    try:
+        cg.add("bad_1", "删除生产数据", layer="self", consistency=True)
+        check("E2 违反纪律写入被拒（ConsistencyError）", False, "未抛错")
+    except consistency.ConsistencyError as e:
+        check("E2 违反纪律写入被拒（ConsistencyError）",
+              e.verdict == "REJECT", e.reason)
+
+    out = cg.add("bad_2", "删除生产数据", layer="self", consistency=True,
+                 on_conflict="defer")
+    check("E3 on_conflict=defer 不落盘",
+          out is None and cg.get("bad_2") is None, str(out))
+
+    cg.add("bad_3", "删除生产数据", layer="self", consistency=True,
+           on_conflict="record")
+    fm3 = (cg.get("bad_3") or {}).get("frontmatter") or {}
+    check("E4 on_conflict=record 记录后放行",
+          (fm3.get("consistency") or {}).get("verdict") == "REJECT",
+          str(fm3.get("consistency")))
+
+    cg.remember_gated("g_1", "删除生产数据", layer="self", consistency=True)
+    check("E5 遗忘闸门叠加冲突检测：冲突内容不落盘",
+          cg.get("g_1") is None, str(cg.get("g_1")))
+
+    # ---------- F. 留痕 / 统计 / 自描述 ----------
+    print("\n[F] 留痕 / 统计 / 自描述")
+    vs = {x.get("verdict") for x in cg.consistency_history(limit=200)}
+    check("F1 留痕覆盖四态",
+          {"ACCEPT", "REJECT", "DEFER", "BLINDSPOT"} <= vs, str(sorted(vs)))
+    st = cg.consistency_stats()
+    check("F2 统计按判定/情绪分布",
+          st["records"] > 0 and st["by_verdict"].get("REJECT", 0) > 0,
+          str(st["by_verdict"]))
+    cat = cg.consistency_catalog()
+    check("F3 自描述三级 + 四态",
+          set(cat["levels"]) == {"L0_emotion", "L1_reflect",
+                                 "L2_recursive_reflect"}
+          and cat["levels"]["L1_reflect"]["verdicts"] == list(consistency.VERDICTS),
+          str(list(cat["levels"])))
+    check("F4 自描述标注情绪通道不参与信任",
+          "不参与信任" in cat["levels"]["L0_emotion"]["constraint"])
+    check("F5 诚实边界声明（非语义蕴含证明）",
+          "非语义蕴含" in cat["honest_boundary"], cat["honest_boundary"])
+    hh = cg.health_os()
+    check("F6 health 报告 consistency 面",
+          "consistency" in hh.get("os", {}),
+          str(hh.get("os", {}).get("consistency"))[:90])
+
+    print(f"\n==== P11 结果：{PASS} 通过 / {FAIL} 失败 ====")
+    if FAILS:
+        print("失败项：" + "、".join(FAILS))
+    return FAIL == 0
+
+
+if __name__ == "__main__":
+    import sys
+    # 用 reconfigure 而非「包一层 TextIOWrapper」：后者在 stdout 被重定向到文件时
+    # 会在解释器退出阶段丢缓冲，CI 里会看不到失败原因。
+    # 本用例原先缺这一步：Windows 默认 gbk 控制台下打印「d²D/dt²」的 ²(U+00B2)
+    # 直接 UnicodeEncodeError，崩在**第一条断言之前**，输出只剩 725 字节——
+    # 于是「P11 通过」这件事从未被真正执行过，也从未被任何人看见。
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+    sys.exit(0 if main() else 1)

package/md_cg/test_p12_metacognition.py

@@ -0,0 +1,212 @@
+# -*- coding: utf-8 -*-
+"""md_cg · 第 12 篇：独立元认知（观察自身认知的二阶单元）
+
+理论出处（本仓原文）：
+  · 情绪 = 信息差二阶变化 d²D/dt²（`docs/智能的公理化基石.md` §十一，:412-510）
+  · 情感 = 信任二阶变化 d²T/dt²（同文档 :469-508）
+  · 五大单元：元认知是反思/验证通道的**外部观察者**（同文档 :540-556）
+  · 推论三「局部不可知」：盲区即知识（同文档 :277-288）
+  · 信任 P_trust / P_gap（同文档 :393-408）
+  · 导航税：显式状态记录（`docs/智能的认知过程.md`:84-86）
+
+覆盖：
+  A 轨迹：D(t) / dD/dt / d²D/dt² / 情绪 / 四态分布
+  B 校准：期望 vs 实际 / gap / 分箱 / ECE / 确定性建议
+  C 盲区：BLINDSPOT 邻域聚合 + unresolved 清单
+  D 信任：P_gap / P_trust / 情感（d²T/dt²）
+  E 报告：四观测面 + 建议带证据 + 独立留痕
+  F 闸门：相似历史 → 建议分流 / 无历史 → no_prior
+  G 独立性：不改 frontmatter / 不参与裁决
+  H 留痕 / 自描述 / health 面
+
+运行：python -m md_cg.test_p12_metacognition
+"""
+from __future__ import annotations
+
+import json
+import tempfile
+
+from .mdcos import MdCGOS
+from .mdcg import STATE_ACCEPT, STATE_REJECT, STATE_BLINDSPOT
+from . import metacognition as mc
+
+PASS = FAIL = 0
+FAILS = []
+
+
+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 _r(state):
+    """构造一次检索结果（精确控制信息差 D：ACCEPT→0，其它→1）。"""
+    return [({"id": "x", "frontmatter": {}, "content": "", "path": "x"},
+             1.0, {"state": state})]
+
+
+def main():
+    root = tempfile.mkdtemp(prefix="mdcg_p12_")
+    cg = MdCGOS(root)
+
+    # ---------- A. 轨迹 ----------
+    print("\n[A] 信息差轨迹（D / dD / d²D → 情绪，§十一）")
+    tr0 = cg.metacognition_trace()
+    check("A1 无留痕 → insufficient_data（不编造数值）",
+          tr0["ok"] is False and tr0["reason"] == "insufficient_data", str(tr0))
+
+    cg.reflect("缓存失效策略", _r(STATE_ACCEPT))
+    cg.reflect("缓存失效策略", _r(STATE_ACCEPT))
+    tr = cg.metacognition_trace()
+    check("A2 命中 → D 收敛到 0", tr["d_current"] == 0.0, str(tr["d_current"]))
+    check("A3 四态分布可读", "ACCEPT" in tr["states"], str(tr["states"]))
+
+    cg.reflect("缓存失效策略", _r(STATE_REJECT))
+    cg.reflect("缓存失效策略", _r(STATE_ACCEPT))
+    tr = cg.metacognition_trace()
+    check("A4 二阶差分识别收敛 → approaching",
+          tr["emotion"] == "approaching",
+          f'emotion={tr["emotion"]} d2={tr["d2"]}')
+    check("A5 一阶方向 dD/dt 可算", isinstance(tr["d1"], float), str(tr["d1"]))
+
+    # ---------- B. 校准 ----------
+    print("\n[B] 自信校准（期望正确率 vs 实际验证通过率）")
+    cal0 = cg.metacognition_calibration()
+    check("B1 无证据 → insufficient_data", cal0["ok"] is False, str(cal0))
+
+    for i in range(6):
+        cg.add(f"v{i}", f"# 功能：验证样本 {i}\n", layer="knowledge",
+               importance=0.5)
+        cg.verify(f"v{i}", "实测通过", "confirmed")
+    for i in range(3):
+        cg.verify(f"v{i}", "反例", "weakened")
+
+    cal = cg.metacognition_calibration()
+    check("B2 期望/实际/gap 自洽",
+          cal["ok"] and abs(cal["gap"] - (cal["expected_accuracy"]
+                                          - cal["actual_accuracy"])) < 1e-6,
+          str({k: cal[k] for k in ("expected_accuracy", "actual_accuracy", "gap")}))
+    check("B3 ECE 非负", cal["ece"] >= 0, str(cal["ece"]))
+    check("B4 分箱覆盖已观测区间", len(cal["bins"]) > 0, str(cal["bins"]))
+    check("B5 判定 ∈ 四类",
+          cal["verdict"] in ("calibrated", "overconfident", "underconfident",
+                             "insufficient_data"), cal["verdict"])
+
+    adv = mc._advise(
+        {"ok": True, "d2": 0.0, "emotion": "stable", "state_rates": {}},
+        {"verdict": "overconfident", "expected_accuracy": 0.8,
+         "actual_accuracy": 0.5, "gap": 0.3},
+        {"unresolved_count": 0}, {})
+    check("B6 过度自信 → 建议抽查复核",
+          any(a["code"] == "overconfident" for a in adv), str(adv))
+    adv2 = mc._advise({"ok": False}, {"verdict": "calibrated"},
+                      {"unresolved_count": 0}, {})
+    check("B7 无轨迹 → 提示先积累留痕",
+          any(a["code"] == "no_trace" for a in adv2), str(adv2))
+
+    # ---------- C. 盲区 ----------
+    print("\n[C] 盲区地图（推论三：局部不可知）")
+    cg.reflect("量子纠缠退相干时间", _r(STATE_BLINDSPOT))
+    cg.reflect("量子纠缠退相干时间", _r(STATE_BLINDSPOT))
+    cg.reflect("另一个模糊问题", _r(STATE_BLINDSPOT))
+    bs = cg.metacognition_blindspots()
+    top = bs["items"][0] if bs["items"] else {}
+    check("C1 盲区按邻域聚合", top.get("blindspot", 0) >= 2, str(top))
+    check("C2 返回 unresolved 计数",
+          "unresolved_count" in bs, str(bs["unresolved_count"]))
+
+    # ---------- D. 信任 ----------
+    print("\n[D] 信任（P_gap / P_trust / 情感 d²T/dt²）")
+    tt = cg.metacognition_trust()
+    check("D1 P_gap 可算", tt["p_gap"] is not None, str(tt["p_gap"]))
+    check("D2 P_trust 来自验证留痕", tt["p_trust"] is not None, str(tt["p_trust"]))
+    check("D3 情感取自二阶差分",
+          tt["emotion"] in ("approaching", "avoiding", "stable"), str(tt["emotion"]))
+
+    # ---------- E. 报告 ----------
+    print("\n[E] 元认知报告（四观测面 + 建议）")
+    rep = cg.metacognition_report()
+    check("E1 四观测面齐全",
+          all(k in rep for k in ("trace", "calibration", "blindspots", "trust")),
+          str(list(rep)))
+    check("E2 建议带 why/action（可复核）",
+          bool(rep["advice"]) and all("why" in a and "action" in a
+                                      for a in rep["advice"]),
+          str([a["code"] for a in rep["advice"]]))
+    check("E3 独立性声明", rep["independent"] is True and "不" in rep["note"],
+          rep["note"][:40])
+
+    # ---------- F. 闸门 ----------
+    print("\n[F] 元认知闸门 self_check")
+    sc = cg.self_check("量子纠缠退相干时间")
+    check("F1 相似历史命中 → 建议声明盲区",
+          sc["recommendation"] == "declare_blindspot" and sc["prior_attempts"] >= 2,
+          str({k: sc[k] for k in ("prior_attempts", "recommendation", "warning")}))
+    sc2 = cg.self_check("完全无关的全新问题 xyz")
+    check("F2 无相似历史 → no_prior",
+          sc2["warning"] == "no_prior"
+          and sc2["recommendation"] == "search_then_decide",
+          str(sc2["recommendation"]))
+    check("F3 空查询被拒", cg.self_check("")["ok"] is False)
+
+    # ---------- G. 独立性 ----------
+    print("\n[G] 独立性（不参与裁决）")
+    before = json.dumps(cg.get("v0")["frontmatter"], sort_keys=True,
+                        ensure_ascii=False)
+    cg.metacognition_report()
+    cg.self_check("量子纠缠退相干时间")
+    after = json.dumps(cg.get("v0")["frontmatter"], sort_keys=True,
+                       ensure_ascii=False)
+    check("G1 元认知不改节点 frontmatter", before == after)
+    check("G2 独立性在自描述中声明",
+          any(("不写" in c) or ("不参与" in c) for c in mc.catalog()["constraints"]),
+          str(mc.catalog()["constraints"]))
+
+    # ---------- H. 留痕 / 自描述 ----------
+    print("\n[H] 留痕 / 自描述 / health 面")
+    h = cg.metacognition_history()
+    check("H1 留痕写入 _metacognition.jsonl", h["n"] > 0, str(h["n"]))
+    check("H2 留痕含 report 与 self_check",
+          {"report", "self_check"} <= {r.get("op") for r in h["records"]},
+          str({r.get("op") for r in h["records"]}))
+    cat = cg.metacognition_catalog()
+    check("H3 自描述含四观测面 + 闸门",
+          {"trace", "calibration", "blindspots", "trust", "self_check"}
+          <= set(cat["faces"]), str(cat["faces"]))
+    hh = cg.health_os()
+    check("H4 health 报告 metacognition 面",
+          "metacognition" in hh.get("os", {}),
+          str(hh.get("os", {}).get("metacognition")))
+
+    # MCP 入口冒烟（注册 + 两条 dispatch 路径）
+    from . import mcp_server as ms
+    check("H5 MCP 注册 mdcg_metacognition",
+          any(t["name"] == "mdcg_metacognition" for t in ms.TOOLS))
+    check("H6 cg op=metacognition 路由",
+          ms._cg_call(cg, {"op": "metacognition",
+                           "action": "catalog"}).get("module") == "metacognition")
+    check("H7 mdcg_metacognition dispatch",
+          ms._metacognition_call(cg, {"action": "trust"})["ok"] is True)
+
+    print(f"\n==== P12 结果：{PASS} 通过 / {FAIL} 失败 ====")
+    if FAILS:
+        print("失败项：" + "、".join(FAILS))
+    return FAIL == 0
+
+
+if __name__ == "__main__":
+    import sys
+    # 用 reconfigure 而非「包一层 TextIOWrapper」：后者在 stdout 被重定向到文件时
+    # 会在解释器退出阶段丢缓冲，CI 里会看不到失败原因。
+    # 本用例原先缺这一步：Windows 默认 gbk 控制台下打印「d²D/dt²」的 ²(U+00B2)
+    # 直接 UnicodeEncodeError，崩在**第一条断言之前**，输出只剩 725 字节——
+    # 于是「P12 通过」这件事从未被真正执行过，也从未被任何人看见。
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+    sys.exit(0 if main() else 1)