@furongjun1999/dsh-memory 0.5.1 → 0.6.0

package/md_cg/test_none_id_write_guard.py

@@ -0,0 +1,165 @@
+# -*- coding: utf-8 -*-
+"""test_none_id_write_guard —— None.md 脏节点写入面守卫（DSH 在役库实测缺陷 P3）
+
+现场（DSH 端在役库实测）：``knowledge/orphan/None.md`` 出现在检索与 route 候选中
+参与打分。取证链（2026-09-26，临时库实弹复现）：
+
+  1. 批次 24（2a57c2a2，2026-09-24）之前 ``add()`` 对 node_id **零校验**，
+     ``path = os.path.join(d, f"{node_id}.md")`` 直拼——``add(None, ...)`` 直落
+     ``None.md``（旧版直接源头，git 取证 ``git show 2a57c2a2^:md_cg/mdcg.py``）。
+  2. 现行代码 ``add(None)``/``add("")`` 已被 P0-1 白名单拒绝（mdcg.py _NODE_ID_RE），
+     **但字符串 ``"None"``（Python ``str(None)`` 的污染形态）形状合法照常放行**：
+     实弹复现 ``add("None", ...)`` → 生成 ``knowledge/orphan/None.md``。
+     ``"null"``（TS/JS ``String(null)`` 形态）同族放行。这是现行写入面残留洞。
+  3. 盘上存量 ``None.md`` 经 ``_scan_nodes`` 全库扫描收录为 ``id="None"``，
+     ``search``/route 候选参与打分（复现实测命中）——与 DSH 病理现象完全吻合。
+
+修复（本守卫的红绿两态锚点）：``md_cg/mdcg.py`` ``add()`` 写入边界把空语义值的
+字符串化污染形态（整串精确等值 ``"None"`` / ``"null"``，**大小写敏感、不扩子串**）
+结构化拒绝（ValueError，fail-closed）——add 是全部写入链（writepipe 执行器 /
+review accept / identity / consolidate / branches）落盘的唯一真源边界，堵一处即
+全链路堵死。``_move_layer`` 等直写点只对已在索引中的既有节点操作，不新造 id。
+
+清理面（不在本守卫内，运维建议）：存量 None.md 属历史脏数据——删除
+``<root>/knowledge/orphan/None.md`` 文件后 ``rebuild_index()`` 即从索引与检索/
+route 候选中消失（[6] 的收录取证即清理有效性依据）；勿用 ``add("None",...)``
+覆写清理（修复后该形态被拒）。
+
+隔离纪律：全程 ``tempfile.mkdtemp`` 临时库，MDCG_ROOT/MDCG_TOKEN_FILE 不参与
+（库实例以显式 root 构造），不触真实令牌库与真实在役数据目录。
+
+自检 floor：断言总数低于 FLOOR 视为失败——防「探针面失效 → 假绿」。
+
+运行：python -X utf8 -m md_cg.test_none_id_write_guard
+"""
+from __future__ import annotations
+
+import os
+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
+
+FLOOR = 12           # 断言总数下限（防假绿）
+passed = failed = 0
+
+
+def check(name, cond, detail=""):
+    global passed, failed
+    if cond:
+        passed += 1
+        print("  [PASS] " + name)
+    else:
+        failed += 1
+        print("  [FAIL] " + name + "  " + str(detail)[:200])
+
+
+def _none_md_hits(root):
+    """盘面上所有 None.md（大小写不敏感——Windows 盘面本就不区分）。"""
+    hits = []
+    for dirpath, _dirs, files in os.walk(root):
+        for f in files:
+            if f.lower() == "none.md":
+                hits.append(os.path.relpath(os.path.join(dirpath, f), root)
+                            .replace("\\", "/"))
+    return sorted(hits)
+
+
+def main():
+    root = tempfile.mkdtemp(prefix="mdcg_none_guard_")
+    try:
+        return _run(root)
+    finally:
+        import shutil
+        shutil.rmtree(root, ignore_errors=True)   # 测毕清理（临时库纪律）
+
+
+def _run(root):
+    cg = MdCGOS(root)
+
+    print("[1] 红形态：字符串 \"None\"（str(None) 污染形态）在写入边界拒绝")
+    rejected = False
+    try:
+        nid = cg.add("None", "污染形态内容 无条件")
+        check("add(\"None\") 被拒绝", False, "返回了 " + repr(nid))
+    except ValueError as e:
+        rejected = True
+        check("add(\"None\") 被拒绝", True)
+        check("拒绝是结构化 ValueError 且消息点名形态",
+              "None" in str(e) and "node_id" in str(e), str(e)[:120])
+    check("盘面无 None.md 生成", _none_md_hits(root) == [], _none_md_hits(root))
+    check("索引无 id='None' 条目", "None" not in cg.index["nodes"])
+
+    print("[2] 红形态：字符串 \"null\"（String(null) 跨语言同族形态）")
+    try:
+        nid = cg.add("null", "跨语言污染形态内容 无条件")
+        check("add(\"null\") 被拒绝", False, "返回了 " + repr(nid))
+    except ValueError:
+        check("add(\"null\") 被拒绝", True)
+    check("盘面仍无 None.md/null.md", _none_md_hits(root) == [],
+          _none_md_hits(root))
+
+    print("[3] 防误杀：含 None/null 子串的合法 id 照常写入（只拒整串精确等值）")
+    ok1 = cg.add("NoneBot_1", "含 None 子串的合法 id 无条件")
+    ok2 = cg.add("nullify_test", "含 null 子串的合法 id 无条件")
+    check("add(\"NoneBot_1\") 正常", ok1 == "NoneBot_1")
+    check("add(\"nullify_test\") 正常", ok2 == "nullify_test")
+
+    print("[4] 既有语义不回退：None 本体 / falsy 仍结构化拒绝（P0-1）")
+    # 注：add(123) 是既有合法行为（"123" 匹配白名单），不入守卫——非字符串
+    # 原值入索引快照属相邻缺陷（_scan_nodes/_load_index 混型键 sorted 崩），
+    # 超出本守卫目标，取证记录于修复报告。
+    for bad in (None, "", 0):
+        try:
+            cg.add(bad, "非法形态内容")
+            check("add(%r) 仍被拒绝" % (bad,), False, "竟返回成功")
+        except ValueError:
+            check("add(%r) 仍被拒绝（ValueError）" % (bad,), True)
+
+    print("[5] writepipe 链：node_id=\"None\" 不落盘（DEFER/BLINDSPOT 短路入队"
+          "或落盘前被 add 边界拒绝，两态皆 fail-closed）")
+    from md_cg import writepipe
+    pipe = writepipe.WritePipeline()
+    writepipe.install_default_gates(pipe)
+    committed = None
+    try:
+        out = pipe.execute(cg, {"content": "writepipe 污染形态", "node_id": "None",
+                                "content_kind": "work_done",
+                                "生效条件": "writepipe 守卫探针"})
+        committed = out.get("committed")
+    except ValueError:
+        committed = False                       # 落盘前被 add 边界拒绝（修复态）
+    check("writepipe 对 node_id='None' 不提交落盘", committed is not True,
+          repr(committed))
+    check("盘面无 None.md（writepipe 后复查）", _none_md_hits(root) == [],
+          _none_md_hits(root))
+
+    print("[6] 存量脏数据收录取证：盘上 None.md 被 _scan_nodes 收进索引（DSH 病理机理；"
+          "亦是清理建议的依据——删文件 + rebuild 即消失）")
+    d = os.path.join(root, "knowledge", "orphan")
+    os.makedirs(d, exist_ok=True)
+    with open(os.path.join(d, "None.md"), "w", encoding="utf-8") as f:
+        f.write("---\nid: None\nlayer: knowledge\nimportance: 0.5\n"
+                "confidence: 0.6\ncreated_at: 1\ntags: []\n---\n\n历史脏数据内容\n")
+    cg2 = MdCGOS(root)                      # 重开：走 _scan_nodes 全库扫描
+    cg2.rebuild_index()
+    check("历史 None.md 被扫描收录（机理复证）", "None" in cg2.index["nodes"])
+    res, _m = cg2.search_rrf("历史脏数据内容", k=10, judge=False)
+    check("检索候选命中 id='None'（病理复证）",
+          any(r[0]["id"] == "None" for r in res), [r[0]["id"] for r in res])
+    os.remove(os.path.join(d, "None.md"))   # 清理后即消失（清理建议有效性）
+    cg3 = MdCGOS(root)
+    cg3.rebuild_index()
+    check("删文件 + rebuild 后 id='None' 从索引消失（清理有效）",
+          "None" not in cg3.index["nodes"])
+
+    check(f"断言总数不低于 FLOOR（{passed} >= {FLOOR}）", passed >= FLOOR)
+
+    print(f"\nnone_id_write_guard: {passed} 通过 / {failed} 失败")
+    return 0 if not failed 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())

