@furongjun1999/dsh-memory 0.4.7 → 0.4.9

package/md_cg/test_blindspot_tickets.py

@@ -0,0 +1,166 @@
+# -*- coding: utf-8 -*-
+"""盲区消解票据（blindspot_tickets.make_tickets）验证。
+
+断言面：
+  ① 空库诚实：无反思记录 → 零票据、零落库（不编造消解价值）
+  ② 预演：apply=False 全 dry_run、零落库
+  ③ 四类分类：task（query 精确命中 unresolved 首行，优先级最高）/
+     grilling（defer 主导）/ research（blindspot>=3）/ prototype（其余）
+  ④ apply 落卡：tasks.list_tasks 可见、tags 带 ticket:<type>
+  ⑤ 幂等：重复 apply → created=0、updated=4（不重复建卡）
+  ⑥ types 仅作分类后落卡过滤（判据恒定不变）
+  ⑦ 非法 types → ok=False、零落库
+  ⑧ grilling 卡如实声明「执行通道=宿主侧访谈」（库内无访谈工具，不越权代答）
+  ⑨ task 卡正文携带关联 unresolved node_id
+  ⑩ min_blindspot 候选资格过滤（b 低且无 defer 的簇不入池）
+
+运行：python -m md_cg.test_blindspot_tickets
+"""
+from __future__ import annotations
+
+import os
+import tempfile
+
+from . import blindspot_tickets, tasks
+from .fsutil import append_jsonl
+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 _sig(cg, t, query, states):
+    """直写一条反思记录（与 test_autonomy 同构先例：只造信号面，不动检索面）。"""
+    append_jsonl(cg.reflection_log,
+                 {"t": t, "query": query, "d_prev": 1.0, "d_curr": 1.0,
+                  "d_delta": 0.0, "d2": 0.1, "states": states,
+                  "n_results": 1, "feedback": None})
+
+
+def _card(cg, ttype, q):
+    nid = tasks.TASK_PREFIX + tasks.slugify("票据:%s:%s" % (ttype, q[:24]))
+    node = cg.get(nid) or {}
+    return node, nid
+
+
+def main():
+    tmp = tempfile.mkdtemp(prefix="mdcg_tickets_")
+    try:
+        root = os.path.join(tmp, "root")
+        os.makedirs(root, exist_ok=True)
+        cg = MdCGOS(root)
+
+        Q_R = "如何审计蜂巢的 gossip 收敛性"   # blindspot×3 → research
+        Q_G = "上次说的那个修复方案细节"       # defer×2     → grilling
+        Q_P = "数据迁移的回滚口径"             # blindspot×1 → prototype
+        Q_T = "跨库事务一致性边界"             # blindspot×1 + unresolved 首行命中 → task
+
+        # ---------- ① 空库诚实 ----------
+        r0 = blindspot_tickets.make_tickets(cg)
+        ok(r0["ok"] and r0["scanned"] == 0 and r0["created"] == 0
+           and not r0["tickets"],
+           "①空反思日志 → 零票据（不编造消解价值）")
+        r0a = blindspot_tickets.make_tickets(cg, apply=True)
+        ok(r0a["ok"] and r0a["created"] == 0 and len(tasks.list_tasks(cg)["tasks"]) == 0,
+           "①b空库 apply → 零落卡")
+
+        # ---------- ② 造四类信号（t 递增：task/prototype 同 b，last_t 定序） ----------
+        t = 1.0
+        for i in range(3):
+            t += 1
+            _sig(cg, t, Q_R, {"BLINDSPOT": 1})
+        for i in range(2):
+            t += 1
+            _sig(cg, t, Q_G, {"DEFER": 1})
+        _sig(cg, 10.0, Q_P, {"BLINDSPOT": 1})
+        _sig(cg, 11.0, Q_T, {"BLINDSPOT": 1})
+        cg.add("t_unres", Q_T + "\n悬挂：等待架构裁决", layer="unresolved")
+
+        # ---------- ③ 预演 ----------
+        dry = blindspot_tickets.make_tickets(cg)
+        ok(dry["ok"] and dry["scanned"] == 4 and dry["applied"] is False,
+           "③四簇入池、预演不落库")
+        by_q = {tk["query"]: tk for tk in dry["tickets"]}
+        ok(all(tk.get("dry_run") for tk in dry["tickets"]),
+           "③b预演票据全 dry_run 标记")
+        ok(len(tasks.list_tasks(cg)["tasks"]) == 0,
+           "③c预演零落库")
+        ok(by_q[Q_T]["type"] == "task" and by_q[Q_R]["type"] == "research"
+           and by_q[Q_G]["type"] == "grilling" and by_q[Q_P]["type"] == "prototype",
+           "③d四类分类各就位（task 判据优先于 b/d 计数）")
+
+        # ---------- ④ apply 落卡 ----------
+        r1 = blindspot_tickets.make_tickets(cg, apply=True, actor="test")
+        ok(r1["ok"] and r1["created"] == 4 and r1["errors"] == 0,
+           "④apply 建 4 卡、零错误")
+        lt = tasks.list_tasks(cg, status="active")
+        ok(len(lt["tasks"]) == 4, "④b任务清单可见 4 张 active 卡")
+        tags_ok = True
+        for ttype, q in (("research", Q_R), ("grilling", Q_G),
+                         ("prototype", Q_P), ("task", Q_T)):
+            node_i, _ = _card(cg, ttype, q)
+            fm_i = (node_i or {}).get("frontmatter") or {}
+            if "ticket:%s" % ttype not in (fm_i.get("tags") or []):
+                tags_ok = False
+        ok(tags_ok, "④c四卡 fm tags 带 ticket:<type> 族标")
+        # 分类落卡实体抽查
+        node_r, _ = _card(cg, "research", Q_R)
+        ok(node_r and "ticket:research" in (node_r["frontmatter"].get("tags") or []),
+           "④dresearch 卡以 ticket:research 落库")
+
+        # ---------- ⑤ 幂等 ----------
+        r2 = blindspot_tickets.make_tickets(cg, apply=True)
+        ok(r2["ok"] and r2["created"] == 0 and r2["updated"] == 4,
+           "⑤重复 apply → created=0、updated=4（同 slug 不重复建卡）")
+        ok(len(tasks.list_tasks(cg)["tasks"]) == 4, "⑤b卡数不增")
+
+        # ---------- ⑥ types 过滤（仅过滤，不改判据） ----------
+        r3 = blindspot_tickets.make_tickets(cg, types=["research"], apply=True)
+        tk3 = {tk["query"]: tk for tk in r3["tickets"]}
+        ok(r3["ok"] and tk3[Q_R].get("node_id") and tk3[Q_G].get("skipped")
+           and tk3[Q_T].get("skipped") and tk3[Q_P].get("skipped"),
+           "⑥types=research → 其余三类 skipped（判据未被 types 改写）")
+        ok(tk3[Q_R].get("created") is False,
+           "⑥bresearch 卡幂等更新（created=False，重复过滤轮不重复建）")
+
+        # ---------- ⑦ 非法 types ----------
+        r4 = blindspot_tickets.make_tickets(cg, types=["nope"], apply=True)
+        ok(r4["ok"] is False and "nope" in r4["error"]
+           and len(tasks.list_tasks(cg)["tasks"]) == 4,
+           "⑦非法类型 → ok=False 点名可选集、零落库")
+
+        # ---------- ⑧⑨ 卡正文边界与关联 ----------
+        node_g, _ = _card(cg, "grilling", Q_G)
+        plan_g = node_g["content"] if node_g else ""
+        ok(node_g and "宿主侧访谈" in plan_g and "不越权代答" in plan_g,
+           "⑧grilling 卡如实声明执行通道=宿主侧访谈")
+        node_t, _ = _card(cg, "task", Q_T)
+        plan_t = node_t["content"] if node_t else ""
+        ok(node_t and "t_unres" in plan_t and "关联悬挂" in plan_t,
+           "⑨task 卡携带关联 unresolved node_id")
+
+        # ---------- ⑩ min_blindspot 资格过滤 ----------
+        r5 = blindspot_tickets.make_tickets(cg, min_blindspot=3)
+        qs5 = {tk["query"] for tk in r5["tickets"] if not tk.get("skipped")}
+        ok(Q_R in qs5 and Q_G in qs5 and Q_P not in qs5 and Q_T not in qs5,
+           "⑩min_blindspot=3 → 仅 research(b=3) 与 grilling(d≥1) 入池")
+
+        print("[test_blindspot_tickets] PASS=%d FAIL=%d" % (PASS, FAIL))
+        if FAILS:
+            raise SystemExit(1)
+    finally:
+        pass
+
+
+if __name__ == "__main__":
+    main()

