@furongjun1999/dsh-memory 0.4.6 → 0.4.7

package/md_cg/test_p27_docindex.py

@@ -17,7 +17,8 @@ R2 改造的验收（对照 docs/认知图_索引与工程规范化_计划_v0.1.
   ⑤ §1.3-3 裁定落地：layer 默认 knowledge；密级默认 internal **显式写入**
      frontmatter，路径段命中私有提示再保守降为 private；调用方可显式覆盖。
   ⑥ 真实 docs/：章节可定位（行号与源文件一致），能检索到并按 CCG 判 ACCEPT。
-  ⑦ 不静默：truncated / skipped_suffixes 显式上报；只读契约（源 mtime 不变）；
+  ⑦ 不静默：truncated / skipped_suffixes / skipped_dirs 显式上报；排除为**追加**
+     （只增不减，内置 .git/.venv/node_modules 不可被关闭）；只读契约（源 mtime 不变）；
      幂等（重跑节点数不变）；`index_doc` 进 ALL_OPS 且与工具 schema 一致。
 
 运行：python -m md_cg.test_p27_docindex
@@ -29,9 +30,9 @@ import shutil
 import sys
 import tempfile
 
-from . import corpus, docindex, nodefile, routing, tokens
+from . import codeindex, corpus, docindex, nodefile, routing, tokens
 from . import mcp_server
-from .mdcg import MdCG
+from .mdcos import MdCGOS          # 生产路径：forget 属 OS 层，基础层 MdCG 无删除原语
 from .mcp_server import call_tool
 
 PASS = FAIL = 0
@@ -132,7 +133,7 @@ def main():
         f.write("不是文档")
 
     corpus.reset_root(ROOT)
-    cg = MdCG(ROOT)
+    cg = MdCGOS(ROOT)
     guide_path = os.path.join(fx, "guide.md")
 
     try:
@@ -279,8 +280,8 @@ def main():
         rd = call_tool(cg, "cg", {"op": "read", "query": "分阶段实施", "k": 10})
         hits = [r for r in rd.get("results", []) if r["node"]["id"] == g_id]
         check("文档节点可被检索到", bool(hits), f"hits={len(hits)}")
