@furongjun1999/dsh-memory 0.4.5 → 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_p43_pooling.py

@@ -233,17 +233,27 @@ def main():
 
         # ============================================== (8) 降权可复算
         print("\n(8) 硬约束二 · 降权显式可复算")
-        sc = {r[0]["id"]: round(r[1], 6) for r in on}
-        ok(sc["code_0"] == round(0.6 * 1.0, 6), f"(8) 索引类命中分 == 0.6（实得 {sc.get('code_0')}）")
-        ok(max(sc[f"kp_{i}"] for i in range(6)) == 1.0, "(8) 知识类命中分不被削")
+        # 降权断言与打分口径解耦：以关闭分池（权重恒 1.0）时同一条目的分数为 base，
+        # 断言 final == base × weight。口径由 legacy 切 jaccard 后 base ≠ 1.0，
+        # 但「乘数可复算」这一被测语义不变。
+        base = {r[0]["id"]: r[1] for r in off}
+        sc = {r[0]["id"]: r[1] for r in on}
+        ok(abs(sc["code_0"] - base.get("code_0", 0.0) * 0.6) < 1e-9,
+           f"(8) 索引类命中分 == 基础分 × 0.6（base={base.get('code_0', 0.0):.6f} → "
+           f"{sc.get('code_0', float('nan')):.6f}）")
+        common = [i for i in range(6) if f"kp_{i}" in base and f"kp_{i}" in sc]
+        ok(common and all(abs(sc[f"kp_{i}"] - base[f"kp_{i}"]) < 1e-9 for i in common),
+           f"(8) 知识类命中分不被削（权重 1.0；逐条比对 {len(common)} 条）")
         ok(PL.weight_of("code_x", {}, True) == PL.WEIGHTS["index"]["weight"],
            "(8) weight_of 与表内系数一致")
         alt = {"knowledge": {"cap_ratio": 0.5, "weight": 1.0},
                "index": {"cap_ratio": 0.4, "weight": 0.3},
                "negative": {"cap_ratio": 0.1, "weight": 0.5}}
         on2, _m2 = cg.search(QUERY, k=20, record=False, pools=alt)
-        sc2 = {r[0]["id"]: round(r[1], 6) for r in on2}
-        ok(sc2["code_0"] == 0.3, f"(8) 换表即换行为（实得 {sc2.get('code_0')}）")
+        sc2 = {r[0]["id"]: r[1] for r in on2}
+        ok(abs(sc2["code_0"] - base.get("code_0", 0.0) * 0.3) < 1e-9,
+           f"(8) 换表即换行为（base×0.3={base.get('code_0', 0.0) * 0.3:.6f} → "
+           f"{sc2.get('code_0', float('nan')):.6f}）")
         ok(PL.caps(10, PL.resolve(alt)) == {"knowledge": 4, "index": 4, "negative": 2},
            f"(8) 换表额度同步可复算（实得 {PL.caps(10, PL.resolve(alt))}）")
 

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)