@furongjun1999/dsh-memory 0.5.0 → 0.6.0

package/md_cg/test_retr_score_once.py

@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""生产 search T2/T3 重打分守卫（v7 N51 留档复测·修复，缺陷迭代第 14 轮）。
+
+缺陷形态（缺陷报告/v9.md:111 留档，600 节点临时库实测逐位复现）：
+  生产 MdCGOS.search 的 try_stage（mdcos.py）无 scored 形参——T2/T3 均为
+  「打分截断后又对 picked 重打」：cut_by_relevance(hits, self._score(hits))
+  之后 try_stage(hits) 内部再 _score 一遍；T3 再对 picked 重打。实测无交集
+  查询 _score 恰 4 调、per-call docs=[0,0,600,500]、共打分 1100 文档——
+  500/1100≈45% 打分工作量冗余（GLOBAL_CAP=500）。基类 try_stage 早有
+  scored=None 形参（mdcg.py P2-4，批次 31，reach 分支已用）未回移生产覆写。
+
+修复口径：生产 try_stage 照基类 P2-4 模板补 scored=None 形参；T2 hits 腿
+（截断打分结果经 doc_key 键表回填）与 T3 picked 腿、reach hits_r 腿一并
+透传——同一 _score 纯函数（单次 search 内 docs/q/qb/pool_cfg 均不变），
+透传不改变任何分值与输出。
+
+本守卫（调用计数/复杂度断言形态，非时间阈值）：
+  T3 段（无交集查询，600 节点）：_score 恰 2 调、per-call [0,600]、共 600
+     文档（旧实现 4 调 [0,0,600,500]=1100 → 红）；tier/scanned/结果规模
+     不变；
+  T2 段（有交集查询）：_score 恰 1 调、共 600 文档（旧实现 2 调
+     [600,500]=1100 → 红）；
+  纯度段：对计数包装记录的每笔 (docs, scored) 复算 _score 逐位相等
+     （透传值 ≡ 现算值——不改结果的直接证据）；
+  确定性段：同查询连跑两轮结果 id 序与分值逐位一致。
+
+运行：python -m md_cg.test_retr_score_once
+"""
+import os
+import shutil
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from md_cg.mdcos import MdCGOS              # noqa: E402
+
+PASS = 0
+FAIL = 0
+FAILS = []
+
+N = 600
+QUERY_MISS = "完全无交集查询词项甲乙丙"       # LIKE 零命中 → T3 全量兜底
+QUERY_HIT = "蜂群调度"                      # 有交集 → T2 命中
+
+
+def check(name, cond, detail=""):
+    global PASS, FAIL
+    if cond:
+        PASS += 1
+        print(f"  OK   {name}")
+    else:
+        FAIL += 1
+        FAILS.append(name)
+        print(f"  FAIL {name}  {detail}")
+
+
+def build_lib(root):
+    cg = MdCGOS(root)
+    for i in range(N):
+        cg.add("mem_%04d" % i,
+               "# 功能名：打分样本 %d\n# 正文：%s 节点 %d" % (i, QUERY_HIT, i),
+               layer="knowledge")
+    cg.flush()
+    return cg
+
+
+def count_score(cg, fn):
+    """包装实例 _score：记录每笔 (docs 数, scored)；另存 docs 引用于旁表。"""
+    calls = []            # [docs_n]
+    pairs = []            # [(docs, scored)]
+    real = MdCGOS._score
+
+    def _spy(self, docs, *a, **kw):
+        out = real(self, docs, *a, **kw)
+        calls.append(len(docs))
+        # 记录时拷贝：_emit 会对 scored 列表原地排序（记录引用会被事后变更）
+        pairs.append((list(docs), list(out)))
+        return out
+
+    cg._score = _spy.__get__(cg, MdCGOS)
+    try:
+        return fn(), calls, pairs
+    finally:
+        del cg._score                     # 还原类属性查找
+
+
+def main():
+    os.environ.pop("MDCG_READ_CACHE", None)
+    root = tempfile.mkdtemp(prefix="mdcg_score_once_")
+    cg = None
+    try:
+        cg = build_lib(root)
+        cg.search(QUERY_MISS)             # 预热（读缓存装载，非度量面）
+
+        print("== T3 无交集查询：打分恰一次/文档 ==")
+        for rep in range(2):
+            (res, meta), calls, _ = count_score(
+                cg, lambda: cg.search(QUERY_MISS))
+            check("T3a rep%d _score 调用数 == 2（旧 4）" % rep,
+                  len(calls) == 2, f"calls={calls}")
+            check("T3b rep%d per-call docs == [0, 600]（旧 [0,0,600,500]）" % rep,
+                  calls == [0, 600], f"calls={calls}")
+            check("T3c rep%d 共打分 600 文档（旧 1100，省 45）" % rep,
+                  sum(calls) == 600, f"total={sum(calls)}")
+            check("T3d rep%d tier/scanned/结果规模不变" % rep,
+                  meta.get("tier") == "T3_global_scan"
+                  and meta.get("scanned") == N and len(res) == 20,
+                  f"tier={meta.get('tier')} scanned={meta.get('scanned')} "
+                  f"n={len(res)}")
+
+        print("== T2 有交集查询：打分恰一次/文档 ==")
+        for rep in range(2):
+            (res, meta), calls, _ = count_score(
+                cg, lambda: cg.search(QUERY_HIT))
+            check("T2a rep%d _score 调用数 == 1（旧 2）" % rep,
+                  len(calls) == 1, f"calls={calls}")
+            check("T2b rep%d 共打分 600 文档（旧 1100）" % rep,
+                  calls == [600], f"calls={calls}")
+            check("T2c rep%d tier 不变（T2_global_like）" % rep,
+                  meta.get("tier") == "T2_global_like",
+                  f"tier={meta.get('tier')}")
+
+        print("== 纯度：透传 scored ≡ 现算 _score（不改结果的直接证据）==")
+        (res, meta), calls, pairs = count_score(
+            cg, lambda: cg.search(QUERY_MISS))
+        # 与 search 同口径重建 q/qb（mdcos.py:751-773 的打分输入）
+        from md_cg.mdcg import bigrams, normalize_en, en_zh_bigrams
+        from md_cg.semantic.unify import unify_query
+        q_p = unify_query(QUERY_MISS)
+        qb_p = bigrams(normalize_en(q_p)) | en_zh_bigrams(q_p)
+        pure = True
+        for i, (docs, scored) in enumerate(pairs):
+            again = MdCGOS._score(cg, docs, q_p, qb_p, None)
+            if again != scored:
+                pure = False
+                print(f"    第{i}笔复算不一致: {len(docs)} docs")
+        check("P1a 每笔 (docs→scored) 复算逐位相等（_score 纯函数）", pure)
+
+        print("== 确定性：同查询两轮结果逐位一致 ==")
+        r1, m1 = cg.search(QUERY_MISS)
+        r2, m2 = cg.search(QUERY_MISS)
+        ids1 = [(x[0].get("id"), round(x[1], 12)) for x in r1]
+        ids2 = [(x[0].get("id"), round(x[1], 12)) for x in r2]
+        check("D1a 两轮结果 id 序与分值逐位一致", ids1 == ids2,
+              f"n={len(ids1)}/{len(ids2)}")
+        rh1, _ = cg.search(QUERY_HIT)
+        rh2, _ = cg.search(QUERY_HIT)
+        check("D1b T2 路径两轮结果逐位一致",
+              [(x[0].get("id"), round(x[1], 12)) for x in rh1]
+              == [(x[0].get("id"), round(x[1], 12)) for x in rh2])
+
+        print("== reach 腿（MDCG_REACH=1）：P2-4 模板形态修复 ==")
+        # 相邻缺陷（本轮 stash 取证）：基类 reach 分支旧 _smap 模板对 scored
+        # 的 card dict 调 pooling.doc_key（形参须 (entry,fm,content) 三元组）
+        # → MDCG_REACH=1 + 命中集非空即 KeyError: 1（HEAD 原生在位）。
+        from md_cg.mdcg import MdCG
+        os.environ["MDCG_REACH"] = "1"
+        try:
+            root2 = tempfile.mkdtemp(prefix="mdcg_score_reach_")
+            cg2 = MdCGOS(root2)
+            for i in range(30):
+                cg2.add("rm_%03d" % i,
+                        "# 功能名：reach 样本\n# 正文：%s 节点 %d" % (QUERY_HIT, i),
+                        layer="knowledge")
+            cg2.flush()
+            try:
+                (res_r, meta_r), calls_r, _ = count_score(
+                    cg2, lambda: cg2.search(QUERY_HIT))
+                check("R1a 生产 reach 腿不再 KeyError（HEAD 实测崩）且有结果",
+                      len(res_r) >= 1, f"n={len(res_r)} tier={meta_r.get('tier')}")
+                check("R1b 生产 reach 腿打分 ≤ 2 调（透传无重打）",
+                      len(calls_r) <= 2, f"calls={calls_r}")
+            finally:
+                cg2.close()
+                shutil.rmtree(root2, ignore_errors=True)
+            root3 = tempfile.mkdtemp(prefix="mdcg_score_reachb_")
+            cg3 = MdCG(root3)
+            for i in range(30):
+                cg3.add("bm_%03d" % i,
+                        "# 功能名：reach 样本\n# 正文：%s 节点 %d" % (QUERY_HIT, i),
+                        layer="knowledge")
+            cg3.flush()
+            try:
+                res_b, meta_b = cg3.search(QUERY_HIT)
+                check("R2a 基类 reach 分支不再 KeyError（stash 取证 HEAD 崩）",
+                      len(res_b) >= 1, f"n={len(res_b)} tier={meta_b.get('tier')}")
+            finally:
+                cg3.close()
+                shutil.rmtree(root3, ignore_errors=True)
+        finally:
+            os.environ.pop("MDCG_REACH", None)
+        cg.close()
+    finally:
+        os.environ.pop("MDCG_READ_CACHE", None)
+        shutil.rmtree(root, ignore_errors=True)
+
+    print("\n" + "=" * 60)
+    print(f"结果：PASS {PASS} / FAIL {FAIL}")
+    if FAILS:
+        for f in FAILS:
+            print(f"  - {f}")
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_review_cli_attribution.py

@@ -0,0 +1,177 @@
+# -*- coding: utf-8 -*-
+"""md_cg · review_cli 归因守卫（P1 裁决面身份归因退化，DSH 端在役实测）
+
+缺陷（修复前）：`review_cli._cg` 构造 `Principal(actor="designer-cli", ...)`
+不传 session → `security.Principal.__init__` 每次随机生成 `sess_<uuid12>`；
+accept 落盘经 `MdCGSecure._attribution` 的 setdefault，writer 缺省成裁决者
+designer-cli——于是 DSH 端实测：5 个裁决节点 5 个互不相同的随机会话 id、
+writer 全被 designer-cli 覆盖，原始写入者（dsh-memory，提案记录 actor 有）
+不可追溯。
+
+守卫（修复前红）：
+  ① review_cli accept --session <s> → 落盘节点 frontmatter.session == <s>
+  ② 落盘节点 frontmatter.writer == 提案记录的原始 actor（dsh-memory）
+  ③ 裁决者身份不丢失：frontmatter.reviewer == "designer-cli"
+  ④ 稳定性：同一 --session 两次裁决 → 两节点 session 一致
+  ⑤ 兜底：未传 --session 时环境变量 MDCG_SESSION 生效
+  ⑥ 仍无（两者皆缺省）→ stderr 告警一行 + 维持随机会话（现状兼容）
+
+运行：python -m md_cg.test_review_cli_attribution
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+
+from . import nodefile
+from .mdcos import MdCGOS, MdCGSecure
+from .security import Principal
+
+PASS = FAIL = 0
+FAILS = []
+
+REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+DUMMY_KEY = "ab" * 32          # 哑主密钥：子进程绝不触真实 ~/.mdcg/master.key
+
+
+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 _child_env(extra=None, remove=("MDCG_SESSION", "DSH_SESSION_ID",
+                                   "MDCG_REDTEAM_REQUIRED")):
+    """子进程环境：哑密钥 + UTF-8 + PYTHONPATH 指向本仓（纪律 15）。
+
+    remove 里的会话/红队环境变量先摘除——守卫 ①~④⑥ 必须证明 --session
+    是唯一来源，不能被外层环境偷跑。
+    """
+    env = dict(os.environ)
+    for k in remove:
+        env.pop(k, None)
+    env["MDCG_MASTER_KEY"] = DUMMY_KEY
+    env["PYTHONUTF8"] = "1"
+    env["PYTHONIOENCODING"] = "utf-8"
+    env["PYTHONPATH"] = REPO + os.pathsep + env.get("PYTHONPATH", "")
+    env.update(extra or {})
+    return env
+
+
+def _run_cli(root, argv, extra=None):
+    """跑一次 review_cli 子命令（包内入口 python -m md_cg.review_cli）。"""
+    return subprocess.run(
+        [sys.executable, "-m", "md_cg.review_cli"] + argv,
+        capture_output=True, text=True, encoding="utf-8", errors="replace",
+        env=_child_env(extra), cwd=REPO)
+
+
+def _propose(root, nid, content):
+    """以原始写入者身份（dsh-memory，DSH 端 agent 形态）入队一条提案。"""
+    cg = MdCGSecure(root, principal=Principal(
+        actor="dsh-memory", clearance="internal", can_write=True,
+        can_admin=False, role="recorder", session="sess_writer_orig"))
+    try:
+        return cg.propose(nid, content, layer="knowledge", tags=["attr"])
+    finally:
+        cg.close()
+
+
+def _fm(root, nid):
+    """直读节点文件 frontmatter（不经密级读闸——守卫只看归因字段）。"""
+    probe = MdCGOS(root, actor="probe")
+    try:
+        e = (probe.index.get("nodes") or {}).get(nid)
+        if not e:
+            return None
+        with open(os.path.join(root, e["path"]), encoding="utf-8") as f:
+            fm, _c = nodefile.loads(f.read())
+        return fm
+    finally:
+        probe.close()
+
+
+def main():
+    roots = []
+    try:
+        print("\n【①~③】accept --session → 落盘归因（session/writer/reviewer）")
+        root_a = tempfile.mkdtemp(prefix="cliattrib_a_")
+        roots.append(root_a)
+        pid = _propose(root_a, "attr-node-1", "P1 归因守卫：原始写入者应可追溯。")
+        r = _run_cli(root_a, ["accept", pid, "--session", "sess_decide_01",
+                              "--root", root_a, "--reason", "归因守卫"])
+        check("review_cli accept --session 退出码 0", r.returncode == 0,
+              (r.stdout or r.stderr or "")[:200])
+        fm = _fm(root_a, "attr-node-1")
+        check("frontmatter.session == 传入 --session",
+              bool(fm) and fm.get("session") == "sess_decide_01",
+              str(fm and fm.get("session")))
+        check("frontmatter.writer == 提案原始 actor（dsh-memory）",
+              bool(fm) and fm.get("writer") == "dsh-memory",
+              str(fm and fm.get("writer")))
+        check("裁决者身份保留于 frontmatter.reviewer == designer-cli",
+              bool(fm) and fm.get("reviewer") == "designer-cli",
+              str(fm and fm.get("reviewer")))
+
+        print("\n【④】同一 --session 两次裁决 → 落盘归属一致")
+        pid2 = _propose(root_a, "attr-node-2",
+                        "P1 归因守卫第二提案：同批裁决同会话。")
+        r2 = _run_cli(root_a, ["accept", pid2, "--session", "sess_decide_01",
+                               "--root", root_a, "--reason", "归因守卫"])
+        fm2 = _fm(root_a, "attr-node-2")
+        check("第二节点 session 与第一节点一致",
+              r2.returncode == 0 and bool(fm) and bool(fm2)
+              and fm2.get("session") == fm.get("session") == "sess_decide_01",
+              "%r vs %r" % (fm and fm.get("session"), fm2 and fm2.get("session")))
+
+        print("\n【⑤】MDCG_SESSION 环境变量兜底")
+        pid3 = _propose(root_a, "attr-node-3",
+                        "P1 归因守卫第三提案：环境变量会话。")
+        r3 = _run_cli(root_a, ["accept", pid3, "--root", root_a,
+                               "--reason", "归因守卫"],
+                      extra={"MDCG_SESSION": "sess_env_03"})
+        fm3 = _fm(root_a, "attr-node-3")
+        check("无 --session 时 MDCG_SESSION 生效",
+              r3.returncode == 0 and bool(fm3)
+              and fm3.get("session") == "sess_env_03",
+              str(fm3 and fm3.get("session")))
+
+        print("\n【⑥】两者皆缺省 → stderr 告警一行 + 维持随机会话")
+        pid4 = _propose(root_a, "attr-node-4",
+                        "P1 归因守卫第四提案：随机会话告警。")
+        r4 = _run_cli(root_a, ["accept", pid4, "--root", root_a,
+                               "--reason", "归因守卫"])
+        fm4 = _fm(root_a, "attr-node-4")
+        check("退出码 0（告警不阻断裁决）", r4.returncode == 0,
+              (r4.stdout or r4.stderr or "")[:200])
+        warn = [ln for ln in (r4.stderr or "").splitlines() if ln.strip()]
+        check("stderr 恰一行随机会话告警",
+              len(warn) == 1 and "随机会话" in warn[0], str(warn))
+        check("缺省仍落随机会话 id（sess_ 前缀，现状兼容）",
+              bool(fm4) and str(fm4.get("session", "")).startswith("sess_"),
+              str(fm4 and fm4.get("session")))
+        check("无 --session 时原始 writer 归因同样在位",
+              bool(fm4) and fm4.get("writer") == "dsh-memory",
+              str(fm4 and fm4.get("writer")))
+    finally:
+        for r_ in roots:
+            shutil.rmtree(r_, ignore_errors=True)
+
+    print("\n" + "=" * 64)
+    print(f"PASS={PASS}  FAIL={FAIL}")
+    if FAILS:
+        print("失败项：" + "；".join(FAILS))
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_review_cli_visibility.py