-        check("CCG 完整 → state=ACCEPT",
-              bool(hits) and hits[0]["state"] == "ACCEPT",
+        check("CCG 完整 → state=DEFER（v2：情境未确认条件不冒充接受，非 BLINDSPOT）",
+              bool(hits) and hits[0]["state"] == "DEFER",
               str(hits[0]["state"] if hits else None))
 
         # ===================================================== ⑥ op=ref
@@ -332,13 +333,44 @@ def main():
 
         # ===================================================== ⑨ 真实 docs/
         print("\n【9】真实 docs/：章节可定位、行号与源一致、可检索")
-        expect_files = sum(1 for d, _s, fs in os.walk(DOCS) for fn in fs
-                           if fn.lower().endswith(".md"))
-        real = index_doc(cg, DOCS)
+        # docs/experiments/ 是 .gitignore 整目录忽略的实验产物（实测 2358 个 md，
+        # 属索引噪声而非文档事实源），会把 max_files=500 撑爆：显式 skip_dirs 排除。
+        # 用「排除 + 回报」而不是「调大上限」——排除结果落在 skipped_dirs 里，不静默。
+        SKIP_NOISE = ("experiments",)
+
+        def _count_md(base, skip_names):
+            n = 0
+            for d, dirs, fs in os.walk(base):
+                dirs[:] = [x for x in dirs if x not in skip_names]
+                n += sum(1 for fn in fs if fn.lower().endswith(".md"))
+            return n
+
+        # 测试不得依赖仓库外状态：docs/experiments/ 被 .gitignore 整目录忽略，
+        # 外部 clone 后物理不存在，而本段断言的正是「真实扫描中 skip_dirs 命中
+        # 要被回报」。不存在时自备最小探针目录（跑完即清）；已存在时零动作
+        # （不碰本机历史产物）。探针为无标题正文——extract 返回空条目，不产生
+        # doc 节点；且探针在 experiments 内，_count_md 与被测扫描两侧口径一致，
+        # 对「全部 md 被索引」断言零影响。
+        probe_dir = os.path.join(DOCS, "experiments")
+        probe_created = not os.path.isdir(probe_dir)
+        if probe_created:
+            os.makedirs(probe_dir, exist_ok=True)
+            with open(os.path.join(probe_dir, "_probe_no_heading.md"),
+                      "w", encoding="utf-8") as f:
+                f.write("探针正文：无标题不产节点，仅让 experiments 物理存在。\n")
+        try:
+            expect_files = _count_md(DOCS, SKIP_NOISE)
+            real = index_doc(cg, DOCS, skip_dirs=list(SKIP_NOISE))
+        finally:
+            if probe_created:
+                shutil.rmtree(probe_dir)
         check("docs/ 全部 md 被索引（无静默跳过）",
               real.get("error_count") == 0 and real.get("files") == expect_files
               and real.get("truncated") is False,
               f"files={real.get('files')}/{expect_files} errs={real.get('error_count')}")
+        check("skip_dirs 实际排掉的目录被回报（排除不静默）",
+              any("experiments" in p for p in (real.get("skipped_dirs") or [])),
+              str(real.get("skipped_dirs"))[:80])
         r_items = docindex.extract(
             open(os.path.join(DOCS, PLAN_DOC), encoding="utf-8").read(), PLAN_DOC)
         s9r = next((i for i in r_items if i["heading"].startswith("9. ")), None)
@@ -352,14 +384,116 @@ def main():
         r_id = docindex.node_id(s9r)
         rd2 = call_tool(cg, "cg", {"op": "read", "query": "分阶段实施（稳健）", "k": 10})
         h2 = [r for r in rd2.get("results", []) if r["node"]["id"] == r_id]
-        check("§9 表可被检索到且判 ACCEPT",
-              bool(h2) and h2[0]["state"] == "ACCEPT",
+        check("§9 表可被检索到且可判（state=DEFER，非 BLINDSPOT）",
+              bool(h2) and h2[0]["state"] == "DEFER",
               str(h2[0]["state"] if h2 else None))
         rr4 = call_tool(cg, "cg", {"op": "ref", "node_id": r_id})
         check("回读到 §9 表原文（给出行号区间）",
               rr4.get("ok") and "分阶段实施" in (rr4.get("text") or ""),
               f"L{s9r['lineno']}-L{s9r['end']}" if s9r else "")
 
+        # ===================================================== ⑨b skip_dirs
+        print("\n【9b】skip_dirs：追加排除（只增不减）+ 结果可审计")
+        hit0, rules0 = codeindex.skip_matcher(None)
+        check("skip_dirs 缺省时判定器为空（默认行为与改造前逐字一致）",
+              hit0 is None and rules0 == [], f"{hit0} {rules0}")
+        sb = os.path.join(tmp, "skipdirs")
+        for rel in ("docs/keep/keep.md", "docs/experiments/probe/p.md",
+                    "docs/experiments/x.md", "sub/experiments/y.md",
+                    "node_modules/pkg/n.md"):
+            fp = os.path.join(sb, rel.replace("/", os.sep))
+            os.makedirs(os.path.dirname(fp), exist_ok=True)
+            with open(fp, "w", encoding="utf-8") as f:
+                f.write("# 标题\n\n" + LONG + "\n")
+        _i, _e, st_plain = docindex.index_dir(sb)
+        check("不给 skip_dirs：内置排除照旧（node_modules 不计入）",
+              st_plain["files"] == 4 and st_plain["skipped_dirs"] == [],
+              f"files={st_plain['files']} skip={st_plain['skipped_dirs']}")
+        _i, _e, st_name = docindex.index_dir(sb, skip_dirs=["experiments"])
+        check("不含 / 的规则按目录名匹配（各层级同名目录都排）"
+              " · 且内置排除不可被关闭（node_modules 仍被排）",
+              st_name["files"] == 1
+              and sorted(st_name["skipped_dirs"]) == ["docs/experiments",
+                                                      "sub/experiments"],
+              f"files={st_name['files']} skip={sorted(st_name['skipped_dirs'])}")
+        _i, _e, st_path = docindex.index_dir(sb, skip_dirs=["docs/experiments"])
+        check("含 / 的规则按相对路径匹配（只排这一处）",
+              st_path["files"] == 2 and st_path["skipped_dirs"] == ["docs/experiments"],
+              f"files={st_path['files']} skip={st_path['skipped_dirs']}")
+        _i, _e, st_norm = docindex.index_dir(sb, skip_dirs=["docs\\experiments\\"])
+        check("规则先归一（反斜杠/首尾斜杠）再匹配，不静默失配",
+              st_norm["files"] == 2
+              and st_norm["skipped_dirs"] == ["docs/experiments"],
+              f"files={st_norm['files']} skip={st_norm['skipped_dirs']}")
+
+        # ===================================================== ⑩ 索引对账
+        # 缺口：node_id 含 heading_path，改标题 → 整篇 id 重算；add_items 只做
+        # 同 id 幂等 upsert，旧代节点无人清退 → 新旧并存、同一文档召回两份。
+        # 水位 reconcile 只剪水位条目、不剪节点，所以必须在索引后显式清。
+        print("\n【10】节点级对账：改标题 → 清退过期代（消除重复召回）")
+        rn = os.path.join(fx, "rename.md")
+        b1 = "# 标题甲\n\n" + LONG + "\n"
+        with open(rn, "w", encoding="utf-8") as f:
+            f.write(b1)
+        r1 = index_doc(cg, fx)
+        ids1 = {docindex.node_id(i) for i in docindex.extract(b1, "rename.md")}
+        check("首轮：节点在库", all(cg.get(n) for n in ids1), f"n={len(ids1)}")
+        check("首轮无孤儿（清退计数 0）",
+              (r1.get("pruned") or {}).get("count") == 0, str(r1.get("pruned")))
+
+        b2 = "# 标题乙（已改名）\n\n" + LONG + "\n"
+        with open(rn, "w", encoding="utf-8") as f:
+            f.write(b2)
+        r2 = index_doc(cg, fx)
+        ids2 = {docindex.node_id(i) for i in docindex.extract(b2, "rename.md")}
+        check("改标题后新代上台", all(cg.get(n) for n in ids2), f"n={len(ids2)}")
+        check("旧代被清退（新旧不并存）",
+              not any(cg.get(n) for n in ids1),
+              f"残留={sorted(n for n in ids1 if cg.get(n))}")
+        check("清退数量上报", (r2.get("pruned") or {}).get("count") == len(ids1 - ids2),
+              str(r2.get("pruned")))
+
+        b3 = "# 标题丙\n\n" + LONG + "\n"
+        with open(rn, "w", encoding="utf-8") as f:
+            f.write(b3)
+        r3 = index_doc(cg, fx, prune_dry_run=True)
+        check("prune_dry_run 只列不清（节点仍在库）",
+              (r3.get("pruned") or {}).get("dry_run") is True
+              and any(cg.get(n) for n in ids2), str(r3.get("pruned")))
+        index_doc(cg, fx)
+        check("随后实际清退 → 旧代消失", not any(cg.get(n) for n in ids2))
+
+        b4 = "# 标题丁\n\n" + LONG + "\n"
+        with open(rn, "w", encoding="utf-8") as f:
+            f.write(b4)
+        ids4 = {docindex.node_id(i) for i in docindex.extract(b4, "rename.md")}
+        r5 = index_doc(cg, fx, prune=False)
+        check("prune=false 可关闭（不清退）",
+              r5.get("pruned") is None and all(cg.get(n) for n in ids4),
+              str(r5.get("pruned")))
+        r6 = index_doc(cg, fx, max_files=1)
+        check("截断时不清退（没扫完 ≠ 剩下都过期）",
+              r6.get("pruned") is None, f"truncated={r6.get('truncated')}")
+
+        print("\n【10b】悬空清退：源文件删除 → op=ref action=prune 处置")
+        ck1 = call_tool(cg, "cg", {"op": "ref", "action": "check", "max_nodes": 5000})
+        pre = len(ck1.get("dangling") or [])
+        os.remove(rn)
+        ck2 = call_tool(cg, "cg", {"op": "ref", "action": "check", "max_nodes": 5000})
+        check("删源后 check 报悬空", len(ck2.get("dangling") or []) > pre,
+              f"{pre}→{len(ck2.get('dangling') or [])}")
+        dry = call_tool(cg, "cg", {"op": "ref", "action": "prune", "dry_run": True})
+        check("prune_dry_run 列出待清退但不删",
+              dry.get("dry_run") is True and dry.get("count", 0) >= 1
+              and any(cg.get(n) for n in ids4), str(dry)[:130])
+        gone = call_tool(cg, "cg", {"op": "ref", "action": "prune"})
+        check("prune 清退悬空节点",
+              gone.get("count", 0) >= 1 and not any(cg.get(n) for n in ids4),
+              str(gone)[:130])
+        ck3 = call_tool(cg, "cg", {"op": "ref", "action": "check", "max_nodes": 5000})
+        check("清退后悬空归零", not (ck3.get("dangling") or []),
+              str(ck3.get("dangling"))[:130])
+
     finally:
         shutil.rmtree(tmp, ignore_errors=True)
 

package/md_cg/test_p36_kp_align.py

@@ -78,16 +78,18 @@ def _state(cg, nid, q="问主题"):
                                       {"query": q})["state"]
 
 
-def _dist(cg, ids_):
+def _dist(cg, ids_, q_map=None):
     out = {}
     for nid in ids_:
-        st = _state(cg, nid)
+        st = _state(cg, nid, (q_map or {}).get(nid, "问主题"))
         out[st] = out.get(st, 0) + 1
     return out
 
 
 ALL = ["kp_a", "kp_b", "kp_c", "kp_present", "kp_ph"]
 TARGETS = ["kp_a", "kp_b", "kp_c"]
+#: v2 正条件确认：情境须命中节点声明的生效条件词面才可 ACCEPT
+QMAP = {"kp_a": "问a", "kp_b": "问b", "kp_c": "问c", "kp_present": "问浮力"}
 
 
 def main():
@@ -165,18 +167,21 @@ def main():
         ok(fm.get("ccg_exempt") is True, "⑥空壳豁免标记未被误摘")
 
         # ---------- ⑤ 打破 DEFER 恒定 ----------
+        # v2 语义：摘豁免只是解除 DEFER 短路，ACCEPT 还需情境命中正条件词面
         for nid in TARGETS:
-            ok(_state(cg, nid) == STATE_ACCEPT,
-               f"⑤{nid} 摘豁免后转 ACCEPT（DEFER 恒定被打破）")
-        ok(_state(cg, "kp_present") == STATE_ACCEPT, "⑤已齐备节点转 ACCEPT")
-        after = _dist(cg, ALL)
+            ok(_state(cg, nid, QMAP[nid]) == STATE_ACCEPT,
+               f"⑤{nid} 摘豁免后 + 情境命中条件 → ACCEPT")
+        ok(_state(cg, "kp_present", QMAP["kp_present"]) == STATE_ACCEPT,
+           "⑤已齐备节点 + 情境命中条件 → ACCEPT")
+        after = _dist(cg, ALL, QMAP)
         ok(after.get(STATE_ACCEPT) == 4 and after.get(STATE_DEFER) == 1,
            f"⑤术后分布 ACCEPT=4 / DEFER=1（实测 {after}）")
 
         # ---------- ⑦ 前后对比 ----------
         report = {"before": before, "after": after,
                   "accept_gain": after.get(STATE_ACCEPT, 0) - before.get(STATE_ACCEPT, 0),
-                  "still_defer": [n for n in ALL if _state(cg, n) == STATE_DEFER]}
+                  "still_defer": [n for n in ALL
+                                  if _state(cg, n, QMAP.get(n, "问主题")) == STATE_DEFER]}
         ok(report["accept_gain"] == 4 and report["still_defer"] == ["kp_ph"],
            f"⑦前后对比：ACCEPT +4，剩余 DEFER 仅为不可闭合项（实测 {report}）")
 

