@furongjun1999/dsh-memory 0.6.0 → 0.6.1

package/md_cg/test_p29_session_ingest_export.py

@@ -230,12 +230,12 @@ def main():
         _devs = [e["t"] for e in sources.DSHSessionSource(sess).events()]
         check("源适配层：DSH 13 位毫秒 time 归一为 epoch 秒",
               bool(_devs) and all(1e9 < t < 1e10 for t in _devs), str(_devs))
-        _tw_flat = [x for e in cg.index["nodes"].values()
+        _tw_flat = [x for e in list(cg.index["nodes"].values())
                     if isinstance(e.get("time_window"), (list, tuple))
                     for x in e["time_window"]]
         check("端到端：摄取节点落库 time_window 无 13 位毫秒外溢（旧症状已消失）",
               bool(_tw_flat)
-              and all(0 <= x < sources.trust._MS_EPOCH_THRESHOLD for x in _tw_flat),
+              and all(0 <= x < sources.trust._MS_EPOCH_THRESHOLD for x in list(_tw_flat)),
               str(sorted(set(_tw_flat))[:6]))
 
         d1 = call_tool(cg, "cg", {"op": "ingest", "action": "dir",

package/md_cg/test_p2_mcp.py

@@ -257,7 +257,18 @@ def main():
 
         # 11. 基元暴露面（kernel）：默认只暴露 cg / stg 两个认知基元
         print("\n【11】基元暴露面（kernel 默认）")
-        kc = McpClient(root, actor="kernel", extra_env={"MDCG_MCP_SURFACE": "kernel"})
+        # 迁移（issue #43，2026-09-29）：未设 MDCG_POLICY_FILE 时不再等于「无规则
+        # 可判」——修后回落到**包内默认** data/policy.json，下方「未验证的写入」
+        # 因此由 DEFER 变 REJECT。本断言考的是 **review_queue 通路**（非 ACCEPT/
+        # REJECT 出口）仍可达且不落盘，与策略来源无关，故显式给一份**空规则库**
+        # 保持原口径；「默认安装的真实行为（REJECT）」由
+        # md_cg/test_issue43_default_policy.py 钉住。
+        _empty_pol = os.path.join(root, "policy_empty.json")
+        with open(_empty_pol, "w", encoding="utf-8") as f:
+            json.dump({"forbidden": [], "required": []}, f)
+        kc = McpClient(root, actor="kernel",
+                       extra_env={"MDCG_MCP_SURFACE": "kernel",
+                                  "MDCG_POLICY_FILE": _empty_pol})
         try:
             kc.send("initialize", {"protocolVersion": "2024-11-05", "capabilities": {},
                                    "clientInfo": {"name": "k", "version": "0"}})

package/md_cg/test_p30_maintain.py

@@ -7,6 +7,7 @@
   ③ maintain.importance：dry-run 报表 → apply → 留痕 → rollback 复原
   ④ maintain.longterm：dry-run → 断面落盘 → 幂等 → list/show
   ⑤ maintain.prefeed：预演不写 → write 时 ACCEPT 新增 / MERGE 并入不新增
+     （2026-09-30 补强：MERGE 落点的新正文聚合去向 + 新写入方归属并列落 fm）
   ⑥ maintain.separate：相似而条件不同 → 候选 → apply 写对称边 → 幂等
   ⑦ consolidate.promote：dry-run 分流 → 迁移 → 追溯 → 回滚
   ⑧ 权限分档：写层可 stat/prefeed、不可 importance/separate/rollback
@@ -18,6 +19,7 @@
 """
 from __future__ import annotations
 
+import json
 import os
 import shutil
 import sys
@@ -39,11 +41,13 @@ SEP_B = ("# 功能名：连接池选择\n# 生效条件：多租户在线服务\
          "# 不适用条件：嵌入式设备\n")
 PROMO_HOT = ("# 功能名：重试退避策略\n# 生效条件：网络抖动且请求幂等\n"
              "# 子功能：在瞬时故障下限制重试次数\n# 执行：指数退避重试至多三次\n"
+             "# 验证方式：编译器/静态检查通过\n"
              "# 不适用条件：非幂等写操作\n")
 PROMO_COLD = ("# 功能名：日志轮转策略\n# 生效条件：磁盘占用超过阈值\n"
               "# 子功能：按大小切分历史日志\n# 执行：达到上限即滚动归档\n"
+              "# 验证方式：编译器/静态检查通过\n"
               "# 不适用条件：只读挂载卷\n")
-# 反复命中但四要素不全（缺「不适用条件」）
+# 反复命中但六要素不全（缺「不适用条件」+「验证方式」）
 PROMO_BAD = ("# 功能名：缓存穿透保护\n# 生效条件：高频查询未命中\n"
              "# 子功能：用空值占位挡住穿透\n# 执行：写空对象并设短 TTL\n")
 NOVEL = ("# 观察：本机固定使用 Windows 与 cmd\n# 生效条件：本机开发环境\n"
@@ -201,6 +205,33 @@ def main():
               p2.get("decision") == "reinforce" and bool(p2.get("reinforced")),
               f"decision={p2.get('decision')}")
         check("MERGE 后节点数不变", len(cg.index["nodes"]) == n1)
+        # 2026-09-30 补强：prefeed(write=True) 的 MERGE 落点接线——mdcos.py:2891
+        # 调 forgetting.reinforce 时传 `content=content, session=_writer_session(self)`。
+        # 复核员实测抽掉该接线后各守卫静默全绿（此前无断言覆盖）。断言打在
+        # 可观察结果上：新正文按聚合口径进目标正文 + 新写入方归属并列落目标 fm。
+        _prev_sess = getattr(cg, "session", None)
+        cg.session = "sess_p30"
+        NOVEL2 = NOVEL.replace("cmd.exe", "cmd.exe/powershell")
+        p3 = call_tool(cg, "cg", {"op": "maintain", "action": "prefeed",
+                                  "content": NOVEL2, "layer": "contextual",
+                                  "write": True})
+        rein3 = p3.get("reinforced") or {}
+        tgt3 = rein3.get("node_id")
+        full3 = (cg.get(tgt3) or {}) if tgt3 else {}
+        sink3 = rein3.get("content_sink") or {}
+        check("prefeed 落点①：近重复判 MERGE，新正文按聚合口径进目标正文",
+              p3.get("decision") == "reinforce" and bool(tgt3)
+              and "powershell" in (full3.get("content") or "")
+              and sink3.get("action") == "appended"
+              and "powershell" in (sink3.get("line") or ""),
+              f"decision={p3.get('decision')} sink={sink3}")
+        srcs3 = [(x.get("session"), x.get("actor")) for x in
+                 ((full3.get("frontmatter") or {}).get("merge_sources") or [])]
+        check("prefeed 落点②：新写入方 session/actor 归属并列落目标 fm",
+              bool(srcs3) and srcs3[-1] == ("sess_p30", "p30"),
+              json.dumps((full3.get("frontmatter") or {}).get("merge_sources"),
+                         ensure_ascii=False))
+        cg.session = _prev_sess
 
         # ---------------------------------------------- ⑥ separate
         print("\n【6】maintain.separate：候选 → 对称边 → 幂等")
@@ -242,7 +273,7 @@ def main():
         r1 = call_tool(cg, "cg", {"op": "consolidate", "action": "promote"})
         check("dry-run 未写盘", r1.get("dry_run") and r1.get("written") == 0)
         check("命中热节点", r1.get("targeted", 0) >= 1, f"targeted={r1.get('targeted')}")
-        check("剔除四要素不全", r1.get("skipped_incomplete", 0) >= 1)
+        check("剔除六要素不全", r1.get("skipped_incomplete", 0) >= 1)
         check("剔除不热节点", r1.get("skipped_not_hot", 0) >= 1)
         r2 = call_tool(cg, "cg", {"op": "consolidate", "action": "promote",
                                   "apply": True})

package/md_cg/test_p31_insight.py

@@ -80,6 +80,7 @@ REC_B = ("# 功能名：压缩前先落盘检查点乙\n# 生效条件：%s\n"
 # ---- 盲区学习夹具 ---------------------------------------------------------
 LEARN_KB = ("# 功能名：离线缓存决策知识\n# 生效条件：单机离线环境\n"
             "# 子功能：提供离线时的缓存选型判据\n# 执行：比对候选实现并给出结论\n"
+            "# 验证方式：编译器/静态检查通过\n"
             "# 不适用条件：需要强一致分布式场景\n")
 LEARN_ANCHOR = ("# 功能名：离线缓存锚点条目 zkv7\n# 生效条件：单机离线环境\n"
                 "# 子功能：作为离线缓存话题的检索入口 zkv7\n"

package/md_cg/test_p9c_dedup_hints.py

@@ -0,0 +1,276 @@
+# -*- coding: utf-8 -*-
+"""md_cg · P-9b 去重可见性守卫：直写 dup_of 提示 + gated 路径两处静默洞
+
+背景（探针实测，2026-09-30）
+---------------------------
+① **直写**（`mdcg_remember(gated=false)` 与 `cg(op=write, gated=false)` 的链尾
+   执行器）此前返回体**只有 id**——「同内容以异 id 再写一次」在盘面上变两个
+   节点，而调用方拿不到任何提示（`add` 只回 id 字符串）。
+   这是**文档化现状**（`writelimit.py` 模块头注 :9-12：限流/同构聚合只作用
+   contextual 层，knowledge 等手动纪律写入不受限）⇒ **不许改写入语义**。
+② gated 路径（默认路径）有两处**静默洞**：
+   (a) 同 id 覆写：`redundancy(exclude=node_id)` 自排除 ⇒ 该层只此一节点时
+       `compared=0`、`duplicate_with=None`、`duplicate_ratio=0.0`——「覆写」与
+       「全新写入」在裁决里完全不可区分（审计面全 null）；
+   (b) `importance≥PROTECT_IMPORTANCE(0.7)` 的「保护优先」分支**排在冗余判定
+       之前** ⇒ 高重要度内容的重复写直接 ACCEPT，绕过 MERGE/DROP（实测：dup=1.0
+       且节点数 +1），审计面只剩一句「触发不可遗忘保护」。
+
+本批处置（依据见 `forgetting.assess` 的 docstring 与 `md_cg/mcp_server.py` 的
+分支注释）：**只补可见性读数，不动任何落盘行为与 verdict**——
+   · 直写：返回体附 `dup_of`/`dup_ratio`/`dup_compared`/`dup_hint` +
+     `overwrite_of`/`overwrite_ratio`；
+   · gated (a)：`gate.entropy.overwrite_of`/`overwrite_ratio` 非 null；
+   · gated (b)：该分支返回 `gate.dedup_skipped`（reason=protect_importance +
+     去重判据读数），reason 文案显式写出「因保护优先未走去重」。
+
+为何 (b) 选「标注」而不是「把 PROTECT 挪到冗余判定之后」：挪位会削弱
+「不可遗忘保护」（高重要度内容将可被 DROP/并入他节点），与 PROTECT_IMPORTANCE
+及 `writelimit.py` 头注的跨模块「保护优先」口径分叉，且 DROP 不可逆——缺陷本体
+是「静默」而非「保护」，标注即可消除且零回归面。本测 ⑤ **钉住这个决定**：
+高重要度近重复的 verdict 必须仍是 ACCEPT（若被挪位 ⇒ 变 MERGE ⇒ 立刻红）。
+
+判据来源：现成字段 `gate.entropy.duplicate_with/.duplicate_ratio/.compared` 与
+`gate.redundancy.with/.max`（不新增重复度算法；新增读数复用 `forgetting` 的
+同一实现 redundancy / prior_node / self_coverage）。
+
+运行：python -m md_cg.test_p9c_dedup_hints
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import tempfile
+import traceback
+
+from . import forgetting, writepipe
+from .mdcos import MdCGOS, MdCGSecure
+from .security import Principal
+
+PASS = 0
+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 ccg(title, body):
+    return (f"# 功能名：{title}\n# 生效条件：任意情境\n# 子功能：验收\n"
+            f"# 执行：直接调用\n# 验证方式：test\n# 不适用条件：无\n{body}\n")
+
+
+# 直写路径 A（mdcg_remember gated=false）用：无策略闸，正文无需 PASSED
+BODY = ccg("编译缓存清理", "清理编译缓存目录释放磁盘空间，超过 2GB 时按 mtime 删除最旧分片")
+# 直写路径 B（cg(op=write)）用：必须过 audit 闸（策略 required 含 PASSED）
+BODY_PASSED = ccg("编译缓存清理", "PASSED 清理编译缓存目录释放磁盘空间，超过 2GB 时删除最旧分片")
+
+
+def _mk_secure(root):
+    p = Principal(tenant="default", actor="t_designer", role="designer",
+                  can_write=True, can_admin=True)
+    return MdCGSecure(root, principal=p)
+
+
+def _policy(tmp, required=("PASSED",), forbidden=()):
+    path = os.path.join(tmp, "policy_p9c.json")
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump({"forbidden": list(forbidden), "required": list(required)}, f)
+    return path
+
+
+def _run(tmp):
+    from . import mcp_server
+
+    # ============ A. 直写路径：mdcg_remember(gated=false) ============
+    print("\n[A] 直写路径 A（mdcg_remember gated=false）：同内容异 id 的提示")
+    cg = _mk_secure(os.path.join(tmp, "a"))
+    cg.add("k_base", BODY, layer="knowledge", importance=0.5)
+    n_before = len(cg.index["nodes"])
+    res = mcp_server._dispatch(cg, "mdcg_remember",
+                               {"content": BODY, "node_id": "k_dup",
+                                "gated": False, "layer": "knowledge",
+                                "content_kind": "text"})
+    check("A1 直写仍成功落盘（不改写入语义）",
+          res.get("ok") is True and cg.get("k_dup") is not None, repr(res)[:160])
+    check("A2 盘面仍新增节点（去重语义未被改动）",
+          len(cg.index["nodes"]) == n_before + 1,
+          f"{n_before} -> {len(cg.index['nodes'])}")
+    check("A3 返回体带 dup_of 指向已存在节点（修复面）",
+          res.get("dup_of") == "k_base", repr(res)[:200])
+    check("A4 dup_ratio 为现成重复度读数（≥ DUP_MERGE）",
+          isinstance(res.get("dup_ratio"), float)
+          and res["dup_ratio"] >= forgetting.DUP_MERGE, repr(res.get("dup_ratio")))
+    check("A5 dup_hint 如实说明「直写不去重」的文档化现状",
+          isinstance(res.get("dup_hint"), str) and "直写" in res["dup_hint"]
+          and "writelimit" in res["dup_hint"], repr(res.get("dup_hint"))[:160])
+
+    # 无重复内容：不得凭空报 dup（判据要有判别力）
+    res2 = mcp_server._dispatch(cg, "mdcg_remember",
+                                {"content": ccg("奇点事故复盘", "首次观测到未知内存泄漏，与既有记忆无重叠"),
+                                 "node_id": "k_fresh", "gated": False,
+                                 "layer": "knowledge", "content_kind": "text"})
+    check("A6 无重复时不报 dup_of（避免假提示）",
+          res2.get("ok") is True and "dup_of" not in res2, repr(res2)[:160])
+
+    # 同 id 覆写：overwrite_of / overwrite_ratio
+    res3 = mcp_server._dispatch(cg, "mdcg_remember",
+                                {"content": BODY, "node_id": "k_base",
+                                 "gated": False, "layer": "knowledge",
+                                 "content_kind": "text"})
+    check("A7 同 id 覆写回 overwrite_of（原本无从区分覆写与新建）",
+          res3.get("overwrite_of") == "k_base", repr(res3)[:200])
+    check("A8 同 id 同内容覆写：overwrite_ratio ≈ 1.0（空写可见）",
+          res3.get("overwrite_ratio") == 1.0, repr(res3.get("overwrite_ratio")))
+    res4 = mcp_server._dispatch(cg, "mdcg_remember",
+                                {"content": ccg("编译缓存清理", "清理编译缓存目录释放磁盘空间，超过 8GB 时按 mtime 删除最旧分片"),
+                                 "node_id": "k_base", "gated": False,
+                                 "layer": "knowledge", "content_kind": "text"})
+    check("A9 同 id 改内容覆写：overwrite_ratio < 1.0（真改可见）",
+          isinstance(res4.get("overwrite_ratio"), float)
+          and res4["overwrite_ratio"] < 1.0, repr(res4.get("overwrite_ratio")))
+
+    # ============ B. 直写路径：cg(op=write) 链尾执行器 ============
+    print("\n[B] 直写路径 B（cg(op=write, gated=false) 链尾执行器）")
+    old_policy = os.environ.get("MDCG_POLICY_FILE")
+    os.environ["MDCG_POLICY_FILE"] = _policy(tmp)
+    try:
+        pipe = writepipe.install_default_gates(writepipe.WritePipeline())
+        cgb = _mk_secure(os.path.join(tmp, "b"))
+        cgb.add("w_base", BODY_PASSED, layer="knowledge", importance=0.5)
+        out = pipe.execute(cgb, {"content_kind": "text", "content": BODY_PASSED,
+                                 "gated": False, "layer": "knowledge"})
+        check("B1 直写经链：committed + verdict 不变",
+              out.get("committed") is True and out.get("verdict") is not None,
+              repr(out)[:200])
+        check("B2 经链直写也带 dup_of（第二处落盘点同样接线上）",
+              out.get("dup_of") == "w_base", repr(out)[:200])
+        check("B3 经链直写 dup_ratio 读数存在",
+              isinstance(out.get("dup_ratio"), float)
+              and out["dup_ratio"] >= forgetting.DUP_MERGE, repr(out.get("dup_ratio")))
+        out2 = pipe.execute(cgb, {"content_kind": "text",
+                                  "content": BODY_PASSED, "gated": False,
+                                  "node_id": "w_base", "layer": "knowledge"})
+        check("B4 经链直写覆写读数存在",
+              out2.get("overwrite_of") == "w_base"
+              and out2.get("overwrite_ratio") == 1.0, repr(out2)[:200])
+        # 无重复不报 dup
+        fresh = ccg("奇点事故复盘二", "PASSED 首次观测到未知泄漏，与既有记忆无重叠")
+        out3 = pipe.execute(cgb, {"content_kind": "text", "content": fresh,
+                                  "gated": False, "layer": "knowledge"})
+        check("B5 经链直写无重复时不报 dup_of",
+              out3.get("committed") is True and "dup_of" not in out3,
+              repr(out3)[:160])
+    finally:
+        if old_policy is None:
+            os.environ.pop("MDCG_POLICY_FILE", None)
+        else:
+            os.environ["MDCG_POLICY_FILE"] = old_policy
+
+    # ============ C. gated 洞 (a)：同 id 覆写的裁决不再全 null ============
+    print("\n[C] gated (a)：同 id 覆写 → entropy.overwrite_of（不再静默全 null）")
+    cg3 = MdCGOS(os.path.join(tmp, "c"))
+    cg3.add("k_ov", BODY, layer="knowledge", importance=0.5)
+    r = cg3.remember_gated("k_ov", BODY, layer="knowledge", role="user")
+    ent = r["gate"]["entropy"]
+    check("C1 覆写情形 entropy.overwrite_of 指向既有 id",
+          ent.get("overwrite_of") == "k_ov", repr(ent)[:220])
+    check("C2 覆写情形 overwrite_ratio 有值（1.0＝逐字同构的重写）",
+          ent.get("overwrite_ratio") == 1.0, repr(ent.get("overwrite_ratio")))
+    check("C3 并未改动去重判据本身：自排除仍在（duplicate_with 依旧 None、compared 0）",
+          ent.get("duplicate_with") is None and ent.get("compared") == 0,
+          repr({k: ent.get(k) for k in ("duplicate_with", "compared")}))
+    check("C4 verdict 不变（覆写语义未动）", r["verdict"] == "ACCEPT",
+          f"{r['verdict']} · {r['gate']['reason']}")
+    check("C5 同 id 异内容覆写：overwrite_ratio < 1.0",
+          forgetting.assess(cg3, BODY.replace("2GB", "8GB"), layer="knowledge",
+                            role="user", node_id="k_ov")["entropy"]["overwrite_ratio"] < 1.0,
+          str(forgetting.assess(cg3, BODY.replace("2GB", "8GB"), layer="knowledge",
+                                role="user", node_id="k_ov")["entropy"]["overwrite_ratio"]))
+
+    # ============ D. gated 洞 (b)：保护优先不静默 ============
+    print("\n[D] gated (b)：importance≥0.7 的近重复 → dedup_skipped 标注")
+    cg4 = MdCGOS(os.path.join(tmp, "d"))
+    cg4.add("c_dup", BODY, layer="contextual", importance=0.5)
+    n_before = len(cg4.index["nodes"])
+    r2 = cg4.remember_gated("c_new", BODY, layer="contextual", role="user",
+                            importance_hint=0.9)
+    g = r2["gate"]
+    dk = g.get("dedup_skipped")
+    check("D1 保护优先分支**仍** ACCEPT（保护语义不变——未被挪到冗余判定之后）",
+          r2["verdict"] == "ACCEPT", f"{r2['verdict']} · {g['reason']}")
+    check("D2 该分支不再静默：dedup_skipped 存在且 reason=protect_importance",
+          isinstance(dk, dict) and dk.get("reason") == "protect_importance",
+          repr(dk)[:220])
+    check("D3 标注带现成去重读数（duplicate_with 指向既有节点）",
+          isinstance(dk, dict) and dk.get("duplicate_with") == "c_dup"
+          and dk.get("duplicate_ratio", 0) >= forgetting.DUP_MERGE,
+          repr(dk)[:220])
+    check("D4 reason 文案显式写出「因保护优先未走去重」",
+          "保护优先" in g["reason"] and "未走去重" in g["reason"], g["reason"])
+    check("D5 落盘行为不变：仍新建节点（保护优先本就不并入）",
+          len(cg4.index["nodes"]) == n_before + 1,
+          f"{n_before} -> {len(cg4.index['nodes'])}")
+
+    # 保护优先 + 无近重复：仍标注（结构不变量），但如实说「无近重复」
+    r3 = cg4.remember_gated("c_fresh", ccg("奇点事故复盘三", "PASSED 首次观测到未知泄漏，与既有记忆无重叠"),
+                            layer="contextual", role="user", importance_hint=0.9)
+    dk3 = r3["gate"].get("dedup_skipped")
+    check("D6 保护优先 + 无近重复：仍带 dedup_skipped 且 duplicate_with 为 None",
+          isinstance(dk3, dict) and dk3.get("duplicate_with") is None,
+          repr(dk3)[:220])
+
+    # ============ E. 结构不变量：dedup_skipped 只在 PROTECT 分支出现 ============
+    print("\n[E] 结构不变量：dedup_skipped 仅 PROTECT 分支（不多不少）")
+    cg5 = MdCGOS(os.path.join(tmp, "e"))
+    cg5.add("p_dup", BODY, layer="contextual", importance=0.5)
+    cases = [
+        ("保护优先（0.9）+ 近重复", BODY, 0.9, True),
+        ("保护优先（0.7 边界）+ 全新", ccg("边界探针", "PASSED 全新的边界用例内容"), 0.7, True),
+        ("非保护（0.6）+ 近重复", BODY, 0.6, False),
+        ("非保护（0.1）+ 近重复", BODY, 0.1, False),
+    ]
+    for name, content, hint, expect in cases:
+        g5 = forgetting.assess(cg5, content, layer="contextual", role="user",
+                               importance_hint=hint, node_id=None)
+        got = g5.get("dedup_skipped") is not None
+        check(f"E · {name}", got is expect,
+              f"dedup_skipped={'有' if got else '无'}（期望 {'有' if expect else '无'}）"
+              f" · verdict={g5['verdict']}")
+    check("E · entropy 恒带 overwrite_of 键（无覆写时为 None，不新增缺键）",
+          "overwrite_of" in g5["entropy"] and g5["entropy"]["overwrite_of"] is None,
+          str(g5["entropy"].get("overwrite_of")))
+    check("E · prior_node 单点：空 id / 不存在 id 一律 None",
+          forgetting.prior_node(cg5, None) is None
+          and forgetting.prior_node(cg5, "") is None
+          and forgetting.prior_node(cg5, "不存在的_id") is None
+          and forgetting.prior_node(cg5, "p_dup") == "p_dup")
+
+
+def main():
+    tmp = tempfile.mkdtemp(prefix="mdcg_p9c_")
+    try:
+        _run(tmp)
+    except Exception:
+        traceback.print_exc()
+        globals()["FAIL"] += 1
+        FAILS.append("未捕获异常")
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+    print(f"\n==== P9c 结果：{PASS} 通过 / {FAIL} 失败 ====")
+    if FAILS:
+        print("失败项：" + "、".join(FAILS))
+    return 1 if FAIL else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())