@furongjun1999/dsh-memory 0.4.3 → 0.4.5

package/md_cg/test_p40_refine_worklist.py

@@ -0,0 +1,241 @@
+# -*- coding: utf-8 -*-
+"""G6 · node_ 结构提炼抽检工单与扩批闸门（P40 设计态验收）。
+
+对照 `docs/认知图_G4-G8缺口裁定单_v0.1.md` §四 G6：`node_*`（P37 派生记忆）
+自带 `ccg_exempt=true`，只声明「功能名 / 生效条件」，`子功能/执行/不适用条件` 全缺。
+条件 A 要求**先抽 20 条做提炼预演、人工核对提炼口径，绝不盲跑全量**。
+
+覆盖：①契约链 ②plan 只读 ③工单结构 ④同源口径 ⑤预演 grounded+模板词标记
+⑥样本不足不产候选 ⑦确定性 ⑧闸门关闭 ⑨闸门放行 ⑩闸门否决 ⑪不改节点
+⑫权限分档 ⑬样本量校准 ⑭未知 action。
+
+独立临时根，重跑 ≡ 首跑。运行：python -m md_cg.test_p40_refine_worklist
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import tempfile
+
+from . import consolidate as C
+from . import refine as rf
+from . import tokens
+from .mdcos import MdCGOS
+from .mcp_server import KERNEL_TOOLS, call_tool
+from .security import AccessDenied, Principal
+
+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 denied(fn, label):
+    try:
+        fn()
+    except AccessDenied:
+        ok(True, label)
+        return
+    ok(False, label)
+
+
+#: 与 P37 派生记忆同型：有「功能名/生效条件」，缺「子功能/执行/不适用条件」
+TEMPLATE = ("# 功能名：感知单元\n"
+            "# 生效条件：载体/位置：感知系统；时间：2026-01-01 00:00～"
+            "2026-01-01 01:00（UTC）；方法：感官输入；约束：协议实例运行中\n"
+            "协议实例在感知系统中完成一次观测，产出结构化记录。\n")
+
+
+def _seed_root(root, n=30):
+    cg = MdCGOS(root)
+    for i in range(n):
+        cg.add("node_dup_%02d" % i, TEMPLATE, layer="knowledge", tags=["p37"])
+    cg.add("note_out", "情境笔记，不在抽检前缀内。\n", layer="contextual",
+           tags=["note"])
+    cg.flush()
+    cg.rebuild_index()
+    return cg
+
+
+def _write_layer():
+    s = tokens.role_spec("reflection")
+    return Principal(tenant="default", actor="writer", clearance="internal",
+                     can_write=True, can_admin=False, role="reflect",
+                     layers_allow=s["layers_allow"], ops_allow=s["ops_allow"])
+
+
+def _p(cg, **kw):
+    return call_tool(cg, "cg", {"op": "maintain", **kw})
+
+
+def main():
+    print("md 认知图 P40 验收 · G6 node_ 提炼抽检工单（只读预演 + 扩批闸门）")
+    print("=" * 70)
+    tmp = tempfile.mkdtemp(prefix="mdcg_p40_")
+    ROOT = os.path.join(tmp, "root")
+    try:
+        from . import corpus
+        corpus.reset_root(ROOT)
+        cg = _seed_root(ROOT)
+        cg.principal = Principal(tenant="default", actor="p40",
+                                 clearance="private", can_write=True,
+                                 can_admin=True, role="designer")
+        acts = ("refine", "refine_gate", "refine_history", "refine_calibrate")
+
+        print("\n【1】op 契约链（防漏改）")
+        prop = next(t for t in KERNEL_TOOLS
+                    if t["name"] == "cg")["inputSchema"]["properties"]
+        desc = prop["action"]["description"]
+        ok(all(a in desc for a in acts), "①4 个 refine action 已在 schema 声明")
+        ok(all(k in prop for k in ("sample_n", "prefix", "verdicts")),
+           "①sample_n/prefix/verdicts 参数已声明")
+        ok(all(a in MdCGOS.MAINTAIN_ACTIONS for a in acts),
+           "①4 个 action 已在 MAINTAIN_ACTIONS 注册")
+
+        print("\n【2】plan 只读（不写盘 / 前缀内 20 条）")
+        rep = _p(cg, action="refine")
+        ok(rep.get("dry_run") is True and rep.get("readonly") is True,
+           "②dry_run/readonly 标记")
+        ok(rep.get("pool") == 30, f"②抽检池 30（实测 {rep.get('pool')}）")
+        ok(rep.get("sampled") == 20, f"②抽检 20 条（实测 {rep.get('sampled')}）")
+        ok(all(i["id"].startswith("node_") for i in rep["items"]),
+           "②前缀外节点不纳入")
+        ok(not os.path.exists(os.path.join(ROOT, rf.REFINE_LOG)),
+           "②预演不写日志")
+
+        print("\n【3】工单结构（原文 + 字段缺口 + 指纹 + 口径声明）")
+        ok(len(rep["worklist"]) == 20, "③工单 20 条")
+        it = rep["items"][0]
+        ok(all(k in it for k in ("id", "family", "layer", "body", "body_len",
+                                 "ccg_present", "ccg_missing", "source_sha")),
+           "③工单条目字段齐备")
+        ok("子功能" in it["ccg_missing"] and "执行" in it["ccg_missing"],
+           "③如实登记缺失的 CCG 字段（不编造）")
+        ok(it["body"].strip(), "③工单带原文（供人工核对）")
+        ok(len(it["source_sha"]) == 16, "③来源指纹（可复核正文）")
+        ok([r["key"] for r in rep["spec"]["review_items"]]
+           == ["faithful", "added_info", "discriminating", "member_consistency"],
+           "③口径声明含 4 项人工核对项")
+        ok(rep["spec"]["evidence"].startswith("inferred"),
+           "③产出证据档恒 inferred")
+
+        print("\n【4】同源口径（不另起提炼器）")
+        ok(rf.MIN_CLUSTER == C.INDUCE_MIN_CLUSTER
+           and rf.MIN_JACCARD == C.INDUCE_MIN_JACCARD, "④聚类阈值取自 induce")
+
+        print("\n【5】预演（grounded + 模板词标记）")
+        pv = rep["preview"]
+        ok(pv["clusters"] == 1, f"⑤产出 1 个候选（实测 {pv['clusters']}）")
+        c0 = pv["candidates"][0]
+        ok(c0["size"] == 20, f"⑤候选成员 20（实测 {c0['size']}）")
+        ok(c0["grounding_gap"] == [], "⑤共性条件全成员可追溯（无忠实性缺口）")
+        ok(all(len(v) == c0["size"] for v in c0["condition_sources"].values()),
+           "⑤每条共性条件都有成员索引来源")
+        ok(any(g["ratio"] >= rf.GENERIC_DF for g in c0["generic_conditions"]),
+           "⑤高 df 模板词被标记 generic")
+        ok(c0["discriminating"] == [], "⑤该候选无区分性共性")
+        ok(pv["candidates_generic_only"] == 1, "⑤如实报「模板化」候选计数")
+
+        print("\n【6】样本不足不产候选（<min_cluster 不成簇）")
+        pv2 = rf.preview(cg, ids=sorted(rep["sample"])[:2])
+        ok(pv2["clusters"] == 0, "⑥2 条 < min_cluster → 0 候选")
+        ok(pv2["sample_adequacy"] == "insufficient", "⑥判 insufficient")
+
+        print("\n【7】确定性（同 seed 同样本）")
+        rep2 = _p(cg, action="refine")
+        ok(rep["sample_sha"] == rep2["sample_sha"], "⑦同样本指纹")
+        ok([c["concept_id"] for c in pv["candidates"]]
+           == [c["concept_id"] for c in rep2["preview"]["candidates"]],
+           "⑦同候选集")
+        ok(rep["sample"] == rep2["sample"], "⑦同抽样序")
+
+        print("\n【8】闸门（未审不放行）")
+        g0 = _p(cg, action="refine_gate")
+        ok(g0.get("expand_allowed") is False and g0.get("reason") == "no_batch",
+           "⑧无留痕 → no_batch 且不放行")
+        ap0 = _p(cg, action="refine", apply=True, batch="t-review")
+        ok(ap0.get("reviewed") == 0
+           and ap0["gate"]["reason"] == "awaiting_human_review",
+           "⑧未审 → awaiting_human_review 且不放行")
+        ok(os.path.exists(os.path.join(ROOT, rf.REFINE_LOG)), "⑧留痕已落盘")
+
+        print("\n【9】闸门放行（全审 / 全忠实 / 无新增）")
+        cids = [c["concept_id"] for c in pv["candidates"]]
+        good = [{"concept_id": c, "faithful": True, "added_info": False}
+                for c in cids]
+        ap1 = _p(cg, action="refine", apply=True, batch="t-ok", verdicts=good)
+        ok(ap1["gate"]["reviewed"] == len(cids), "⑨裁决全部候选")
+        ok(ap1["gate"]["expand_allowed"] is True
+           and ap1["gate"]["reason"] == "ok", "⑨通过率达标 → 放行扩批")
+        g1 = _p(cg, action="refine_gate", batch="t-ok")
+        ok(g1.get("expand_allowed") is True, "⑨gate 动作复算一致")
+
+        print("\n【10】闸门否决（新增信息 / 忠实率不足）")
+        bad = [{"concept_id": c, "faithful": True, "added_info": True}
+               for c in cids]
+        ap2 = _p(cg, action="refine", apply=True, batch="t-added", verdicts=bad)
+        ok(ap2["gate"]["reason"] == "added_info_detected"
+           and ap2["gate"]["expand_allowed"] is False, "⑩新增信息 → 整批否决")
+        st = rf._verdict_stats(
+            [{"concept_id": "a", "faithful": False, "added_info": False},
+             {"concept_id": "b", "faithful": True, "added_info": False}],
+            [{"concept_id": "a"}, {"concept_id": "b"}])
+        ok(st["reason"] == "faithful_rate_below_gate"
+           and st["expand_allowed"] is False, "⑩忠实率不足 → 拒放行")
+
+        print("\n【11】apply 不改任何节点")
+        nid = rep["items"][0]["id"]
+        before = cg._read(cg.index["nodes"][nid])
+        _p(cg, action="refine", apply=True, batch="t-immutable")
+        cg.rebuild_index()
+        after = cg._read(cg.index["nodes"][nid])
+        ok(before[0] == after[0] and before[1] == after[1],
+           "⑪frontmatter 与正文逐字节不变")
+        hist = _p(cg, action="refine_history")
+        ok(hist["total"] >= 4 and hist["returned"] >= 1, "⑪history 可回读留痕")
+        ok("root" in hist, "⑪history 结构含 root")
+
+        print("\n【12】权限分档（写层可看 / apply 需管理）")
+        cg.principal = _write_layer()
+        ok(isinstance(_p(cg, action="refine"), dict), "⑫写层可看工单")
+        ok(isinstance(_p(cg, action="refine_gate"), dict), "⑫写层可看闸门")
+        denied(lambda: _p(cg, action="refine", apply=True), "⑫写层不可 apply")
+        cg.principal = Principal(tenant="default", actor="p40",
+                                 clearance="private", can_write=True,
+                                 can_admin=True, role="designer")
+
+        print("\n【13】样本量校准（只读爬坡，如实归因）")
+        cal = _p(cg, action="refine_calibrate")
+        ok(cal.get("readonly") is True and cal["steps"][0]["n"] == 20,
+           "⑬校准从 20 条起步")
+        ok(isinstance(cal.get("blocked"), bool)
+           and isinstance(cal.get("recommend"), str), "⑬如实报 blocked + 归因")
+        ok("扩批" in cal["recommend"], "⑬归因指向「不得扩批」")
+
+        print("\n【14】未知 action 不静默成功")
+        try:
+            _p(cg, action="refine_x")
+            ok(False, "⑭未知 action 必须报错")
+        except ValueError as e:
+            ok("未知 action" in str(e), "⑭未知 action 报错")
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+    print("\n" + "=" * 70)
+    print(f"P40 结果：PASS {PASS} / FAIL {FAIL}")
+    if FAILS:
+        print("未通过：" + "；".join(FAILS))
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(main())

package/md_cg/test_p41_evolve_patrol.py

@@ -0,0 +1,224 @@
+# -*- coding: utf-8 -*-
+"""G7 · 自主演化巡检（把「有能力」变成「有驱动」）（P41 设计态验收）。
+
+对照 `docs/认知图_G4-G8缺口裁定单_v0.1.md` §五 G7：固化 / 重要性 / 去污染三类自我
+演化动作早已具备，但**没有任何驱动源**周期性问「现在有多少该固化 / 该重算的候选」，
+于是能力被饿死。本项给常驻循环挂上**只读**演化巡检 + **受控**自愈。
+
+覆盖：
+  ① 契约链：catalog/描述/schema 暴露 evolve 及 allow_evolve/auto_evolve/evolve_interval；
+  ② 只读盘点：`evolve_check` 标 readonly/dry_run、零写盘、零改节点、代理指标显式声明；
+  ③ 确定性：两次盘点候选数一致（可复核）；
+  ④ 诊断集成：`diagnose()` 带 evolve 段与 info 级 issue（候补多 ≠ 库有毛病，ok 不受影响）；
+  ⑤ 自愈默认关闭：`heal()` 不带 allow_evolve → 演化动作 applied=False 且给出 reason；
+  ⑥ 自愈受控放行：带 allow_evolve → 只放行**确定性**动作（重要性重算）且漂移归零；
+  ⑦ LLM 依赖永不自动：固化（consolidate_run）无 reflect_fn 时恒 applied=False；
+  ⑧ 循环挂载：`evolve_interval` 生效、`auto_evolve=False` 时只记账；
+  ⑨ 失败不拖垮常驻：巡检抛错时循环仍活着、心跳照常、last_evolve 不被污染；
+  ⑩ MCP 接入：op=sustain action=evolve / catalog / heal(allow_evolve)；
+  ⑪ 未知 action 不静默成功。
+
+独立临时根，重跑 ≡ 首跑。运行：python -m md_cg.test_p41_evolve_patrol
+"""
+from __future__ import annotations
+
+import hashlib
+import os
+import shutil
+import tempfile
+import time
+
+from . import sustain
+from . import weights as W
+from .mdcg import MdCG
+from .mcp_server import KERNEL_TOOLS, call_tool
+
+PASS = FAIL = 0
+FAILS = []
+
+
+def ok(cond, label):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  [PASS] {label}")
+    else:
+        FAIL += 1
+        FAILS.append(label)
+        print(f"  [FAIL] {label}")
+
+
+def _digest(cg, nid):
+    e = cg.index["nodes"][nid]
+    with open(os.path.join(cg.root, e["path"]), "rb") as f:
+        return hashlib.sha256(f.read()).hexdigest()
+
+
+def _patch(cg, nid, fm):
+    """直接改写节点 frontmatter（模拟「重要性漂移」），同步索引快照。"""
+    e = cg.index["nodes"][nid]
+    node = cg.get(nid)
+    f = dict(node["frontmatter"])
+    f.update(fm)
+    cg._write_node(nid, os.path.join(cg.root, e["path"]), f,
+                   node.get("content") or "")
+    e["importance"] = f.get("importance", e.get("importance"))
+
+
+def main():
+    print("md 认知图 P41 验收 · G7 自主演化巡检（只读盘点 + 受控自愈）")
+    print("=" * 70)
+    net = tempfile.mkdtemp(prefix="mdcg_p41_net_")
+    os.environ["MDCG_SUSTAIN_DIR"] = net
+    root = None
+    try:
+        root = tempfile.mkdtemp(prefix="mdcg_p41_")
+        cg = MdCG(root)
+        cg.add("n_a", "# 功能名：甲\n# 生效条件：条件 A\n\n正文甲的说明。",
+               tags=["g7"])
+        cg.add("n_b", "# 功能名：乙\n# 生效条件：条件 B\n\n正文乙的说明。",
+               tags=["g7"])
+        cg.add("n_c", "# 功能名：丙\n# 生效条件：条件 C\n\n正文丙的说明。",
+               tags=["g7"])
+        cg.rebuild_index()
+
+        # ------------------------------------------------ ① 契约链
+        print("\n【1】契约链（防「能力在、入口无」）")
+        tool = next(t for t in KERNEL_TOOLS if t["name"] == "cg")
+        prop = tool["inputSchema"]["properties"]
+        desc = (tool["description"] + prop["op"]["description"]
+                + prop["action"]["description"])
+        ok("evolve" in desc, "①sustain 契约描述含 evolve")
+        for k in ("allow_evolve", "auto_evolve", "evolve_interval"):
+            ok(k in prop, f"①schema 声明 {k}")
+        cat = call_tool(cg, "cg", {"op": "sustain", "action": "catalog"})
+        ok("evolve" in cat["actions"], "①catalog 列出 evolve")
+        ok(cat["evolve_fixes"] == {"ccg_backlog": "consolidate_run",
+                                   "importance_drift": "importance"},
+           "①候补项→修复动作映射显式声明")
+        ok(cat["evolve_interval"] == sustain.DEFAULT_EVOLVE_INTERVAL,
+           "①演化巡检间隔有默认值（不再靠人工想起来）")
+
+        # ------------------------------------------------ ② 只读盘点
+        print("\n【2】只读盘点（零写盘 / 零改节点 / 代理指标显式）")
+        before = {nid: _digest(cg, nid) for nid in cg.index["nodes"]}
+        ev = call_tool(cg, "cg", {"op": "sustain", "action": "evolve"})
+        after = {nid: _digest(cg, nid) for nid in cg.index["nodes"]}
+        ok(ev["readonly"] is True and ev["dry_run"] is True,
+           "②标 readonly/dry_run")
+        ok(before == after, "②节点逐字节不变")
+        ok(ev["ccg_backlog"]["proxy"] is True, "②固化候补标为索引代理指标")
+        ok(ev["ccg_backlog"]["n"] == 3, f"②3 条无验证基底/负条件（实测 {ev['ccg_backlog']['n']}）")
+        ok(ev["importance_drift"]["scanned"] == 3, "②重要性扫全库（索引级、不读文件）")
+        ok(ev["candidates"] == ev["ccg_backlog"]["n"] + ev["importance_drift"]["n"],
+           "②候补总量 = 各项之和")
+        ok(ev["by_fix"]["consolidate_run"] == ev["ccg_backlog"]["n"]
+           and ev["by_fix"]["importance"] == ev["importance_drift"]["n"],
+           "②按修复动作可归口")
+
+        # ------------------------------------------------ ③ 确定性
+        print("\n【3】确定性（可复核）")
+        ev2 = sustain.evolution_candidates(cg, top=3)
+        ok(ev2["ccg_backlog"]["n"] == ev["ccg_backlog"]["n"]
+           and ev2["importance_drift"]["n"] == ev["importance_drift"]["n"],
+           "③两次盘点候选数一致")
+
+        # ------------------------------------------------ ④ 诊断集成
+        print("\n【4】诊断集成（候补多 ≠ 库有毛病）")
+        dg = call_tool(cg, "cg", {"op": "sustain", "action": "diagnose"})
+        ok(dg["evolve"] is not None
+           and dg["stats"]["evolve_candidates"] == ev["candidates"],
+           "④diagnose 带 evolve 段与 stats")
+        codes = {i["code"]: i for i in dg["issues"]}
+        ok("ccg_backlog" in codes and codes["ccg_backlog"]["severity"] == "info",
+           "④固化候补以 info 级呈现（不是故障）")
+        ok(codes["ccg_backlog"]["fix"] == "consolidate_run"
+           and codes["ccg_backlog"]["proxy"] is True, "④issue 带 fix 与代理标记")
+        ok("importance_drift" in codes and codes["importance_drift"]["severity"] == "info",
+           "④重要性漂移 issue")
+        ok(dg["ok"] is True, "④候补多不翻转 ok（无 warning）")
+
+        # ------------------------------------------------ ⑤ 自愈默认关闭
+        print("\n【5】自愈默认关闭（不显式放行就不动）")
+        hl = call_tool(cg, "cg", {"op": "sustain", "action": "heal"})
+        acts = {a["code"]: a for a in hl["actions"]}
+        ok(acts["consolidate_run"]["applied"] is False
+           and acts["consolidate_run"]["reason"] == "needs_llm",
+           "⑤固化候补不自动执行（需 LLM）")
+        ok(acts["importance"]["applied"] is False
+           and acts["importance"]["reason"] == "evolve_disabled",
+           "⑤重要性重算默认关闭")
+        ok({nid: _digest(cg, nid) for nid in cg.index["nodes"]} == before,
+           "⑤heal 未改任何节点")
+
+        # ------------------------------------------------ ⑥ 受控放行
+        print("\n【6】受控放行（只放确定性动作，且漂移归零）")
+        _patch(cg, "n_a", {"importance": 0.99})
+        ok(W.recalc(cg)["changed"] >= 1, "⑥制造漂移（n_a 手工置 0.99）")
+        hl2 = call_tool(cg, "cg", {"op": "sustain", "action": "heal",
+                                   "allow_evolve": True})
+        acts2 = {a["code"]: a for a in hl2["actions"]}
+        ok(acts2["importance"]["applied"] is True
+           and acts2["importance"]["ok"] is True,
+           "⑥重要性重算被放行且执行成功")
+        ok(W.recalc(cg)["changed"] == 0, "⑥漂移归零（收敛）")
+        ok(acts2["consolidate_run"]["applied"] is False,
+           "⑦LLM 依赖的固化仍不自动跑")
+
+        # ------------------------------------------------ ⑧ 循环挂载
+        print("\n【8】常驻循环挂载（默认只记账）")
+        lp = sustain.ensure_loop(cg, "p41loop", beat_interval=0.05,
+                                 heal_interval=0.05, scrub_interval=0.05,
+                                 evolve_interval=0.05, auto_evolve=False, d=net)
+        lp.start()
+        time.sleep(0.8)
+        ok(lp.last_evolve is not None, "⑧演化巡检周期触发")
+        ok(lp.last_evolve["applied"] == [], "⑧auto_evolve=False → 只记账不动库")
+        ok(lp.status()["evolve_interval"] == 0.05
+           and lp.status()["auto_evolve"] is False, "⑧status 暴露演化字段")
+        ok(sustain.summary(cg)["evolve"]["candidates"] >= 0, "⑧summary 含演化摘要")
+        lp.stop()
+
+        # ------------------------------------------------ ⑨ 失败不拖垮常驻
+        print("\n【9】巡检失败不拖垮常驻")
+        orig = W.recalc
+        W.recalc = lambda *a, **k: (_ for _ in ()).throw(RuntimeError("boom"))
+        try:
+            lp2 = sustain.ensure_loop(cg, "p41boom", beat_interval=0.05,
+                                      heal_interval=99.0, scrub_interval=99.0,
+                                      evolve_interval=0.05, d=net)
+            lp2.start()
+            time.sleep(0.6)
+            ok(lp2.status()["running"] is True, "⑨循环仍存活")
+            ok(lp2.beats >= 2, f"⑨心跳照常（beats={lp2.beats}）")
+            ok(lp2.last_evolve is None, "⑨失败巡检不写脏记录")
+            lp2.stop()
+        finally:
+            W.recalc = orig
+        ok(sustain.evolution_candidates(cg)["importance_drift"]["n"] >= 0,
+           "⑨恢复后巡检可用")
+
+        # ------------------------------------------------ ⑩ 未知 action
+        print("\n【10】未知 action 不静默成功")
+        try:
+            call_tool(cg, "cg", {"op": "sustain", "action": "evolve_x"})
+            ok(False, "⑩必须报错")
+        except ValueError as e:
+            ok("未知 action" in str(e), "⑩未知 action 报错")
+    finally:
+        os.environ.pop("MDCG_SUSTAIN_DIR", None)
+        sustain.stop_all()
+        for d in (net, root):
+            if d:
+                shutil.rmtree(d, ignore_errors=True)
+
+    print("\n" + "=" * 70)
+    print(f"P41 结果：PASS {PASS} / FAIL {FAIL}")
+    if FAILS:
+        print("未通过：" + "；".join(FAILS))
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(main())