package/package.json

@@ -1,10 +1,15 @@
 {
   "name": "@furongjun1999/dsh-memory",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "灵枢（Lingshu·líng shū）DeepSeek Harness 插件：完整大脑——长期记忆/知识飞轮/自我认知/递归反思接入 DSH，对话自动沉淀进 md_cg 认知图（md 文档）",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
+  "bin": {
+    "lingshu": "./lib/cli.js",
+    "lingshu-init": "./lib/init.js",
+    "dsh-memory": "./lib/cli.js"
+  },
   "exports": {
     ".": {
       "types": "./lib/index.d.ts",

package/src/cli.ts

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+/**
+ * cli.ts —— `lingshu` 主命令入口（npx 兼容分发器）
+ *
+ * 为什么有三个 bin（package.json bin）：
+ *   · `lingshu`       → 本文件：`lingshu init` 分发到 init.ts（未来其它子命令也挂这）；
+ *   · `lingshu-init`  → lib/init.js：单命令直入（不想敲子命令的场景）；
+ *   · `dsh-memory`    → 本文件：npx 的同名匹配规则——`npx @furongjun1999/dsh-memory init`
+ *     在包有多个 bin 时，只会自动运行**与包名末段同名**的 bin（npm 官方口径），
+ *     缺这个入口 npx 会因「多个 bin 且无同名」直接报错，一键配置命令即失效。
+ *
+ * 零运行时依赖：只用 Node 内置模块。
+ */
+import { resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { runInit } from './init.js'
+
+const USAGE = [
+  '灵枢（Lingshu）命令行',
+  '',
+  '用法：lingshu <命令>',
+  '',
+  '命令：',
+  '  init [选项]    一键配置生成器（交互三问；参数齐则跳过问答）',
+  '                 选项：--end <dsh|claude|codex|generic> --root <dir> --python <interpreter>',
+  '',
+  '示例：',
+  '  npx @furongjun1999/dsh-memory init',
+  '  npx @furongjun1999/dsh-memory init -- --end claude --root D:/mem --python python3',
+].join('\n')
+
+/** 入口分发：argv 为去掉 node 与本脚本路径后的参数。仅导出供测试。 */
+export async function main(argv: string[]): Promise<number> {
+  const cmd = argv[0] ?? ''
+  if (cmd === 'init') {
+    await runInit(argv.slice(1))
+    return 0
+  }
+  process.stdout.write(`${USAGE}\n`)
+  if (cmd === '--help' || cmd === '-h' || cmd === 'help') return 0
+  if (cmd !== '') process.stderr.write(`未知命令「${cmd}」。\n`)
+  else process.stderr.write('缺少命令。\n')
+  return 1
+}
+
+function isMainEntry(): boolean {
+  const entry = process.argv[1]
+  if (!entry) return false
+  try {
+    const entryUrl = pathToFileURL(resolve(entry)).href
+    return import.meta.url === entryUrl
+      || (process.platform === 'win32' && import.meta.url.toLowerCase() === entryUrl.toLowerCase())
+  } catch {
+    return false
+  }
+}
+
+if (isMainEntry()) {
+  main(process.argv.slice(2))
+    .then((code) => { process.exitCode = code })
+    .catch((e: unknown) => {
+      process.stderr.write(`lingshu：${e instanceof Error ? e.message : String(e)}\n`)
+      process.exitCode = 1
+    })
+}