@furongjun1999/dsh-memory 0.4.11 → 0.5.1

package/md_cg/test_verify_answer.py

@@ -1,138 +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)
+# -*- 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)

package/md_cg/test_verify_dirty_reconcile.py

@@ -0,0 +1,157 @@
+# -*- coding: utf-8 -*-
+"""verify() 直写分支索引对账守卫（缺陷：confirmed/weakened 直写盘后不置 _dirty）。
+
+缺陷形态（缺陷报告 2026-09-25 复现证实，medium）：verify() 的
+confirmed/weakened 直写分支（mdcg.py:3166-3170）`_write_node` 落盘后只原地改
+index 条目 `evidence_count`，不置 `self._dirty[node_id]`。当节点已在目标验证态
+（verified→verified / doubted→doubted）时，尾部 set_verification 走 stamp
+noop 提前返回（trust.py:192-193 / 695-696，不写盘、不调 _sync_index）——
+本次写盘对索引增量日志（_dirty → flush → _index_log 重放）完全不可见：
+
+  ① 重开后索引 evidence_count 与盘面漂移（forgetting.py:358、
+     scrub.py:181/582/716、metacognition.py:176/193 均按索引条目
+     evidence_count 决策）——计数对账只对账 .md 数量（compact_index
+     :1003），内容级改写不触发重扫；
+  ② readcache 代际（_DirtyDict.write_gen）不推进 → 同实例 _read 命中旧
+     frontmatter（缓存视图 vs 盘上真值不一致）。
+
+复现形态（与缺陷报告一致的三段会话）：S1 预置验证态并 close 落快照 →
+S2 noop 形态 verify（已在目标验证态）→ S3 重开对账索引与盘面。
+
+修复：直写分支落盘并原地更新条目后显式 `self._dirty[node_id] = e`
+（与 mdcg.py 边域同步 :1664 / goal 状态 :1902 同款口径）。
+
+红项 = V3-V6（代际推进 / 标脏 / 缓存视图 / 重开对账）；V1/V2 锁语义不变
+（noop 幂等、返回载荷形态不变）。
+运行：python -m md_cg.test_verify_dirty_reconcile
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import sys
+import tempfile
+
+from .mdcos import MdCGOS
+
+PASS = FAIL = 0
+FAILS = []
+
+
+def ok(cond, label):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  OK   {label}")
+    else:
+        FAIL += 1
+        FAILS.append(label)
+        print(f"  FAIL {label}")
+
+
+def _disk_fm(root, nid):
+    """盘上真值直读（新实例首触 = 磁盘当前内容）。"""
+    cg = MdCGOS(root)
+    e = (cg.index.get("nodes") or {}).get(nid)
+    if not e:
+        return None, None
+    fn = getattr(cg, "_read_uncached", None) or cg._read
+    fm, content = fn(e)
+    cg.close()
+    return fm, content
+
+
+def _noop_session(root, nid, verdict, label, want_conf):
+    """S2：节点已在目标验证态 → verify 的 set_verification 为 noop 直写分支。"""
+    cg = MdCGOS(root)
+    entry = cg.index["nodes"][nid]
+    cg._read(entry)                         # 检索装载缓存（生产形态）
+    g0 = cg._dirty.write_gen
+
+    r = cg.verify(nid, f"{label}的外部证据", verdict)
+    ok(r["action"] == verdict,
+       f"{label}1 verify 返回 action={verdict}")
+    ok(r["verification"].get("code") == "noop"
+       and r["verification"].get("changed") is False,
+       f"{label}2 已在目标验证态 → 幂等 noop（语义不变，不写验证态）")
+
+    ok(cg._dirty.write_gen > g0,
+       f"{label}3 写代际推进（write_gen {g0}→{cg._dirty.write_gen}）")
+    ok(nid in cg._dirty,
+       f"{label}4 直写分支已标脏（_dirty 含 {nid} → flush 落增量日志）")
+    fm_cached, _ = cg._read(entry)          # 缓存视图
+    ok(fm_cached.get("evidence_count") == 1,
+       f"{label}5 同实例缓存视图不陈旧（evidence_count="
+       f"{fm_cached.get('evidence_count')}，应 1）")
+    cg.close()
+
+    # S3：重开对账——索引条目与盘面一致
+    cg2 = MdCGOS(root)
+    idx = (cg2.index.get("nodes") or {}).get(nid) or {}
+    fm_disk, _ = _disk_fm(root, nid)
+    ok(idx.get("evidence_count") == 1 and fm_disk.get("evidence_count") == 1,
+       f"{label}6 重开后索引与盘面对账一致（索引 {idx.get('evidence_count')}"
+       f" / 盘面 {fm_disk.get('evidence_count')}，应均为 1）")
+    ok(fm_disk.get("confidence") == want_conf,
+       f"{label}7 盘面置信度正确（{want_conf}）")
+    cg2.close()
+
+
+def _confirmed_shape(tmp):
+    """confirmed 复现（缺陷报告原样：先 set_verification(verified) 再 noop verify）。"""
+    root = os.path.join(tmp, "cf")
+    os.makedirs(root)
+    # S1：预置验证态并 close 落快照（此后 noop 会话走 compact 而非 rebuild）
+    cg1 = MdCGOS(root)
+    cg1.add("n1", "# 功能名：对账守卫\n\n正文。\n", layer="knowledge")
+    cg1.flush()
+    r0 = cg1.set_verification("n1", "verified", reason="守卫预置",
+                              actor="guard")
+    ok(r0.get("ok") and r0.get("changed"),
+       "cf0 S1 预置 verified（unverified→verified 非 noop）")
+    cg1.close()
+    _noop_session(root, "n1", "confirmed", "cf", 0.65)
+    fm, _ = _disk_fm(root, "n1")
+    ok(fm.get("verification_state") == "verified",
+       "cf8 盘面验证态保持 verified（noop 未改态）")
+
+
+def _weakened_shape(tmp):
+    """weakened 复现：doubted→doubted 同为 noop 直写分支（置信度不触降级）。"""
+    root = os.path.join(tmp, "wk")
+    os.makedirs(root)
+    cg1 = MdCGOS(root)
+    cg1.add("n2", "# 功能名：对账守卫二\n\n正文。\n", layer="knowledge",
+            confidence=0.9)
+    cg1.flush()
+    r0 = cg1.set_verification("n2", "doubted", reason="守卫预置",
+                              actor="guard")
+    ok(r0.get("ok") and r0.get("changed"),
+       "wk0 S1 预置 doubted（unverified→doubted 非 noop）")
+    cg1.close()
+    _noop_session(root, "n2", "weakened", "wk", 0.75)   # 0.9−0.15
+    fm, _ = _disk_fm(root, "n2")
+    ok(fm.get("layer") == "knowledge" and fm.get("verification_state") == "doubted",
+       "wk8 未误降级（0.75 > DEMOTE_CONFIDENCE 0.2）且态保持 doubted")
+
+
+def main():
+    os.environ.pop("MDCG_READ_CACHE", None)
+    tmp = tempfile.mkdtemp(prefix="mdcg_verify_dirty_")
+    try:
+        _confirmed_shape(tmp)
+        _weakened_shape(tmp)
+    finally:
+        os.environ.pop("MDCG_READ_CACHE", None)
+        shutil.rmtree(tmp, ignore_errors=True)
+
+    print("\n" + "=" * 60)
+    print(f"结果：PASS {PASS} / FAIL {FAIL}")
+    if FAILS:
+        for f in FAILS:
+            print(f"  - {f}")
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())