package/md_cg/test_predict_beta.py

@@ -0,0 +1,135 @@
+# -*- coding: utf-8 -*-
+"""通道贝叶斯后验（P-T-73/74）验证：Beta-Bernoulli 置信更新。
+
+断言面：
+  ① 纯函数数学：先验=基线（空历史 mean=0.40）；小样本向基线收缩
+    （n=5 全命中 → 0.52，不过度自信到 1.0）；大样本收敛（n=200 → 0.9455）；
+    方差闭式与区间对称
+  ② 通道分组与留痕：feedback(channel=...) 落 _prediction.jsonl；
+    未标注归 "unlabeled"；channel_posterior 分通道/单通道/limit 截断
+  ③ 自我模型集成：self_state 预测面带 beta_mean/ci95；正文渲染；留痕字段
+  ④ 零回归面：dynamic_hit_threshold/hit_rate 默认行为不变；stats/catalog 增补
+
+运行：python -m md_cg.test_predict_beta
+"""
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+
+from . import predict, self_state
+from .mdcos import MdCGOS
+
+PASS = FAIL = 0
+FAILS = []
+
+
+def ok(cond, label):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+    else:
+        FAIL += 1
+        FAILS.append(label)
+        print(f"  FAIL {label}")
+
+
+def main():
+    tmp = tempfile.mkdtemp(prefix="mdcg_beta_")
+    try:
+        root = os.path.join(tmp, "root")
+        os.makedirs(root, exist_ok=True)
+        cg = MdCGOS(root)
+
+        # ---------- ① 纯函数数学 ----------
+        p0 = predict.beta_posterior([])
+        ok(p0["mean"] == predict.BASE_HIT_RATE and p0["samples"] == 0,
+           "①空序列 → 先验（mean=0.40=BASE_HIT_RATE，口径无缝）")
+        ok(p0["alpha"] == 8.0 and p0["beta"] == 12.0,
+           "①b先验参数 α0=0.4×20=8 β0=12")
+
+        p5 = predict.beta_posterior([True] * 5)
+        ok(p5["mean"] == 0.52 and p5["samples"] == 5,
+           "①c小样本收缩：n=5 全命中 → mean=0.52（滑动均值会到 1.0 过度自信）")
+        ok(0.4 < p5["mean"] < 1.0, "①d证据上拉但不越界")
+
+        p200 = predict.beta_posterior([True] * 200)
+        ok(p200["mean"] == 0.9455 and p200["ci95"] == [0.9155, 0.9754],
+           "①e大样本收敛：n=200 全命中 → mean=0.9455，CI=[0.9155,0.9754] 收窄")
+
+        p50 = predict.beta_posterior([True] * 50 + [False] * 50)
+        ok(p50["mean"] == 0.4833, "①f半对半 n=100 → mean=0.4833（58/120）")
+        lo, hi = p50["ci95"]
+        ok(lo < p50["mean"] < hi and abs((p50["mean"] - lo) - (hi - p50["mean"])) < 2e-4,
+           "①gCI95 对称包住后验均值")
+
+        # ---------- ② 通道分组与留痕 ----------
+        for _ in range(3):
+            predict.feedback(cg, "n_c", hit=True, channel="causal",
+                             sync_self=False, note="t")
+        for _ in range(2):
+            predict.feedback(cg, "n_s", hit=False, channel="semantic",
+                             sync_self=False, note="t")
+        predict.feedback(cg, "n_u", hit=True, sync_self=False, note="t")
+
+        hist = predict.channel_history(cg)
+        ok(set(hist) == {"causal", "semantic", "unlabeled"},
+           "②三通道分组（未标注诚实归 unlabeled）")
+        ok(len(hist["causal"]) == 3 and len(hist["semantic"]) == 2
+           and len(hist["unlabeled"]) == 1, "②b各通道计数 3/2/1")
+
+        post = predict.channel_posterior(cg)
+        ok(post["all"]["samples"] == 6 and post["all"]["hits"] == 4,
+           "②c全量后验 samples=6 hits=4")
+        ok(post["channels"]["causal"]["mean"] > post["channels"]["semantic"]["mean"],
+           "②d通道分离：causal 全命中(0.4783) > semantic 全 miss(0.3636)")
+        ok(post["all"]["mean"] == 0.4615,
+           "②e全量后验 12/26=0.4615（介于两通道之间）")
+
+        one = predict.channel_posterior(cg, channel="causal")
+        ok(one["channel"] == "causal" and one["samples"] == 3
+           and one["mean"] == 0.4783, "②f单通道查询（11/23=0.4783）")
+        ok(len(predict.channel_history(cg, limit=2)) >= 1,
+           "②glimit 截断不崩溃")
+
+        # ---------- ③ 自我模型集成 ----------
+        r = self_state.refresh(cg, actor="t_beta")
+        pd = (r.get("state") or {}).get("prediction") or {}
+        ok(r["ok"] and pd.get("beta_mean") == 0.4615
+           and pd.get("beta_ci95"), "③self_state 预测面带后验（beta_mean/ci95）")
+        ok(pd.get("hit_rate") == 0.6667,
+           "③b滑动 hit_rate 与后验并存（两种估计面，互不替代）")
+        st = self_state.snapshot(cg)
+        ok(st and st["prediction"]["beta_mean"] == 0.4615, "③c快照可读")
+        node = cg.get(self_state.state_node_id())
+        ok("后验可信度" in (node.get("content") or ""), "③d正文渲染含后验可信度")
+        with open(os.path.join(root, "_self_state.jsonl"), encoding="utf-8") as f:
+            tail = [json.loads(x) for x in f if x.strip()][-1]
+        ok(tail.get("prediction_beta_mean") == 0.4615,
+           "③e留痕字段 prediction_beta_mean")
+
+        # ---------- ④ 零回归面 ----------
+        dth = predict.dynamic_hit_threshold(cg)
+        ok(dth["samples"] == 6 and dth["reflect"] is False
+           and dth["threshold"] == predict.BASE_HIT_RATE,
+           "④dynamic_hit_threshold 默认行为不变（样本<50 不触发反思）")
+        ok(predict.hit_rate(cg) == 0.6667, "④bhit_rate 滑动口径不变（4/6）")
+        stt = predict.stats(cg)
+        ok("beta" in stt and stt["beta"]["channels"]["causal"]["samples"] == 3,
+           "④cstats 带 beta 通道分解")
+        ok(any("P-T-73/74" in k for k in predict.catalog()["decisions"]),
+           "④dcatalog 自描述含通道贝叶斯条目")
+
+        print(f"\n测试完成：{PASS} 通过 / {FAIL} 失败")
+        if FAILS:
+            for f in FAILS:
+                print(f"  - {f}")
+        print("ALL PASS" if FAIL == 0 else "HAS FAILURES")
+    finally:
+        import shutil
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
+if __name__ == "__main__":
+    main()

