@furongjun1999/dsh-memory 0.4.11 → 0.5.1

package/md_cg/test_p38_contextualize.py

@@ -1,273 +1,273 @@
-# -*- coding: utf-8 -*-
-"""层归位（P38 · G4 设计态验收）。
-
-对照 `docs/mdcg/认知图_G4-G8缺口裁定单_v0.1.md` §二：批次流水账（`note_`/`milestone_`/
-`retest6_`）与感知产物（`imgpart_`/`vpipe_`）混在 knowledge 层，语义上属**情境**，
-需归位到 `contextual` 且**保留可召回**。
-
-验收覆盖：
-  ① op 契约链：consolidate 新增 3 个 action 与 `prefixes` 参数已在工具 schema 声明；
-  ② 无前缀 → 拒绝：不给白名单即报错，**拒绝对整层无差别改写**；
-  ③ 预演：只出报表不写盘；targeted 按前缀命中数；
-  ④ 落盘：layer 改写 + 落点迁到 `contextual/<id>.md` + 旧文件删除 + 正文不动 + 前缀外不动；
-  ⑤ 可追溯：演化账本落 `layer_shift`（before/after 可对照）；
-  ⑥ 可留痕：`_maintain.jsonl` 记 `action=contextualize` + batch；
-  ⑦ 可回滚：按 batch 反向迁层，落回原层原路径，并记 `contextualize_rollback`；
-  ⑧ 保留召回：归位后仍可被 `op=route` 检索到（不改层白名单）；
-  ⑨ 权限：写层（can_admin=False）不可归位（管理操作 require_admin）；
-  ⑩ 密文 fail-closed：密文节点跳过并计数，绝不解密回写；
-  ⑪ 幂等：重跑 targeted=0；
-  ⑫ 未知 action 不静默成功。
-
-独立临时根，重跑 ≡ 首跑。
-
-运行：python -m md_cg.test_p38_contextualize
-"""
-from __future__ import annotations
-
-import json
-import os
-import shutil
-import tempfile
-
-from . import consolidate, tokens
-from .mdcos import MdCGOS, MdCGSecure
-from .mcp_server import KERNEL_TOOLS, call_tool
-from .security import AccessDenied, Principal
-
-PASS = FAIL = 0
-FAILS = []
-
-PREFIXES = ["note_", "imgpart_"]
-KEK = b"0123456789abcdef0123456789abcdef"   # 32 字节（crypto 硬要求）
-
-
-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)
-
-
-def ccg(subject):
-    return (f"# 功能名：{subject}\n"
-            "# 生效条件：默认满足\n"
-            f"# 子功能：{subject} 的条件层\n"
-            f"# 执行：检索 {subject} 的证据\n"
-            "# 验证方式：test\n"
-            "# 不适用条件：无需例外\n\n"
-            f"{subject} 的正文（不得被归位改写）。\n")
-
-
-def _seed(root):
-    """造 5 条待归位（note_×3 + imgpart_×2）+ 1 条对照（kp_）+ 1 条既有情境 + 1 条密文。"""
-    cg = MdCGOS(root)
-    for i in range(3):
-        cg.add(f"note_{i}", ccg(f"批次记录{i}"), layer="knowledge", tags=["batch"])
-    for i in range(2):
-        cg.add(f"imgpart_{i}", ccg(f"图像部件{i}"), layer="knowledge",
-               tags=["vision", "part"])
-    cg.add("kp_keep", ccg("长期知识点"), layer="knowledge", tags=["keep"])
-    cg.add("ctx_seed", ccg("既有情境记忆"), layer="contextual", tags=["ctx"])
-    cg.flush()
-    # 密文节点：无密钥实例读不到正文 → 归位必须 fail-closed 跳过
-    sec = MdCGSecure(root, principal=Principal(
-        actor="p38s", clearance="private", can_write=True, can_admin=True),
-        master_key=KEK)
-    sec.add("note_secret", ccg("密文批次记录"), layer="knowledge",
-            tags=["batch"], sensitivity="private")
-    sec.flush()
-    cg.rebuild_index()
-    return cg
-
-
-def _write_layer(plain, secret=None):
-    """写层 principal：可写不可管（require_admin 应拦下）。"""
-    s = tokens.role_spec("reflection")
-    return Principal(tenant="default", actor="writer", clearance="internal",
-                     can_write=True, can_admin=False, role="reflection",
-                     layers_allow=s["layers_allow"], ops_allow=s["ops_allow"])
-
-
-def main():
-    global PASS, FAIL
-    print("md 认知图 P38 验收 · 层归位（G4：情境性内容回迁 contextual）")
-    print("=" * 68)
-    tmp = tempfile.mkdtemp(prefix="mdcg_p38_")
-    ROOT = os.path.join(tmp, "root")
-    try:
-        from . import corpus
-        corpus.reset_root(ROOT)
-        cg = _seed(ROOT)
-        cg.principal = Principal(tenant="default", actor="p38",
-                                 clearance="private", can_write=True,
-                                 can_admin=True, role="designer")
-
-        # ------------------------------------------------ ① 契约链
-        print("\n【1】op 契约链（防漏改）")
-        tool = next(t for t in KERNEL_TOOLS if t["name"] == "cg")
-        prop = tool["inputSchema"]["properties"]
-        act_desc = prop["action"]["description"]
-        ok(all(a in act_desc for a in ("contextualize", "contextualize_rollback",
-                                       "contextualize_history")),
-           "①consolidate 新增 action 已在 schema 声明")
-        ok("prefixes" in prop, "①prefixes 参数已声明")
-
-        # ------------------------------------------------ ② 无前缀拒绝
-        print("\n【2】无白名单 → 拒绝对整层改写")
-        try:
-            call_tool(cg, "cg", {"op": "consolidate", "action": "contextualize",
-                                 "apply": True})
-            ok(False, "②无 prefixes 必须拒绝")
-        except ValueError as e:
-            ok("prefixes" in str(e), "②无 prefixes 拒绝整层改写")
-        fmk0, _ = cg._read(cg.index["nodes"]["kp_keep"])
-        ok(fmk0.get("layer") == "knowledge", "②拒绝后无副作用")
-
-        # ------------------------------------------------ ③ 预演
-        print("\n【3】预演不写盘")
-        dry = call_tool(cg, "cg", {"op": "consolidate", "action": "contextualize",
-                                   "prefixes": PREFIXES})
-        ok(dry.get("dry_run") is True, "③dry_run=True")
-        ok(dry.get("targeted") == 5, f"③targeted=5（实测 {dry.get('targeted')}）")
-        ok(dry.get("skipped_locked") == 1,
-           f"③密文节点计入 skipped_locked（实测 {dry.get('skipped_locked')}）")
-        e0 = cg.index["nodes"]["note_0"]
-        old_path = e0["path"]
-        fm, _ = cg._read(e0)
-        ok(fm.get("layer") == "knowledge" and e0["path"] == old_path,
-           "③预演未改层、未迁目录")
-
-        # ------------------------------------------------ ④ 归位落盘
-        print("\n【4】归位落盘（layer + 落点；正文不动）")
-        body_before = cg._read(e0)[1]
-        ap = call_tool(cg, "cg", {"op": "consolidate", "action": "contextualize",
-                                  "prefixes": PREFIXES, "apply": True,
-                                  "reason": "G4 层归位（P38 验收）"})
-        ok(ap.get("written") == 5, f"④归位 5 条（实测 {ap.get('written')}）")
-        cg2 = MdCGOS(ROOT)                      # 重新加载，验证盘上结果
-        e0b = cg2.index["nodes"]["note_0"]
-        fm, body_after = cg2._read(e0b)
-        ok(fm.get("layer") == "contextual", "④layer → contextual")
-        ok(fm.get("contextualized_from") == "knowledge", "④记录来源层")
-        ok(fm.get("contextualization_basis", {}).get("batch") == ap.get("batch"),
-           "④记录批次依据")
-        ok(e0b["path"] == "contextual/note_0.md",
-           f"④落点为 contextual/<id>.md（实测 {e0b['path']}）")
-        ok(not os.path.exists(os.path.join(ROOT, old_path)), "④旧文件已删除")
-        ok(body_after == body_before, "④正文一字未动")
-        fmk, _ = cg2._read(cg2.index["nodes"]["kp_keep"])
-        ok(fmk.get("layer") == "knowledge", "④前缀外节点不动")
-        fmc, _ = cg2._read(cg2.index["nodes"]["ctx_seed"])
-        ok(fmc.get("layer") == "contextual", "④既有情境记忆不动")
-
-        # ------------------------------------------------ ⑤ 演化账本
-        print("\n【5】可追溯（layer_shift）")
-        ev = call_tool(cg2, "cg", {"op": "evolution", "action": "entries",
-                                   "limit": 100})
-        blob = json.dumps(ev, ensure_ascii=False)
-        ok("layer_shift" in blob, "⑤演化账本落 layer_shift")
-        ok("note_0" in blob, "⑤账本可按节点追溯")
-
-        # ------------------------------------------------ ⑥ 台账
-        print("\n【6】可留痕（_maintain.jsonl）")
-        recs = [r for r in consolidate._read_maintain(ROOT)
-                if r.get("action") == "contextualize"]
-        ok(len(recs) == 5, f"⑥台账 5 条（实测 {len(recs)}）")
-        ok(all(r.get("batch") == ap.get("batch") for r in recs), "⑥批次号一致")
-        ok(all(r.get("from") == "knowledge" and r.get("to") == "contextual"
-               for r in recs), "⑥记录 from/to")
-
-        # ------------------------------------------------ ⑧ 保留召回
-        print("\n【7】保留可召回（不改层白名单）")
-        ok("contextual" in tokens.ALL_LAYERS, "⑦contextual 仍在层白名单")
-        rt = call_tool(cg2, "cg", {"op": "route", "query": "批次记录0 的正文"})
-        ok("note_0" in json.dumps(rt, ensure_ascii=False)[:20000],
-           "⑦归位后仍可被 route 检索到")
-
-        # ------------------------------------------------ ⑪ 幂等
-        print("\n【8】幂等")
-        again = call_tool(cg2, "cg", {"op": "consolidate", "action": "contextualize",
-                                      "prefixes": PREFIXES, "apply": True})
-        ok(again.get("targeted") == 0 and again.get("written") == 0,
-           f"⑧重跑 targeted=0（实测 {again.get('targeted')}）")
-
-        # ------------------------------------------------ ⑨ 权限
-        print("\n【9】权限分档（管理操作）")
-        cg2.principal = _write_layer(cg2)
-        denied(lambda: call_tool(cg2, "cg", {"op": "consolidate",
-                                             "action": "contextualize",
-                                             "prefixes": PREFIXES, "apply": True}),
-               "⑨写层不可归位")
-        cg2.principal = Principal(tenant="default", actor="p38",
-                                  clearance="private", can_write=True,
-                                  can_admin=True, role="designer")
-
-        # ------------------------------------------------ ⑦ 回滚
-        print("\n【10】可回滚（按批次）")
-        rb = call_tool(cg2, "cg", {"op": "consolidate",
-                                   "action": "contextualize_rollback",
-                                   "batch": ap.get("batch")})
-        ok(rb.get("reverted") == 5, f"⑩回滚 5 条（实测 {rb.get('reverted')}）")
-        cg3 = MdCGOS(ROOT)
-        e0c = cg3.index["nodes"]["note_0"]
-        fmc, body_back = cg3._read(e0c)
-        ok(fmc.get("layer") == "knowledge", "⑩layer 回到 knowledge")
-        ok(e0c["path"] == old_path, f"⑩路径回到原处（实测 {e0c['path']}）")
-        ok(body_back == body_before, "⑩回滚后正文仍一致")
-        rb2 = [r for r in consolidate._read_maintain(ROOT)
-               if r.get("action") == "contextualize_rollback"]
-        ok(len(rb2) == 5, f"⑩回滚留痕 5 条（实测 {len(rb2)}）")
-        hist = call_tool(cg3, "cg", {"op": "consolidate",
-                                     "action": "contextualize_history"})
-        ok(len(hist.get("records") or []) >= 10, "⑩history 可回读批次记录")
-
-        # ------------------------------------------------ ⑫ 未知 action
-        print("\n【11】未知 action 不静默成功")
-        try:
-            call_tool(cg3, "cg", {"op": "consolidate", "action": "contextualize_x"})
-            ok(False, "⑪未知 action 必须报错")
-        except ValueError as e:
-            ok("未知 action" in str(e), "⑪未知 action 报错且列出可选值")
-
-        # ------------------------------------------------ ⑫ 定向 id 对称
-        print("\n【12】定向 id 补迁（回滚的对称操作）")
-        t1 = call_tool(cg3, "cg", {"op": "consolidate", "action": "contextualize",
-                                   "ids": ["note_1"], "apply": True})
-        ok(t1.get("written") == 1 and t1.get("targeted") == 1,
-           f"⑫定向 id 归位 1 条（实测 {t1.get('written')}）")
-        cg4 = MdCGOS(ROOT)
-        e1 = cg4.index["nodes"]["note_1"]
-        ok(e1["path"] == "contextual/note_1.md", "⑫定向归位落点正确")
-        rb1 = call_tool(cg4, "cg", {"op": "consolidate",
-                                    "action": "contextualize_rollback",
-                                    "batch": t1.get("batch")})
-        ok(rb1.get("reverted") == 1, "⑫定向批次可单独回滚")
-        cg5 = MdCGOS(ROOT)
-        ok(cg5.index["nodes"]["note_1"]["path"].startswith("knowledge/"),
-           "⑫定向回滚路径正确")
-    finally:
-        shutil.rmtree(tmp, ignore_errors=True)
-
-    print("\n" + "=" * 68)
-    print(f"P38 结果：PASS {PASS} / FAIL {FAIL}")
-    if FAILS:
-        print("未通过：" + "；".join(FAILS))
-    return 0 if FAIL == 0 else 1
-
-
-if __name__ == "__main__":
-    import sys
-    sys.exit(main())
+# -*- coding: utf-8 -*-
+"""层归位（P38 · G4 设计态验收）。
+
+对照 `docs/mdcg/认知图_G4-G8缺口裁定单_v0.1.md` §二：批次流水账（`note_`/`milestone_`/
+`retest6_`）与感知产物（`imgpart_`/`vpipe_`）混在 knowledge 层，语义上属**情境**，
+需归位到 `contextual` 且**保留可召回**。
+
+验收覆盖：
+  ① op 契约链：consolidate 新增 3 个 action 与 `prefixes` 参数已在工具 schema 声明；
+  ② 无前缀 → 拒绝：不给白名单即报错，**拒绝对整层无差别改写**；
+  ③ 预演：只出报表不写盘；targeted 按前缀命中数；
+  ④ 落盘：layer 改写 + 落点迁到 `contextual/<id>.md` + 旧文件删除 + 正文不动 + 前缀外不动；
+  ⑤ 可追溯：演化账本落 `layer_shift`（before/after 可对照）；
+  ⑥ 可留痕：`_maintain.jsonl` 记 `action=contextualize` + batch；
+  ⑦ 可回滚：按 batch 反向迁层，落回原层原路径，并记 `contextualize_rollback`；
+  ⑧ 保留召回：归位后仍可被 `op=route` 检索到（不改层白名单）；
+  ⑨ 权限：写层（can_admin=False）不可归位（管理操作 require_admin）；
+  ⑩ 密文 fail-closed：密文节点跳过并计数，绝不解密回写；
+  ⑪ 幂等：重跑 targeted=0；
+  ⑫ 未知 action 不静默成功。
+
+独立临时根，重跑 ≡ 首跑。
+
+运行：python -m md_cg.test_p38_contextualize
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import tempfile
+
+from . import consolidate, tokens
+from .mdcos import MdCGOS, MdCGSecure
+from .mcp_server import KERNEL_TOOLS, call_tool
+from .security import AccessDenied, Principal
+
+PASS = FAIL = 0
+FAILS = []
+
+PREFIXES = ["note_", "imgpart_"]
+KEK = b"0123456789abcdef0123456789abcdef"   # 32 字节（crypto 硬要求）
+
+
+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)
+
+
+def ccg(subject):
+    return (f"# 功能名：{subject}\n"
+            "# 生效条件：默认满足\n"
+            f"# 子功能：{subject} 的条件层\n"
+            f"# 执行：检索 {subject} 的证据\n"
+            "# 验证方式：test\n"
+            "# 不适用条件：无需例外\n\n"
+            f"{subject} 的正文（不得被归位改写）。\n")
+
+
+def _seed(root):
+    """造 5 条待归位（note_×3 + imgpart_×2）+ 1 条对照（kp_）+ 1 条既有情境 + 1 条密文。"""
+    cg = MdCGOS(root)
+    for i in range(3):
+        cg.add(f"note_{i}", ccg(f"批次记录{i}"), layer="knowledge", tags=["batch"])
+    for i in range(2):
+        cg.add(f"imgpart_{i}", ccg(f"图像部件{i}"), layer="knowledge",
+               tags=["vision", "part"])
+    cg.add("kp_keep", ccg("长期知识点"), layer="knowledge", tags=["keep"])
+    cg.add("ctx_seed", ccg("既有情境记忆"), layer="contextual", tags=["ctx"])
+    cg.flush()
+    # 密文节点：无密钥实例读不到正文 → 归位必须 fail-closed 跳过
+    sec = MdCGSecure(root, principal=Principal(
+        actor="p38s", clearance="private", can_write=True, can_admin=True),
+        master_key=KEK)
+    sec.add("note_secret", ccg("密文批次记录"), layer="knowledge",
+            tags=["batch"], sensitivity="private")
+    sec.flush()
+    cg.rebuild_index()
+    return cg
+
+
+def _write_layer(plain, secret=None):
+    """写层 principal：可写不可管（require_admin 应拦下）。"""
+    s = tokens.role_spec("reflection")
+    return Principal(tenant="default", actor="writer", clearance="internal",
+                     can_write=True, can_admin=False, role="reflection",
+                     layers_allow=s["layers_allow"], ops_allow=s["ops_allow"])
+
+
+def main():
+    global PASS, FAIL
+    print("md 认知图 P38 验收 · 层归位（G4：情境性内容回迁 contextual）")
+    print("=" * 68)
+    tmp = tempfile.mkdtemp(prefix="mdcg_p38_")
+    ROOT = os.path.join(tmp, "root")
+    try:
+        from . import corpus
+        corpus.reset_root(ROOT)
+        cg = _seed(ROOT)
+        cg.principal = Principal(tenant="default", actor="p38",
+                                 clearance="private", can_write=True,
+                                 can_admin=True, role="designer")
+
+        # ------------------------------------------------ ① 契约链
+        print("\n【1】op 契约链（防漏改）")
+        tool = next(t for t in KERNEL_TOOLS if t["name"] == "cg")
+        prop = tool["inputSchema"]["properties"]
+        act_desc = prop["action"]["description"]
+        ok(all(a in act_desc for a in ("contextualize", "contextualize_rollback",
+                                       "contextualize_history")),
+           "①consolidate 新增 action 已在 schema 声明")
+        ok("prefixes" in prop, "①prefixes 参数已声明")
+
+        # ------------------------------------------------ ② 无前缀拒绝
+        print("\n【2】无白名单 → 拒绝对整层改写")
+        try:
+            call_tool(cg, "cg", {"op": "consolidate", "action": "contextualize",
+                                 "apply": True})
+            ok(False, "②无 prefixes 必须拒绝")
+        except ValueError as e:
+            ok("prefixes" in str(e), "②无 prefixes 拒绝整层改写")
+        fmk0, _ = cg._read(cg.index["nodes"]["kp_keep"])
+        ok(fmk0.get("layer") == "knowledge", "②拒绝后无副作用")
+
+        # ------------------------------------------------ ③ 预演
+        print("\n【3】预演不写盘")
+        dry = call_tool(cg, "cg", {"op": "consolidate", "action": "contextualize",
+                                   "prefixes": PREFIXES})
+        ok(dry.get("dry_run") is True, "③dry_run=True")
+        ok(dry.get("targeted") == 5, f"③targeted=5（实测 {dry.get('targeted')}）")
+        ok(dry.get("skipped_locked") == 1,
+           f"③密文节点计入 skipped_locked（实测 {dry.get('skipped_locked')}）")
+        e0 = cg.index["nodes"]["note_0"]
+        old_path = e0["path"]
+        fm, _ = cg._read(e0)
+        ok(fm.get("layer") == "knowledge" and e0["path"] == old_path,
+           "③预演未改层、未迁目录")
+
+        # ------------------------------------------------ ④ 归位落盘
+        print("\n【4】归位落盘（layer + 落点；正文不动）")
+        body_before = cg._read(e0)[1]
+        ap = call_tool(cg, "cg", {"op": "consolidate", "action": "contextualize",
+                                  "prefixes": PREFIXES, "apply": True,
+                                  "reason": "G4 层归位（P38 验收）"})
+        ok(ap.get("written") == 5, f"④归位 5 条（实测 {ap.get('written')}）")
+        cg2 = MdCGOS(ROOT)                      # 重新加载，验证盘上结果
+        e0b = cg2.index["nodes"]["note_0"]
+        fm, body_after = cg2._read(e0b)
+        ok(fm.get("layer") == "contextual", "④layer → contextual")
+        ok(fm.get("contextualized_from") == "knowledge", "④记录来源层")
+        ok(fm.get("contextualization_basis", {}).get("batch") == ap.get("batch"),
+           "④记录批次依据")
+        ok(e0b["path"] == "contextual/note_0.md",
+           f"④落点为 contextual/<id>.md（实测 {e0b['path']}）")
+        ok(not os.path.exists(os.path.join(ROOT, old_path)), "④旧文件已删除")
+        ok(body_after == body_before, "④正文一字未动")
+        fmk, _ = cg2._read(cg2.index["nodes"]["kp_keep"])
+        ok(fmk.get("layer") == "knowledge", "④前缀外节点不动")
+        fmc, _ = cg2._read(cg2.index["nodes"]["ctx_seed"])
+        ok(fmc.get("layer") == "contextual", "④既有情境记忆不动")
+
+        # ------------------------------------------------ ⑤ 演化账本
+        print("\n【5】可追溯（layer_shift）")
+        ev = call_tool(cg2, "cg", {"op": "evolution", "action": "entries",
+                                   "limit": 100})
+        blob = json.dumps(ev, ensure_ascii=False)
+        ok("layer_shift" in blob, "⑤演化账本落 layer_shift")
+        ok("note_0" in blob, "⑤账本可按节点追溯")
+
+        # ------------------------------------------------ ⑥ 台账
+        print("\n【6】可留痕（_maintain.jsonl）")
+        recs = [r for r in consolidate._read_maintain(ROOT)
+                if r.get("action") == "contextualize"]
+        ok(len(recs) == 5, f"⑥台账 5 条（实测 {len(recs)}）")
+        ok(all(r.get("batch") == ap.get("batch") for r in recs), "⑥批次号一致")
+        ok(all(r.get("from") == "knowledge" and r.get("to") == "contextual"
+               for r in recs), "⑥记录 from/to")
+
+        # ------------------------------------------------ ⑧ 保留召回
+        print("\n【7】保留可召回（不改层白名单）")
+        ok("contextual" in tokens.ALL_LAYERS, "⑦contextual 仍在层白名单")
+        rt = call_tool(cg2, "cg", {"op": "route", "query": "批次记录0 的正文"})
+        ok("note_0" in json.dumps(rt, ensure_ascii=False)[:20000],
+           "⑦归位后仍可被 route 检索到")
+
+        # ------------------------------------------------ ⑪ 幂等
+        print("\n【8】幂等")
+        again = call_tool(cg2, "cg", {"op": "consolidate", "action": "contextualize",
+                                      "prefixes": PREFIXES, "apply": True})
+        ok(again.get("targeted") == 0 and again.get("written") == 0,
+           f"⑧重跑 targeted=0（实测 {again.get('targeted')}）")
+
+        # ------------------------------------------------ ⑨ 权限
+        print("\n【9】权限分档（管理操作）")
+        cg2.principal = _write_layer(cg2)
+        denied(lambda: call_tool(cg2, "cg", {"op": "consolidate",
+                                             "action": "contextualize",
+                                             "prefixes": PREFIXES, "apply": True}),
+               "⑨写层不可归位")
+        cg2.principal = Principal(tenant="default", actor="p38",
+                                  clearance="private", can_write=True,
+                                  can_admin=True, role="designer")
+
+        # ------------------------------------------------ ⑦ 回滚
+        print("\n【10】可回滚（按批次）")
+        rb = call_tool(cg2, "cg", {"op": "consolidate",
+                                   "action": "contextualize_rollback",
+                                   "batch": ap.get("batch")})
+        ok(rb.get("reverted") == 5, f"⑩回滚 5 条（实测 {rb.get('reverted')}）")
+        cg3 = MdCGOS(ROOT)
+        e0c = cg3.index["nodes"]["note_0"]
+        fmc, body_back = cg3._read(e0c)
+        ok(fmc.get("layer") == "knowledge", "⑩layer 回到 knowledge")
+        ok(e0c["path"] == old_path, f"⑩路径回到原处（实测 {e0c['path']}）")
+        ok(body_back == body_before, "⑩回滚后正文仍一致")
+        rb2 = [r for r in consolidate._read_maintain(ROOT)
+               if r.get("action") == "contextualize_rollback"]
+        ok(len(rb2) == 5, f"⑩回滚留痕 5 条（实测 {len(rb2)}）")
+        hist = call_tool(cg3, "cg", {"op": "consolidate",
+                                     "action": "contextualize_history"})
+        ok(len(hist.get("records") or []) >= 10, "⑩history 可回读批次记录")
+
+        # ------------------------------------------------ ⑫ 未知 action
+        print("\n【11】未知 action 不静默成功")
+        try:
+            call_tool(cg3, "cg", {"op": "consolidate", "action": "contextualize_x"})
+            ok(False, "⑪未知 action 必须报错")
+        except ValueError as e:
+            ok("未知 action" in str(e), "⑪未知 action 报错且列出可选值")
+
+        # ------------------------------------------------ ⑫ 定向 id 对称
+        print("\n【12】定向 id 补迁（回滚的对称操作）")
+        t1 = call_tool(cg3, "cg", {"op": "consolidate", "action": "contextualize",
+                                   "ids": ["note_1"], "apply": True})
+        ok(t1.get("written") == 1 and t1.get("targeted") == 1,
+           f"⑫定向 id 归位 1 条（实测 {t1.get('written')}）")
+        cg4 = MdCGOS(ROOT)
+        e1 = cg4.index["nodes"]["note_1"]
+        ok(e1["path"] == "contextual/note_1.md", "⑫定向归位落点正确")
+        rb1 = call_tool(cg4, "cg", {"op": "consolidate",
+                                    "action": "contextualize_rollback",
+                                    "batch": t1.get("batch")})
+        ok(rb1.get("reverted") == 1, "⑫定向批次可单独回滚")
+        cg5 = MdCGOS(ROOT)
+        ok(cg5.index["nodes"]["note_1"]["path"].startswith("knowledge/"),
+           "⑫定向回滚路径正确")
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+    print("\n" + "=" * 68)
+    print(f"P38 结果：PASS {PASS} / FAIL {FAIL}")
+    if FAILS:
+        print("未通过：" + "；".join(FAILS))
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(main())