package/md_cg/test_branches.py

@@ -0,0 +1,249 @@
+# -*- coding: utf-8 -*-
+"""记忆演化分支（branches，Pi 移植④）验收：交接文档 §3④。
+
+蓝图验收两条：
+① fork → 分支改写 → merge 后主支节点 derived_from 链完整可回溯；
+② 放弃分支不污染主支检索（召回主支时分支节点零命中）。
+"""
+
+import os
+import shutil
+import sys
+import tempfile
+import traceback
+
+from . import branches
+from .mdcos import MdCGSecure
+from .security import AccessDenied, Principal
+
+_ok = 0
+_bad = []
+
+
+def _check(name, cond, detail=""):
+    global _ok
+    if cond:
+        _ok += 1
+        print("  ok   %s" % name)
+    else:
+        _bad.append("%s %s" % (name, detail))
+        print("  FAIL %s %s" % (name, detail))
+
+
+def _mk_cg(tmp, role="designer", seq=[0]):
+    seq[0] += 1
+    root = os.path.join(tmp, "root_%02d_%s" % (seq[0], role))
+    p = Principal(tenant="default", actor="t_" + role, role=role,
+                  can_write=(role != "guest"),
+                  can_admin=(role == "designer"))
+    return MdCGSecure(root, principal=p)
+
+
+def _fm(cg, nid):
+    rec = cg.get(nid) or {}
+    return rec.get("frontmatter") or {}
+
+
+def _content(cg, nid):
+    return ((cg.get(nid) or {}).get("content") or "").strip()
+
+
+def _hits(cg, q, **kw):
+    """命中集 id 清单（零污染断言的口径：分支 nid 不出现，而非结果为空——
+    T3 全扫兜底本就会返回低分主支节点，那是检索器既有行为不是污染）。"""
+    return [h[0].get("id") for h in cg.search(q, **kw)[0]]
+
+
+def main():
+    tmp = tempfile.mkdtemp(prefix="branches_")
+    try:
+        _run(tmp)
+    except Exception:
+        traceback.print_exc()
+        _bad.append("未捕获异常")
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+    print("\nbranches 验收：%d 通过%s" % (
+        _ok, ("，%d 失败：%s" % (len(_bad), "; ".join(_bad))) if _bad else ""))
+    return 1 if _bad else 0
+
+
+def _run(tmp):
+    # ---------- 1 fork：副本血缘 + 防呆 + 幂等 ----------
+    cg = _mk_cg(tmp)
+    cg.add("mem_a", "A内容alpha", layer="knowledge", verification_basis="test",
+           consistency=False)
+    cg.add("mem_b", "B内容beta", layer="contextual", verification_basis="test",
+           consistency=False, derived_from=["anc1"], relation="merged_from")
+    r = branches.fork(cg, ["mem_a", "mem_b"], branch_id="exp1", note="实验一")
+    _check("fork成功", r.get("ok") is True and r.get("branch_id") == "exp1",
+           repr(r))
+    fm_a = _fm(cg, "mem_a@exp1")
+    _check("副本血缘", fm_a.get("branch_id") == "exp1"
+           and fm_a.get("branched_from") == "mem_a"
+           and fm_a.get("derived_from") == ["mem_a"]
+           and fm_a.get("derived_relation") == "split_from", repr(fm_a))
+    _check("副本内容继承", _content(cg, "mem_a@exp1") == "A内容alpha")
+    _check("fork空入参拒", branches.fork(cg, []).get("ok") is False)
+    _check("fork非法id拒", branches.fork(
+        cg, ["mem_a"], branch_id="BAD ID!").get("ok") is False)
+    r2 = branches.fork(cg, ["mem_a", "mem_a", "mem_c"], branch_id="exp1")
+    _check("fork幂等skipped", r2.get("ok") is False
+           and len([s for s in r2.get("skipped", [])
+                    if "已存在" in s.get("why", "")]) == 2
+           and len([s for s in r2.get("skipped", [])
+                    if "不存在" in s.get("why", "")]) == 1, repr(r2))
+
+    # ---------- 2 蓝图验收②：主支检索零污染 ----------
+    # 分支上改写副本走 rewrite（唯一正路）——add 是全量重建 fm，裸 add
+    # 不重传 branch_id 会让副本在索引里退化成主支（实验泄漏进主支检索）。
+    rr = branches.rewrite(cg, "mem_a@exp1", "A改写exp版")
+    _check("rewrite改写成功", rr.get("ok") is True
+           and rr.get("branch_id") == "exp1", repr(rr))
+    # rewrite 防呆：非分支/不存在拒；归属与血缘不可篡改（extra 伪造键被剥离）
+    _check("rewrite非分支拒", branches.rewrite(
+        cg, "mem_a", "x").get("ok") is False)
+    _check("rewrite不存在拒", branches.rewrite(
+        cg, "mem_z@exp1", "x").get("ok") is False)
+    branches.rewrite(cg, "mem_a@exp1", "A改写exp版", branch_id="伪造",
+                     branched_from="mem_zzz", derived_from=["fake"])
+    fm_rr = _fm(cg, "mem_a@exp1")
+    _check("rewrite归属不可篡改", fm_rr.get("branch_id") == "exp1"
+           and fm_rr.get("branched_from") == "mem_a"
+           and fm_rr.get("derived_from") == ["mem_a"], repr(fm_rr))
+    _check("主支检索分支内容零命中",
+           "mem_a@exp1" not in _hits(cg, "A改写exp版"),
+           repr(_hits(cg, "A改写exp版")))
+    _check("主支检索原内容仍命中", bool(cg.search("A内容alpha")[0]))
+    _check("分支内检索命中改写",
+           bool(branches.search(cg, "A改写exp版", "exp1")[0]),
+           repr(branches.search(cg, "A改写exp版", "exp1")))
+    _check("分支内检索主支也可见",
+           bool(branches.search(cg, "B内容beta", "exp1")[0]))
+    # 其他分支互不可见（用各自独有内容词验：对方分支 nid 不在命中集）
+    branches.fork(cg, ["mem_a"], branch_id="exp2")
+    branches.rewrite(cg, "mem_a@exp2", "A改写exp2版")
+    h_e1 = [h[0].get("id") for h in branches.search(cg, "A改写exp2版",
+                                                    "exp1")[0]]
+    h_e2 = [h[0].get("id") for h in branches.search(cg, "A改写exp版",
+                                                    "exp2")[0]]
+    _check("跨分支隐身",
+           "mem_a@exp2" not in h_e1 and "mem_a@exp1" not in h_e2,
+           "e1=%r e2=%r" % (h_e1, h_e2))
+
+    # ---------- 3 蓝图验收①：merge 溯源链完整 ----------
+    r = branches.merge(cg, "exp1", reason="实验通过")
+    _check("merge成功", r.get("ok") is True and len(r.get("merged", [])) == 2,
+           repr(r))
+    _check("主支内容已回写", _content(cg, "mem_a") == "A改写exp版")
+    fm_a = _fm(cg, "mem_a")
+    chain = fm_a.get("derived_from") or []
+    _check("主支链追加分支且原链保留",
+           "mem_a@exp1" in chain
+           and fm_a.get("derived_relation") == "merged_from"
+           and fm_a.get("merged_from_branch") == "exp1", repr(fm_a))
+    anc = _fm(cg, "mem_b").get("derived_from") or []
+    _check("原链保留(mem_b)", "anc1" in anc and "mem_b@exp1" in anc, repr(anc))
+    _check("merge后主支检索命中回写", bool(cg.search("A改写exp版")[0]))
+    _check("merge幂等安全", branches.merge(cg, "exp1").get("ok") is True
+           and _content(cg, "mem_a") == "A改写exp版")
+    r = branches.merge(cg, "br_void")
+    _check("merge空分支拒", r.get("ok") is False)
+
+    # merge 时主支不可达 → skipped 不炸（索引与脏缓存一并摘除才是完整模拟）
+    cg2 = _mk_cg(tmp)
+    cg2.add("mem_x", "X内容", layer="knowledge", verification_basis="test",
+            consistency=False)
+    branches.fork(cg2, ["mem_x"], branch_id="orphan")
+    (cg2.index["nodes"]).pop("mem_x", None)
+    (cg2._dirty or {}).pop("mem_x", None)
+    r = branches.merge(cg2, "orphan")
+    _check("merge主支缺失skipped", r.get("ok") is False
+           and len(r.get("skipped", [])) == 1, repr(r))
+
+    # ---------- 4 discard：教训必填 + 冷归档 + 权限 ----------
+    cg3 = _mk_cg(tmp)
+    cg3.add("mem_k", "K内容", layer="knowledge", verification_basis="test",
+            consistency=False)
+    branches.fork(cg3, ["mem_k"], branch_id="dead")
+    branches.rewrite(cg3, "mem_k@dead", "K改写dead版")
+    r = branches.discard(cg3, "dead", "假设有错，教训：不要急")
+    _check("discard缺标记拒", r.get("ok") is False
+           and set(r.get("missing", [])) == {"分支假设", "实验结果"}
+           and r.get("required") == list(branches.BRANCH_MARKS), repr(r))
+    # guest 无 can_admin → 结构性拒绝（guest 无写权建不了节点，
+    # 分支由 designer 建好并 flush 后，guest 开同一 root 只试 discard）
+    branches.fork(cg3, ["mem_k"], branch_id="guest_br")
+    cg3.flush()
+    cg_guest = MdCGSecure(cg3.root,
+                          principal=Principal(tenant="default",
+                                              actor="t_guest", role="guest",
+                                              can_write=False,
+                                              can_admin=False))
+    try:
+        branches.discard(cg_guest, "guest_br",
+                         "分支假设x 实验结果y 教训z")
+        _check("discard需can_admin", False, "guest 未被拒")
+    except AccessDenied:
+        _check("discard需can_admin", True)
+    except Exception as e:  # noqa: BLE001
+        _check("discard需can_admin", False,
+               "异常=%s:%s" % (type(e).__name__, e))
+    # designer 全流程
+    r = branches.discard(cg3, "dead",
+                         "分支假设：覆盖写更快 实验结果：丢失血缘 教训：血缘必保留")
+    _check("discard成功", r.get("ok") is True and r.get("moved") == 1, repr(r))
+    _check("教训节点入库", bool(_fm(cg3, "branch_summary_dead")))
+    _check("教训节点可检索", bool(cg3.search("血缘必保留")[0]),
+           repr(cg3.search("血缘必保留")))
+    cold = os.path.join(cg3.root, branches.COLD_DIR, "dead",
+                        "mem_k@dead.md")
+    _check("分支文件冷区保留", os.path.exists(cold), cold)
+    _check("索引已摘除", "mem_k@dead" not in cg3.index["nodes"])
+    _check("list_branches已不含", all(
+        b.get("branch_id") != "dead"
+        for b in branches.list_branches(cg3).get("branches", [])))
+    _check("discard空分支拒",
+           branches.discard(cg3, "dead", "分支假设a 实验结果b 教训c").get("ok")
+           is False)
+
+    # ---------- 5 list_branches 聚合 + insight act 分派冒烟 ----------
+    cg4 = _mk_cg(tmp)
+    cg4.add("mem_p", "P内容", layer="knowledge", verification_basis="test",
+            consistency=False)
+    branches.fork(cg4, ["mem_p"], branch_id="live1")
+    lst = branches.list_branches(cg4)
+    g = {b.get("branch_id"): b for b in lst.get("branches", [])}.get("live1")
+    _check("list_branches聚合", g is not None and g.get("nodes") == ["mem_p@live1"]
+           and g.get("branched_from") == ["mem_p"], repr(lst))
+    r = cg4.insight("fork", node_ids=["mem_p"], branch_id="live2", note="n")
+    _check("insight act=fork", r.get("ok") is True
+           and r.get("branch_id") == "live2", repr(r))
+    r = cg4.insight("branches")
+    _check("insight act=branches", r.get("ok") is True
+           and len(r.get("branches", [])) == 2, repr(r))
+    r = cg4.insight("branch_rewrite", node_id="mem_p@live2", content="P内容v2")
+    _check("insight act=branch_rewrite", r.get("ok") is True
+           and _content(cg4, "mem_p@live2") == "P内容v2", repr(r))
+    r = cg4.insight("branch_search", content="P内容v2", branch_id="live2")
+    _check("insight act=branch_search", bool(r[0]), repr(r))
+    r = cg4.insight("branch_merge", branch_id="live2", reason="r")
+    _check("insight act=branch_merge", r.get("ok") is True
+           and _content(cg4, "mem_p") == "P内容v2", repr(r))
+    r = cg4.insight("branch_discard", branch_id="live2",
+                    content="分支假设p 实验结果q 教训r")
+    _check("insight act=branch_discard", r.get("ok") is True, repr(r))
+
+    # ---------- 6 session 过滤正交不回归 ----------
+    cg5 = _mk_cg(tmp)
+    cg5.add("mem_s1", "会话一内容", layer="knowledge", verification_basis="test",
+            consistency=False)
+    branches.fork(cg5, ["mem_s1"], branch_id="sx")
+    res, meta = cg5.search("会话一内容", session="sess_zzz")
+    _check("session过滤与branch过滤正交", not res, repr(res))
+    res, meta = cg5.search("会话一内容")
+    _check("默认检索主支正常", bool(res), repr(meta))
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_ccg_perturb.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 """条件扰动反事实实验（P-T-42/43 · 理论仓 §15 命题的可执行化）。
 
-理论命题（docs/智能的公理化基石.md §15 + 附录二可证伪标准）：
+理论命题（docs/theory/智能的公理化基石.md §15 + 附录二可证伪标准）：
   「如果保持候选能力不变，只改变条件词，路由归属按条件发生变化，
     那么路由控制因素就是条件，而不是单纯的语义相似度。」
   可证伪口径：在保持候选能力不变、仅改变条件词的实验中，