package/md_cg/test_preflight_failclosed.py

@@ -0,0 +1,100 @@
+# -*- coding: utf-8 -*-
+"""test_preflight_failclosed.py —— preflight 门面 fail-closed 专项测试（补测④，矩阵 v0.2 #29）。
+
+背景（§2A-3）：AEIS 门面在自我认知组件未装配时返回 ok:True（fail-open），
+「检查未执行」被冒充为「检查通过」，违反白箱「未验证不放行」纪律。
+
+改动：门面（真身 AEIS/aeis/api.py + 镜像 whitebox_kb/aeis_core/api.py 同步）
+未装配时返回 ok:False + status=fail_closed + reason + 装配错误透传。
+
+本测试用库内镜像（aeis_core 不含 self_cognition 模块 → 引擎装配必然失败
+置 None）确定性触发未装配分支；委托路径用 stub 验证；双副本源码一致性
+静态断言防漂移。
+"""
+import os
+import sys
+
+if hasattr(sys.stdout, "buffer"):
+    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from md_cg.whitebox_kb.aeis_core.api import Agent  # noqa: E402
+
+PASS, FAIL = 0, 0
+
+
+def check(name, ok, detail=""):
+    global PASS, FAIL
+    if ok:
+        PASS += 1
+        print(f"  [PASS] {name}" + (f"  · {detail}" if detail else ""))
+    else:
+        FAIL += 1
+        print(f"  [FAIL] {name}" + (f"  · {detail}" if detail else ""))
+
+
+# ------------------------------------------------------------------
+# [1] 未装配分支：fail-closed（镜像引擎装配必然失败，确定性触发）
+# ------------------------------------------------------------------
+print("\n[1] 未装配分支 fail-closed（镜像 aeis_core 无 self_cognition 模块）\n")
+a = Agent(identity="pf-fc-test", db_path=":memory:")
+sc_err = getattr(a.engine, "_self_cognition_error", "")
+print(f"  镜像引擎装配状态: _self_cognition={a.engine._self_cognition} "
+      f"error={sc_err[:60]!r}")
+a.engine._self_cognition = None  # 防御：测试进程若曾 import aeis 会污染别名注册，显式归零
+
+r = a.preflight("任意待发布内容")
+check("未装配 → ok is False（拦截）", r.get("ok") is False)
+check("status=fail_closed", r.get("status") == "fail_closed")
+check("reason=self_cognition_not_ready", r.get("reason") == "self_cognition_not_ready")
+check("note 声明未验证不放行", "未验证不放行" in str(r.get("note", "")))
+check("装配错误透传（可见可修）", "error" in r and r["error"] == str(sc_err or ""))
+
+# ------------------------------------------------------------------
+# [2] 组件在位 → 零干扰委托（门面不改变 sc 结果）
+# ------------------------------------------------------------------
+print("\n[2] 组件在位委托路径（stub 验证门面零干扰）\n")
+
+
+class _StubSC:
+    @staticmethod
+    def preflight(text):
+        return {"ok": False, "conflicts": ["破坏"], "issues": ["stub 拦截"]}
+
+
+a.engine._self_cognition = _StubSC
+r2 = a.preflight("含破坏词的内容")
+check("委托：sc 结果原样返回", r2.get("ok") is False and r2.get("conflicts") == ["破坏"])
+check("委托：门面未注入 fail_closed 字段", "status" not in r2)
+a.engine._self_cognition = None
+
+# ------------------------------------------------------------------
+# [3] 双副本源码一致性（真身 ↔ 镜像，防漂移）
+# ------------------------------------------------------------------
+print("\n[3] 双副本源码一致性静态断言\n")
+HERE = os.path.dirname(os.path.abspath(__file__))
+mirror = open(os.path.join(HERE, "whitebox_kb", "aeis_core", "api.py"),
+              encoding="utf-8").read()
+i0 = mirror.find("def preflight")
+seg_m = mirror[i0:mirror.find("def ", i0 + 10)]
+check("镜像门面含 fail_closed", "fail_closed" in seg_m)
+check("镜像 fail-open 签名已移除",
+      '"ok": True, "note": "自我认知组件未装配"' not in seg_m)
+
+aeis_api = os.path.normpath(os.path.join(HERE, "..", "..", "AEIS", "aeis", "api.py"))
+if os.path.exists(aeis_api):
+    real = open(aeis_api, encoding="utf-8").read()
+    j0 = real.find("def preflight")
+    seg_r = real[j0:real.find("def ", j0 + 10)]
+    check("真身门面含 fail_closed", "fail_closed" in seg_r)
+    check("真身 fail-open 签名已移除",
+          '"ok": True, "note": "自我认知组件未装配"' not in seg_r)
+    # 门面段逐行一致性（双副本纪律：真身与镜像同源同改）
+    check("真身与镜像 preflight 段逐行一致", seg_r == seg_m)
+else:
+    print("  [SKIP] AEIS 仓不在同级路径，真身一致性由 AEIS 侧测试覆盖")
+
+# ------------------------------------------------------------------
+print("\n" + "=" * 60)
+print(f"preflight fail-closed 专项测试：{PASS} 通过 / {FAIL} 失败")
+sys.exit(0 if FAIL == 0 else 1)