@@ -0,0 +1,235 @@
+# -*- coding: utf-8 -*-
+"""md_cg · review_cli 裁决落盘跨进程可见性守卫（P1b autoflush 第二落点，DSH 端在役实测）
+
+缺陷（修复前）：`review_cli._cg` 构造 `MdCGSecure(_root(args), principal=p)`
+不传 autoflush → 缺省 64。库的索引增量链路是「写入先经 `_stage` 入内存
+`_dirty` 与内存索引，攒够 autoflush 条才 flush() 落分片日志 `_index_log/`」；
+短命进程的**正常退出**另有 main finally `cg.close()` + 库层 atexit 双兜底
+（mdcg.py `_LIVE_CGS`，2026-09-16 取证），但**被 kill / 崩溃退出时两者都不
+执行**（兜底刻意只覆盖正常退出这一条路径）——裁决落盘的少量节点停在内存
+索引、分片日志从未落，盘面节点文件在而索引链路断。DSH 端在役实测：裁决后
+MCP 读面 read null。对照：mcp_server.py:3695-3702 同症状 2026-09-16 已修
+（server 级 autoflush=1 兜底），review_cli 这个短命工具落点被遗漏——本修复
+补齐，与 server 同款。
+
+守卫（四组，全部临时库 + 哑主密钥，绝不触真实 ~/.mdcg）：
+  ① 真实在役入口：subprocess 跑 `python -m md_cg.review_cli accept`（正常
+    完成）→ 进程 B（全新 python 子进程 _load_index + read）断言业务节点与
+    审计记录节点均可见。
+  ② kill 形态可见性：进程 A' 等价直接调库落盘 2 条（无任何显式 flush）后
+    `os._exit(0)`（模拟被杀：close/atexit 全部跳过）→ 进程 B 全新子进程
+    断言读回可见。
+  ③ 落账契约（autoflush=1 的直接可观察效应，**修复前红**）：② 的进程 A'
+    被杀退出后，盘面 `_index_log/` 必须已含其全部写入的索引记录——"写入即
+    落分片日志"，与 mcp_server 的 server 级 autoflush=1 同一契约。
+  ④ 同病工具面：evidence._open_cg / scripts/linkref_backfill /
+    scripts/migrate_restricted 同样补 autoflush=1（前两者行为断言
+    .autoflush==1，后两者源级断言构造语句带参）。
+
+如实边界：本仓 HEAD 上 ①② 的读面断言在修复前已绿——正常路径由 09-16 的
+review_decide 显式 flush（mdcos.py）+ close/atexit 兜底覆盖；kill 形态的
+重开读面由批次39（2026-09-25）`_load_index` 指纹失配全扫自愈兜住。修复前
+红的只有 ③ 的落账契约与在役旧读面（0.4.x 副本 `_load_index` 盲信快照）——
+后者正是 DSH 端观察到 read null 的形态；本守卫把读面断言一并钉住，防上述
+两层兜底未来被移除时旧症复发。
+
+运行：python -m md_cg.test_review_cli_visibility
+"""
+from __future__ import annotations
+
+import argparse
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+
+from .mdcg import ShardedLog
+from .mdcos import MdCGSecure
+from .security import Principal
+
+PASS = FAIL = 0
+FAILS = []
+
+REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+DUMMY_KEY = "ab" * 32          # 哑主密钥：子进程绝不触真实 ~/.mdcg/master.key
+
+KILL_CHILD = r'''
+import argparse, os, sys
+sys.path.insert(0, sys.argv[2])
+from md_cg import review_cli
+# 等价直接调库落盘：走 review_cli 的生产构造路径 _cg（与 CLI 同一 autoflush），
+# 随后裸 add 两条（无任何显式 flush）——覆盖 review_decide 之外的写入形态。
+cg = review_cli._cg(argparse.Namespace(root=sys.argv[1]))
+sys.stderr.write("staged=0 autoflush=%d\n" % cg.autoflush)
+cg.add("vis-node-1", "P1b 可见性守卫节点一：kill 形态落账。", layer="knowledge",
+       tags=["vis:p1b"])
+cg.add("vis-node-2", "P1b 可见性守卫节点二：kill 形态落账。", layer="knowledge",
+       tags=["vis:p1b"])
+os._exit(0)                     # 硬退：close / atexit 一律不执行（模拟被杀）
+'''
+
+READ_CHILD = r'''
+import sys
+sys.path.insert(0, sys.argv[2])
+from md_cg.mdcos import MdCGSecure
+from md_cg.security import Principal
+p = Principal(actor="vis-reader", clearance="internal", can_write=True,
+              can_admin=True, role="designer", auth_mode="test")
+cg = MdCGSecure(sys.argv[1], principal=p)
+ids = sys.argv[3].split(",")
+print("READ " + " ".join("1" if cg.get(nid) is not None else "0" for nid in ids))
+'''
+
+
+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 _child_env(extra=None):
+    """子进程环境：哑密钥 + UTF-8 + PYTHONPATH 指向本仓（纪律 15）。"""
+    env = dict(os.environ)
+    env["MDCG_MASTER_KEY"] = DUMMY_KEY
+    env["PYTHONUTF8"] = "1"
+    env["PYTHONIOENCODING"] = "utf-8"
+    env["PYTHONPATH"] = REPO + os.pathsep + env.get("PYTHONPATH", "")
+    env.update(extra or {})
+    return env
+
+
+def _run_cli(root, argv):
+    """跑一次 review_cli（包内入口 python -m md_cg.review_cli，真实在役入口）。"""
+    return subprocess.run(
+        [sys.executable, "-X", "utf8", "-m", "md_cg.review_cli"] + argv,
+        capture_output=True, text=True, encoding="utf-8", errors="replace",
+        env=_child_env(), cwd=REPO)
+
+
+def _spawn(code, root, arg3=""):
+    """独立子进程跑一段内嵌脚本（进程 A' 杀退形态 / 进程 B 全新读面）。"""
+    return subprocess.run(
+        [sys.executable, "-X", "utf8", "-c", code, root, REPO, arg3],
+        capture_output=True, text=True, encoding="utf-8", errors="replace",
+        env=_child_env())
+
+
+def _propose(root, nid, content):
+    """以原始写入者身份入队一条提案（复刻 DSH 端 agent 形态）。"""
+    cg = MdCGSecure(root, principal=Principal(
+        actor="dsh-memory", clearance="internal", can_write=True,
+        can_admin=False, role="recorder", session="sess_writer_orig"))
+    try:
+        return cg.propose(nid, content, layer="knowledge", tags=["vis:p1b"])
+    finally:
+        cg.close()
+
+
+def _log_ids(root):
+    """读盘面分片日志的记录 id 集（落账契约的观察点）。"""
+    log_dir = os.path.join(root, "_index_log")
+    if not os.path.isdir(log_dir):
+        return None                     # 目录不存在 = 一条都没落过
+    return {rec.get("id") for rec in ShardedLog.read_all(log_dir)
+            if rec.get("id")}
+
+
+def main():
+    roots = []
+    try:
+        # ---------- ① 真实在役入口：review_cli accept → 进程 B 读 ----------
+        print("\n【①】subprocess 跑 review_cli accept（正常完成）→ 进程 B 读")
+        root_1 = tempfile.mkdtemp(prefix="clivis_1_")
+        roots.append(root_1)
+        pid = _propose(root_1, "vis-acc-node",
+                       "P1b 可见性守卫：accept 落盘后其它进程立即可见。")
+        r = _run_cli(root_1, ["accept", pid, "--root", root_1,
+                              "--reason", "可见性守卫"])
+        check("review_cli accept 退出码 0", r.returncode == 0,
+              (r.stdout or r.stderr or "")[:200])
+        b = _spawn(READ_CHILD, root_1, "vis-acc-node")   # 全新子进程 _load_index+read
+        m = re.search(r"READ (\d)", b.stdout or "")
+        check("进程 B 读回业务节点 vis-acc-node 可见",
+              bool(m) and m.group(1) == "1",
+              (b.stdout or b.stderr or "")[:200])
+        pa = MdCGSecure(root_1, principal=Principal(
+            actor="vis-reader", clearance="internal", can_write=True,
+            can_admin=True, role="designer", auth_mode="test"))
+        try:
+            recs = pa.review_records(pid)
+        finally:
+            pa.close()
+        check("进程 B 侧审计记录节点可见（review_records 命中 1 条）",
+              len(recs) == 1, str(recs))
+
+        # ---------- ②③ kill 形态：调库落盘后 os._exit → 落账契约 + 读 ----------
+        print("\n【②③】进程 A' 调库落 2 条即 os._exit（模拟被杀）→ 落账契约 + 进程 B 读")
+        root_2 = tempfile.mkdtemp(prefix="clivis_2_")
+        roots.append(root_2)
+        a = _spawn(KILL_CHILD, root_2)
+        check("进程 A' 经生产构造 _cg（autoflush=1 回显）",
+              a.returncode == 0 and "autoflush=1" in (a.stderr or ""),
+              (a.stderr or "")[:200])
+        ids = _log_ids(root_2)
+        check("③ 落账契约：A' 被杀退出后 _index_log 已含全部 2 条写入记录"
+              "（autoflush=1 写毕即落日志；修复前 autoflush=64 未达阈值=红）",
+              ids is not None and {"vis-node-1", "vis-node-2"} <= ids,
+              "log_ids=%s" % sorted(ids or []))
+        b2 = _spawn(READ_CHILD, root_2, "vis-node-1,vis-node-2")   # 全新子进程读
+        m2 = re.search(r"READ (\d) (\d)", b2.stdout or "")
+        check("② 进程 B 读回 kill 形态的两条节点均可见",
+              bool(m2) and m2.group(1) == "1" and m2.group(2) == "1",
+              (b2.stdout or b2.stderr or "")[:200])
+
+        # ---------- ④ 同病工具面：三处同款补 autoflush=1 ----------
+        print("\n【④】同病工具面 autoflush=1")
+        cg_rv = None
+        try:
+            from . import review_cli as _rv
+            cg_rv = _rv._cg(argparse.Namespace(root=root_1))
+            check("review_cli._cg 构造 autoflush==1", cg_rv.autoflush == 1,
+                  str(cg_rv.autoflush))
+        finally:
+            if cg_rv is not None:
+                cg_rv.close()
+        from . import evidence as _ev
+        cg_ev = _ev._open_cg(root_1)
+        try:
+            check("evidence._open_cg 构造 autoflush==1", cg_ev.autoflush == 1,
+                  str(cg_ev.autoflush))
+        finally:
+            cg_ev.close()
+        for rel, anchor in (
+                ("scripts/linkref_backfill.py",
+                 "cg = MdCGSecure(a.root, principal=p, autoflush=1)"),
+                ("scripts/migrate_restricted.py", None)):
+            with open(os.path.join(REPO, rel), encoding="utf-8") as f:
+                src = f.read()
+            if anchor is not None:
+                ok = anchor in src
+            else:
+                # migrate_restricted 构造跨多行：断言构造语句带 autoflush=1
+                ok = re.search(r"MdCGSecure\([^)]*?auth_mode=\"test\"\), "
+                               r"autoflush=1\)", src, re.S) is not None
+            check("%s 构造语句带 autoflush=1（源级断言）" % rel, ok)
+    finally:
+        for r_ in roots:
+            shutil.rmtree(r_, ignore_errors=True)
+
+    print("\n" + "=" * 64)
+    print(f"PASS={PASS}  FAIL={FAIL}")
+    if FAILS:
+        print("失败项：" + "；".join(FAILS))
+    return 0 if FAIL == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())