@furongjun1999/dsh-memory 0.4.4 → 0.4.6

package/md_cg/test_p44_md_whitebox.py

@@ -0,0 +1,218 @@
+# -*- coding: utf-8 -*-
+"""P44 · md 原生知识库的白箱问答（端到端实测）。
+
+验证目标
+--------
+1) 结构等价：md 语料还原库与源库 nodes / edges 计数一致（4355 / 2948）；
+2) **数据等价**：逐题比较 `dex_respond` 的**全量候选集**（name+score）——
+   这是「md 语料 = 源库知识」的硬证据，不受 top-N 截断与排序影响；
+3) **端到端一致**：同一批实际问题上，md 库与源库的 `chat` 回答
+   （route / 命中卡 / 分值）逐题一致；同分并列单独标注（排序取决于
+   表的物理顺序，非数据差异）；
+4) 效果报告：打印每题的 route、命中卡、回答摘要，供人工评估。
+
+源库保护
+--------
+对比跑在源库的**临时副本**上：白箱问答会 `increment_access` 写库，
+绝不能污染随包的只读 `wisdom-book-cloud.db`。
+
+运行：`python -m md_cg.test_p44_md_whitebox`
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import sqlite3
+import sys
+import tempfile
+
+_HERE = os.path.dirname(os.path.abspath(__file__))
+
+from .md_whitebox import build_db_from_md  # noqa: E402
+
+SOURCE_DB = os.path.join(_HERE, "whitebox_kb", "wisdom", "wisdom-book-cloud.db")
+
+#: 20 题实际题库：口语提问 × 跨域，覆盖白箱各条确定性检索通路。
+QUESTIONS = [
+    # —— 翻译表（俗语 → 规范知识词）
+    "水烧开是什么现象",
+    "为什么会打雷",
+    "铁球和羽毛谁落得快",
+    "天空为什么是蓝的",
+    # —— 学科术语直配
+    "什么是熵",
+    "什么是勾股定理",
+    "什么是光合作用",
+    "什么是质数",
+    # —— 极短 / 单字学科词
+    "熵",
+    # —— 领域知识点卡（KCCS 注释索引）
+    "古巴比伦有什么文明成就",
+    "秦始皇是谁",
+    "月亮为什么会有阴晴圆缺",
+    "什么是通货膨胀",
+    # —— 英文缩写
+    "什么是TCP三次握手",
+    "KKT条件是什么",
+    # —— 系统概念（含「定律」先验）
+    "光的反射定律是什么",
+    "一天有多少小时",
+    # —— 元层 / 理论
+    "什么是条件论",
+    "什么是存在论",
+    # —— 诚实边界（白箱应拒答或降级，而非编造）
+    "外星人存在吗",
+]
+
+
+def _probe(db_path, questions, label):
+    """在同一引擎上顺序提问，返回逐题结果。
+
+    两库按**同题同序**跑，access 累积轨迹相同，故对比公平。
+    候选集用 `dex_respond`（全库打分，不被 graph_retrieve 的
+    top-N 早返回截断），端到端用 `chat`（真实入口）。
+    """
+    from .whitebox_kb.engine import WhiteboxEngine  # 先导入：注入 sys.path
+    import semantic_translate as _st  # noqa: E402 —— 平铺导入，需上行先执行
+
+    eng = WhiteboxEngine(db_path=db_path, seed=False)
+    out = []
+    try:
+        dex = eng.dex
+        for q in questions:
+            try:
+                # limit 放大到不截断：截断会让「同分并列」的保留集合
+                # 取决于排序，从而把排序差异误判成数据差异。
+                _hits = dex.dex_respond(q, limit=10 ** 6, translator=_st)
+                _c = {}
+                for h in _hits:
+                    _sc = round(float(h.get("score") or 0), 4)
+                    _c.setdefault(_sc, set()).add(h.get("name") or "")
+                cand = {k: frozenset(v) for k, v in _c.items()}
+            except Exception as exc:  # 诊断用：不掩盖底层异常
+                cand = {"__error__": frozenset([f"{type(exc).__name__}: {exc}"])}
+            res = eng.chat(q, session_id=f"p44-{label}")
+            hits = res.get("hits") or []
+            top = hits[0] if hits else {}
+            out.append({
+                "q": q, "cand": cand,
+                "route": res.get("route") or "",
+                "top": top.get("name") or "",
+                "score": (round(float(top.get("score") or 0), 4)
+                          if hits else None),
+                "matched": list(top.get("matched") or []),
+                "reply": (res.get("reply") or "").strip(),
+            })
+    finally:
+        eng.close()
+    return out
+
+
+def _count(db_path, table):
+    con = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
+    try:
+        return int(con.execute(f"SELECT COUNT(*) FROM {table}").fetchone()[0])
+    finally:
+        con.close()
+
+
+def _report(rows):
+    print(f"\n===== md 原生知识库 · 白箱回答（{len(rows)} 题） =====")
+    print(f"{'#':>2}  {'route':<14} {'score':>6}  {'命中卡':<28} 问题")
+    for i, r in enumerate(rows, 1):
+        print(f"{i:>2}  {r['route']:<14} {str(r['score']):>6}  "
+              f"{r['top'][:26]:<28} {r['q']}")
+        if r["reply"]:
+            print(f"      └─ {r['reply'][:140]}")
+
+
+def main():
+    ok = True
+
+    # ---- 1) 结构等价 ----
+    # force：从 md 语料**重新**还原，保证 access_count 等可变字段与源库快照
+    # 同起点（复用旧库会带上此前问答累积的 access，造成假差异）。
+    md = build_db_from_md(force=True, verbose=False)
+    src_nodes, src_edges = _count(SOURCE_DB, "nodes"), _count(SOURCE_DB, "edges")
+    print(f"[结构] md 还原库  nodes={md['nodes']}  edges={md['edges']}")
+    print(f"[结构] 源库      nodes={src_nodes}  edges={src_edges}")
+    if (md["nodes"], md["edges"]) != (src_nodes, src_edges):
+        print("[FAIL] 结构不等价")
+        ok = False
+    else:
+        print("[PASS] 结构等价（nodes / edges 计数一致）")
+
+    # ---- 2) 跑两库（源库用临时副本，绝不写包内库） ----
+    tmp_dir = tempfile.mkdtemp(prefix="p44_src_")
+    tmp = os.path.join(tmp_dir, "src_copy.db")
+    shutil.copy2(SOURCE_DB, tmp)
+    try:
+        rows_md = _probe(md["db"], QUESTIONS, "md")
+        rows_src = _probe(tmp, QUESTIONS, "src")
+    finally:
+        shutil.rmtree(tmp_dir, ignore_errors=True)
+
+    # ---- 3) 数据等价：全量候选集逐一比对 ----
+    cand_bad = []
+    for a, b in zip(rows_md, rows_src):
+        if a["cand"] != b["cand"]:
+            cand_bad.append({"q": a["q"], "md": a["cand"], "src": b["cand"]})
+    print(f"\n[数据] 候选集逐题一致 {len(QUESTIONS) - len(cand_bad)}/{len(QUESTIONS)}"
+          f"（dex_respond 全量打分，不受排序影响）")
+    if cand_bad:
+        ok = False
+        print("[FAIL] md 库与源库候选集不一致：")
+        for d in cand_bad[:5]:
+            print(f"   {d['q']}")
+            for tag in ("md", "src"):
+                keys = sorted(d[tag], reverse=True)[:6]
+                print(f"     {tag:<3}: " + "; ".join(
+                    f"{k}={sorted(d[tag][k])[:3]}" for k in keys))
+    else:
+        print("[PASS] 数据等价（每题候选集完全相同）")
+
+    # ---- 4) 端到端一致：route / 命中卡 / 分值 ----
+    diff, parallel = [], []
+    for a, b in zip(rows_md, rows_src):
+        if a["route"] != b["route"]:
+            diff.append((a["q"], "route", a["route"], b["route"]))
+        elif a["score"] != b["score"]:
+            diff.append((a["q"], "score", a["score"], b["score"]))
+        elif a["top"] != b["top"]:
+            # 同分并列：两侧 top 都出现在对方候选集内且分值相同
+            # → 差异仅来自表的物理遍历顺序，非数据差异
+            _an = {n for ns in a["cand"].values() for n in ns}
+            _bn = {n for ns in b["cand"].values() for n in ns}
+            if (a["score"] == b["score"]
+                    and a["top"] in _bn and b["top"] in _an):
+                parallel.append((a["q"], a["top"], b["top"], a["score"]))
+            else:
+                diff.append((a["q"], "top", a["top"], b["top"]))
+    same = len(QUESTIONS) - len(diff) - len(parallel)
+    print(f"\n[行为] 严格一致 {same}/{len(QUESTIONS)}"
+          f" · 同分并列 {len(parallel)} · 不一致 {len(diff)}")
+    for q, md_top, src_top, sc in parallel:
+        print(f"   并列 {q}（同为 {sc}）：md={md_top} / src={src_top}")
+    if diff:
+        ok = False
+        print("[FAIL] 端到端不一致：")
+        for q, field, x, y in diff[:8]:
+            print(f"   {q} · {field}: md={x!r} vs src={y!r}")
+    else:
+        print("[PASS] 端到端一致（差异仅为同分并列的排序）")
+
+    # ---- 5) 效果报告 ----
+    _report(rows_md)
+    answered = [r for r in rows_md if r["reply"]]
+    print(f"\n[效果] 有回答 {len(answered)}/{len(QUESTIONS)}"
+          f" · route=self {sum(1 for r in rows_md if r['route'] == 'self')}"
+          f" · self_fallback "
+          f"{sum(1 for r in rows_md if r['route'] == 'self_fallback')}"
+          f" · 命中 KCCS 注释索引 "
+          f"{sum(1 for r in rows_md if 'KCCS注释索引' in r['matched'])}")
+    print("\n" + ("全部通过" if ok else "存在失败项"))
+    return 0 if ok else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_p45_session_identity.py

@@ -0,0 +1,220 @@
+# -*- coding: utf-8 -*-
+"""md_cg · 第 45 篇：嵌套身份归因与会话切片（(harness, session) 不参与授权）
+
+设计口径（设计者，2026-09-11）：
+  · 唯一设计者 = 外部用户；被授权端 codebuddy / dsh / zcode 是本机三个进程，
+    权限域一致（同一最高权限），区别只在单元分工（工程内容）；
+  · 身份靠 (harness, session) 归因，而不是靠多令牌/多实例提权；
+  · 会话产物落薄卡（单例）的 session 维度切片 + 富索引指针，卡本身仍是单例。
+
+覆盖：
+  A Principal 归因字段（harness/unit/session；与授权正交）
+  B _normalize_session：DSH 形态 + 目录存在 → 采用；不存在 → anonymous；
+    非 DSH 形态 → 采用；根可配置（MDCG_DSH_SESSIONS_ROOT）
+  C _apply_attribution：MDCG_SESSION / DSH_SESSION_ID / MDCG_HARNESS / MDCG_UNIT
+  D self_state 会话切片：refresh(session=) 登记维度 / summary(session=) 回报 /
+    单例卡语义不变 / 不覆盖显式维度
+  E 会话要点：session_note 缺省用 Principal.session；recall 带回会话自我切片
+  F 审计归因：_audit.jsonl 条目带 harness/unit
+  G MCP 入口：_self_state_call 缺省会话透传 + index 快捷反查
+
+运行：python -m md_cg.test_p45_session_identity
+"""
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+
+from .mdcos import MdCGOS, MdCGSecure
+from .security import Principal
+from . import self_state as ss
+from . import mcp_server as ms
+
+PASS = 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 _setenv(**kw):
+    old = {k: os.environ.get(k) for k in kw}
+    for k, v in kw.items():
+        if v is None:
+            os.environ.pop(k, None)
+        else:
+            os.environ[k] = v
+    return old
+
+
+def _restore(old):
+    for k, v in old.items():
+        if v is None:
+            os.environ.pop(k, None)
+        else:
+            os.environ[k] = v
+
+
+def main():
+    # ---------- A. Principal 归因字段 ----------
+    print("\n[A] Principal 归因字段（与授权正交）")
+    p0 = Principal(actor="a0")
+    check("A1 默认会话是进程随机 id", (p0.session or "").startswith("sess_"),
+          p0.session)
+    check("A2 harness/unit 默认为 None", p0.harness is None and p0.unit is None)
+    p1 = Principal(actor="a1", session="session-x", harness="dsh", unit="record",
+                   ops_allow=("read",))
+    d = p1.as_dict()
+    check("A3 as_dict 暴露 harness/unit/session",
+          d.get("harness") == "dsh" and d.get("unit") == "record"
+          and d.get("session") == "session-x")
+    check("A4 归因不影响授权（ops 仍按记录）",
+          p1.allows_op("read") and not p1.allows_op("write"))
+
+    # ---------- B. _normalize_session ----------
+    print("\n[B] 会话 id 归一与轻校验")
+    sdir = tempfile.mkdtemp(prefix="mdcg_p45_sess_")
+    # 人造 id：不得使用任何真实 DSH 会话 id，否则断言会依赖运行机器的磁盘现状
+    # （若该 id 恰好在 ~/.dsh/sessions 下存在，B5 的 fail-soft 断言会被偶然满足）。
+    sid = "session-deadbeef-6abc-4a71-a1f2-b658712be0fb"
+    os.makedirs(os.path.join(sdir, "--ws--", sid))
+    # 形态自检：id 若不满足 DSH 五段形态，B1/B5 会退化成「非 DSH 形态原样采用」
+    # 而仍然通过——断言落空且看不出来，故先钉死前提。
+    check("B0 测试用 id 满足 DSH 形态（防断言落空）", ms._is_dsh_session(sid))
+    old = _setenv(MDCG_DSH_SESSIONS_ROOT=sdir)
+    try:
+        check("B1 DSH 形态 + 目录存在 → 采用",
+              ms._normalize_session(sid) == sid)
+        check("B2 DSH 形态 + 目录不存在 → anonymous",
+              ms._normalize_session(
+                  "session-00000000-0000-0000-0000-000000000000") == "anonymous")
+        check("B3 非 DSH 形态 → 原样采用",
+              ms._normalize_session("dsl-web-main") == "dsl-web-main")
+        check("B4 空值 → anonymous", ms._normalize_session("") == "anonymous")
+    finally:
+        _restore(old)
+    # 必须显式指向「不存在的根」：若沿用默认根，在装了 DSH 的机器上根目录存在，
+    # 会落到「根可读但无该会话 → anonymous」分支，测不到 fail-soft（易假 PASS）。
+    old = _setenv(MDCG_DSH_SESSIONS_ROOT=os.path.join(sdir, "_no_such_root_"))
+    try:
+        check("B5 根不存在/不可读 → fail-soft（保留标记，不丢会话）",
+              ms._normalize_session(sid) == sid, "根不存在时不因环境差异丢弃会话标记")
+    finally:
+        _restore(old)
+
+    # ---------- C. _apply_attribution ----------
+    print("\n[C] 归因注入（MDCG_SESSION / DSH_SESSION_ID / HARNESS / UNIT）")
+    old = _setenv(MDCG_SESSION="dsl-web-main", DSH_SESSION_ID=None,
+                  MDCG_HARNESS="dsh", MDCG_UNIT="record")
+    try:
+        p = Principal(actor="a2")
+        ms._apply_attribution(p)
+        check("C1 MDCG_SESSION 优先", p.session == "dsl-web-main", p.session)
+        check("C2 harness/unit 注入",
+              p.harness == "dsh" and p.unit == "record")
+        # 原实现此处复述了 C1（测的仍是 MDCG_SESSION），未覆盖「后备不越权覆盖」。
+        old_dsh = _setenv(DSH_SESSION_ID="session-abc")
+        try:
+            pm = Principal(actor="a2b")
+            ms._apply_attribution(pm)
+            check("C3 两者并存时 MDCG_SESSION 优先（后备不覆盖）",
+                  pm.session == "dsl-web-main", pm.session)
+        finally:
+            _restore(old_dsh)
+    finally:
+        _restore(old)
+    old = _setenv(MDCG_SESSION=None, DSH_SESSION_ID="session-abc",
+                  MDCG_HARNESS=None, MDCG_UNIT=None)
+    try:
+        p = Principal(actor="a3")
+        ms._apply_attribution(p)
+        check("C4 无 MDCG_SESSION 时用 DSH_SESSION_ID",
+              p.session == "session-abc", p.session)
+        check("C5 无归因环境时保留进程随机 id",
+              (p := Principal()).session.startswith("sess_"))
+    finally:
+        _restore(old)
+
+    # ---------- D. self_state 会话切片 ----------
+    print("\n[D] 薄卡 + 会话维度切片（单例语义不变）")
+    root = tempfile.mkdtemp(prefix="mdcg_p45_")
+    SESS = ms._normalize_session("dsl-web-main")
+    cg = MdCGSecure(root, principal=Principal(
+        actor="dsh", session=SESS, harness="dsh", unit="record"))
+    r = cg.self_state_refresh(ss.DEFAULT_SUBJECT)
+    check("D1 refresh 缺省带会话维度",
+          bool(r.get("ok")) and SESS in (
+              (r.get("state") or {}).get("dimensions") or {}).get("session", []),
+          str(r.get("changed")))
+    card = cg.self_state_snapshot(ss.DEFAULT_SUBJECT)
+    check("D2 单例卡 id 未因会话改变",
+          card.get("node_id") == ss.state_node_id(ss.DEFAULT_SUBJECT))
+    summ = cg.self_state_summary(ss.DEFAULT_SUBJECT, session=SESS)
+    check("D3 summary 回报本会话已登记",
+          summ.get("session_registered") is True and summ.get("session") == SESS)
+    other = cg.self_state_summary(ss.DEFAULT_SUBJECT, session="session-other")
+    check("D4 其它会话未登记且指针为空",
+          other.get("session_registered") is False
+          and (other.get("session_refs") or {}).get("count") == 0)
+    r2 = cg.self_state_refresh(ss.DEFAULT_SUBJECT,
+                               dimensions={"session": ["manual-x"]})
+    dims = ((r2.get("state") or {}).get("dimensions") or {}).get("session", [])
+    check("D5 会话并入而不覆盖显式维度",
+          "manual-x" in dims and SESS in dims, str(dims))
+    check("D6 窄刷新仍以单例卡为准（同 subject 一张卡）",
+          cg.self_state_snapshot(ss.DEFAULT_SUBJECT).get("node_id")
+          == ss.state_node_id(ss.DEFAULT_SUBJECT))
+
+    # ---------- E. 会话要点 ----------
+    print("\n[E] 会话要点：缺省会话 = Principal.session")
+    n = cg.session_note("P45 会话要点：嵌套身份归因联调")
+    check("E1 session_note 缺省采用进程会话", n.get("session") == SESS,
+          str(n.get("session")))
+    rec = cg.session_recall(session=SESS, include_state=True)
+    check("E2 recall 命中本会话要点",
+          any(x.get("id") == n.get("id") for x in rec.get("notes") or []))
+    check("E3 recall 的自我状态带会话切片",
+          (rec.get("self_state") or {}).get("session") == SESS)
+
+    # ---------- F. 审计归因 ----------
+    print("\n[F] 审计归因（harness/unit 只入审计）")
+    with open(os.path.join(root, "_audit.jsonl"), encoding="utf-8") as f:
+        rows = [json.loads(x) for x in f if x.strip()]
+    last = rows[-1] if rows else {}
+    check("F1 审计条目带 harness", last.get("harness") == "dsh", str(last.get("op")))
+    check("F2 审计条目带 unit", last.get("unit") == "record")
+    check("F3 审计条目带会话", bool(last.get("session")))
+
+    # ---------- G. MCP 入口 ----------
+    print("\n[G] MCP 分发：会话缺省透传")
+    out = ms._self_state_call(cg, {"action": "summary"})
+    check("G1 summary 缺省取 Principal 会话",
+          out.get("session") == SESS and out.get("session_registered") is True)
+    idx = ms._self_state_call(cg, {"action": "index"})
+    check("G2 index 不传 dim → 按当前会话反查",
+          idx.get("dimension") == "session" and idx.get("value") == SESS,
+          str(idx.get("count")))
+    out2 = ms._self_state_call(cg, {"action": "refresh"})
+    check("G3 refresh 经 MCP 缺省登记会话",
+          bool(out2.get("ok")))
+
+    print("\n" + "=" * 68)
+    print(f"通过 {PASS} / 失败 {FAIL}")
+    if FAILS:
+        print("失败项：" + "，".join(FAILS))
+    print("=" * 68)
+    return FAIL
+
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(1 if main() else 0)