package/md_cg/test_progressive.py

@@ -0,0 +1,146 @@
+# -*- coding: utf-8 -*-
+"""渐进式语义检索控制器测试（md_cg/progressive.py）。
+
+断言面（性质级，不锚具体数字）：
+  ① core_subset   保序截断 / 确定性 / 空集 / ratio 边界
+  ② discriminative 零区分→None（诚实停止）/ 最大区分入选 / 同 gap 保序 /
+                   空候选与单候选→None
+  ③ 收敛演示       宽检索 gold 非前排 → 区分性条件把它推到 top1
+  ④ 无区分性       候选同质 → 一步停、不空转
+  ⑤ 预算约束       多步收敛不超过 max_stages，每阶段都被测量
+  ⑥ 空原子集       stages 空、不炸
+
+运行：python -m md_cg.test_progressive
+"""
+from __future__ import annotations
+
+from .progressive import (MIN_DISCRIM, core_subset, discriminative,
+                          progressive_search)
+
+PASS = FAIL = 0
+FAILS = []
+
+
+def ok(cond, label):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+    else:
+        FAIL += 1
+        FAILS.append(label)
+        print(f"  FAIL {label}")
+
+
+def _jaccard_rank(qset, docs):
+    """bench 同款 Jaccard 评分器：[(cid, score)] 降序（tie 按 id 序）。"""
+    out = []
+    for cid, ds in docs:
+        inter = len(qset & ds)
+        out.append((cid, inter / len(qset | ds) if inter else 0.0))
+    out.sort(key=lambda t: (-t[1], t[0]))
+    return out
+
+
+def main():
+    # ---------- ① core_subset ----------
+    cs = core_subset(["买", "外套", "红色", "东京", "昨天"], 0.5)
+    ok(cs == ["买", "外套"],
+       f"①保序截断（5×0.5→2）: {cs}")
+    ok(core_subset(["a", "b", "c"], 0.5) == ["a"],
+       "①int 截断确定性（3×0.5→1）")
+    ok(core_subset([], 0.5) == [] and core_subset(["", None, "x"], 0.5) == ["x"],
+       "①空集/空 token 过滤")
+    ok(core_subset(["a", "b"], 1.0) == ["a", "b"],
+       "①ratio=1.0 退化为全原子")
+
+    # ---------- ② discriminative ----------
+    ok(discriminative(["a"], [{"a"}]) is None,
+       "②单候选→None（无『候选间』区分可言）")
+    ok(discriminative(["a"], []) is None,
+       "②空候选→None")
+    # a 全命中（cov=1→gap=0 零区分）不选；b 一半命中（gap=1）入选
+    ok(discriminative(["a", "b"], [{"a", "x"}, {"a", "b"}]) == "b",
+       "②零区分排除+最大区分入选")
+    # 全不命中（cov=0→gap=0）同样排除
+    ok(discriminative(["z"], [{"a", "x"}, {"a", "b"}]) is None,
+       "②全不命中=零区分，同样排除")
+    # 同 gap 保序：两个原子都恰一半命中 → 取序列靠前者
+    ok(discriminative(["p", "q"], [{"p"}, {"q"}]) == "p",
+       "②同 gap 按原序 tie-break（确定性）")
+    ok(discriminative([], [{"a"}, {"b"}]) is None,
+       "②空条件池→None")
+
+    # ---------- ③ 收敛演示：宽检索 gold 非前排 → 渐进推到 top1 ----------
+    docs = [
+        ("gold", frozenset("买 外套 红色 东京".split())),
+        ("dA",   frozenset("买 外套".split())),
+        ("dB",   frozenset("买 外套 东京".split())),
+    ]
+    cand_atoms = dict(docs)
+    atoms = "买 外套 红色 东京".split()
+
+    def rank_fn(used):
+        return _jaccard_rank(frozenset(used), docs)
+
+    r0 = rank_fn(core_subset(atoms, 0.5))          # core=[买,外套]
+    gold_rank0 = [cid for cid, _ in r0].index("gold") + 1
+    tr = progressive_search(rank_fn, atoms, cand_atoms,
+                            ratio=0.5, k=10, max_stages=4)
+    final_top = tr["stages"][-1]["top"]
+    gold_rank1 = final_top.index("gold") + 1
+    ok(gold_rank0 > 1,
+       f"③前置：宽检索（core 50%）gold 非前排（rank={gold_rank0}）")
+    ok(gold_rank1 == 1,
+       f"③区分性条件把 gold 推到 top1（added={tr['added']}）")
+    ok(tr["added"] and len(tr["added"]) <= 3,
+       "③refinement 步数有限且非零")
+
+    # ---------- ④ 候选同质：无区分性 → 一步停、不空转 ----------
+    docs_same = [("m1", frozenset("a b".split())),
+                 ("m2", frozenset("a b c".split())),
+                 ("m3", frozenset("a b d".split()))]
+    tr2 = progressive_search(lambda u: _jaccard_rank(frozenset(u), docs_same),
+                             "a b c d".split(), dict(docs_same),
+                             ratio=0.5, k=10, max_stages=4)
+    # c 只有 m2 有（cov=1/3→gap=1/3>0.1 可区分）——应加条件而非停；
+    # 加到某步后剩余原子均零/低区分 → 收敛。只断言：步数 ≤ 预算且每阶段被测量。
+    ok(len(tr2["stages"]) <= 4 and len(tr2["added"]) == len(tr2["stages"]) - 1,
+       "④阶段数=加条件数+1（每阶段都被测量，不空转）")
+    docs_twin = [("t1", frozenset("a b".split())),
+                 ("t2", frozenset("a b".split()))]
+    tr3 = progressive_search(lambda u: _jaccard_rank(frozenset(u), docs_twin),
+                             "a b c".split(), dict(docs_twin),
+                             ratio=0.5, k=10, max_stages=3)
+    ok(tr3["converged"] and not tr3["added"] and len(tr3["stages"]) == 1,
+       "④候选同质（剩余原子全零区分）→ 一步收敛，不硬加条件")
+
+    # ---------- ⑤ 预算约束 ----------
+    atoms5 = list("abcdef")
+    docs5 = [(f"n{i}", frozenset(atoms5[:i + 1])) for i in range(6)]  # 递增前缀
+    tr5 = progressive_search(lambda u: _jaccard_rank(frozenset(u), docs5),
+                             atoms5, dict(docs5), ratio=0.5, k=10, max_stages=3)
+    ok(len(tr5["stages"]) <= 3 and not tr5["converged"],
+       "⑤预算耗尽 converged=False（预算内每步已测量）")
+    tr5b = progressive_search(lambda u: _jaccard_rank(frozenset(u), docs5),
+                              atoms5, dict(docs5), ratio=0.5, k=10,
+                              max_stages=10)
+    ok(len(tr5b["stages"]) <= 10,
+       "⑤放宽预算不炸（步数受收敛/原子数天然上限约束）")
+
+    # ---------- ⑥ 空原子集 ----------
+    tr6 = progressive_search(lambda u: [], [], {}, ratio=0.5, k=10)
+    ok(tr6 == {"stages": [], "added": [], "converged": False},
+       "⑥空原子集→空轨迹不炸")
+
+    # ---------- ⑦ MIN_DISCRIM 语义守卫 ----------
+    ok(0 < MIN_DISCRIM < 1, "⑦阈值为 (0,1) 内小正数（排除零区分，不卡高区分）")
+
+    print(f"\nprogressive: {PASS} passed, {FAIL} failed")
+    if FAILS:
+        for f in FAILS:
+            print(f"  - {f}")
+    raise SystemExit(1 if FAIL else 0)
+
+
+if __name__ == "__main__":
+    main()