@furongjun1999/dsh-memory 0.6.0 → 0.7.0

package/md_cg/test_unify_scope.py

@@ -0,0 +1,182 @@
+# -*- coding: utf-8 -*-
+"""统一归一层作用域收窄守卫（2026-09-30 使用者裁定）
+
+口径：`semantic/unify.py::unify_query` **只对英文内容做翻译归一，中文内容
+原样不动**——query 按中文段/非中文段切开，中文段逐字保留、绝不送 segment。
+旧口径「含任一 ASCII 字母即整条归一」把中夹英 query 的中文部分逐字切开
+（「自我接纳」→「自 我 接 纳」），本件钉住收窄后的语义。
+
+**开关前提**：归一层缺省**关**（2026-09-30 使用者裁定，唯一开态 = 显式
+`MDCG_UNIFY_QUERY=1`）；本件第 1 节钉三态，其后各节一律**显式开**下跑。
+缺省态的三态与两侧一致性守卫见 `md_cg/test_unify_default_off.py`。
+
+两侧同源：期望值取自 `md_cg/semantic/unify_fixture.json`——Rust 侧
+`rust/src/atoms.rs::tests::unify_mixed_fixture_matches_python` 用 include_str!
+嵌入**同一份**文件；任一侧漂移即红（两侧逐位相同）。
+
+跑法：python -X utf8 -m md_cg.test_unify_scope
+"""
+import json
+import os
+import sys
+
+HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if HERE not in sys.path:
+    sys.path.insert(0, HERE)
+
+from md_cg.semantic.canonical import is_zh_char      # noqa: E402
+from md_cg.semantic.unify import unify_on, unify_query  # noqa: E402
+
+FIXTURE = os.path.join(HERE, "md_cg", "semantic", "unify_fixture.json")
+
+N = 0
+BAD = []
+
+
+# 生效条件：单参 cond 为真值判定、msg 为说明串；恒累加计数 N，cond 为假时把 msg 记入模块级 BAD（**不中断**）——收集式断言使「定点变异红了几项」可数（首条即停的 assert 风格数不出红项数）。
+def ok(cond, msg):
+    global N
+    N += 1
+    if not cond:
+        BAD.append(msg)
+
+
+# 生效条件：单参 text 为任意字符串，按 canonical.is_zh_char 切出其中的中文连续段，返回保序的段列表（无中文段时为空列表）；仅供本守卫做「中文段逐字保留」的结构判据。
+def zh_runs(text):
+    """文本里的中文连续段（判据同 unify_query：canonical.is_zh_char）。"""
+    out, buf = [], []
+    for ch in text:
+        if is_zh_char(ch):
+            buf.append(ch)
+        elif buf:
+            out.append("".join(buf))
+            buf = []
+    if buf:
+        out.append("".join(buf))
+    return out
+
+
+# ---- 1 · 开关三态（2026-09-30 使用者裁定：缺省由开翻为关；唯一开态 = 显式 "1"）----
+# 本件测的是**作用域收窄**语义，故从本节之后各节必须在**显式开**（=1）下跑：
+# 缺省已关（未设即关），若不显式开，下面 3~8 节全会退化成恒真（对实现零约束力）。
+# 缺省三态守卫另立一件：md_cg/test_unify_default_off.py（两件分工不同，勿互推）。
+ok(unify_on() is False,
+   "MDCG_UNIFY_QUERY 未设即关（缺省关，2026-09-30 翻）")
+os.environ["MDCG_UNIFY_QUERY"] = "0"
+try:
+    ok(unify_on() is False, "=0 显式关")
+    for t in ("I eat beef yesterday", "领养 LGBTQ 群体", "自我接纳",
+              "  beef 报告  ", "2024 报告"):
+        ok(unify_query(t) == t, "开关关：一律原样返回 %r" % t)
+finally:
+    os.environ.pop("MDCG_UNIFY_QUERY", None)
+os.environ["MDCG_UNIFY_QUERY"] = "1"
+ok(unify_on() is True, "=1 显式开（英文对照路要用）——本件余下各节的运行前提")
+
+# ---- 2 · 空/None/无 ASCII 字母：原样返回（未 strip 的入参）----
+ok(unify_query(None) is None, "None 原样")
+ok(unify_query("") == "", "空串原样")
+ok(unify_query("  自我接纳  ") == "  自我接纳  ",
+   "纯中文（无 ASCII 字母）原样返回入参本身（不 strip）")
+ok(unify_query("2024 报告") == "2024 报告", "纯中文+数字（无字母）原样")
+ok(unify_query("，。") == "，。", "纯标点（无字母）原样")
+
+# ---- 3 · 纯英文仍翻译（收窄不得关掉英文链路）----
+ok(unify_query("I eat beef yesterday") == "我 吃 牛肉 昨天",
+   "纯英文仍归一：%r" % unify_query("I eat beef yesterday"))
+ok(unify_query("wrote") == "写", "纯英文时态还原仍生效")
+
+# ---- 4 · 纯中文原样（旧口径会被逐字切开）----
+for t, why in (("自我接纳", "旧口径「自 我 接 纳」"),
+               ("慈善跑", "旧口径「慈 善 跑」"),
+               ("蜂群调度 依赖门禁", "旧口径逐字切开")):
+    ok(unify_query(t) == t, "纯中文原样（%s）：%r" % (why, t))
+
+# ---- 5 · fixture 逐位对拍（两侧同源：Rust 侧嵌同一份文件）----
+with open(FIXTURE, encoding="utf-8") as f:
+    FX = json.load(f)["cases"]
+ok(len(FX) >= 12, "fixture 用例数 >= 12：%d" % len(FX))
+for c in FX:
+    got = unify_query(c["in"])
+    ok(got == c["out"],
+       "fixture 逐位不符 [%s] in=%r got=%r want=%r"
+       % (c["name"], c["in"], got, c["out"]))
+
+# ---- 5b · 单侧钉：任务原型例（Python 侧形态）----
+# 这两例**不入共享 fixture**：非中文段是未登录的**大写**词（LGBTQ），两侧对
+# 「未命中词表的大写词」存在**既有**非对称（Python 保留原大小写 / Rust 经
+# normalize_en 一律 lower 化——用 rust 单测实测 `领养 lgbtq 群体` 取证，
+# 2026-09-30），故两侧钉不出同一期望值。此非本次收窄引入，也非本次范围；
+# 但它是端到端（Python 侧）实际生效的形态，故在此单侧钉死。
+for t in ("领养 LGBTQ 群体 支持 包容", "领养 机构 LGBTQ 群体 支持 包容"):
+    ok(unify_query(t) == t, "中夹英原型例：中文段逐字保留、英文片段原样：%r" % t)
+
+# ---- 6 · 结构判据（对**实现产物**断言）：混合 query 的中文段逐字保留 ----
+# 2026-09-30 清理批次（甲2）修假守卫：本节此前比的是 fixture 的**期望值**
+# （`run in c["out"]`——拿期望比期望），对实现零约束力：做「中文段也送
+# segment」变异时本节 0 项红。现改为直接调 `unify_query` 并对**产物**断言：
+# 中文段必须在产物里逐字出现，且其逐字切开形（`" ".join(run)`）不得出现。
+# 单字中文段（如「年」）的切开形与其本身同形，故切开判据只在 len(run) > 1
+# 时施加（否则是恒假的伪红）。
+for c in FX:
+    got = unify_query(c["in"])
+    for run in zh_runs(c["in"]):
+        ok(run in got,
+           "中文段未逐字保留（被改写）[%s] in=%r 段=%r got=%r"
+           % (c["name"], c["in"], run, got))
+        if len(run) > 1:
+            ok(" ".join(run) not in got,
+               "中文段被逐字切开（送了 segment）[%s] in=%r 段=%r got=%r"
+               % (c["name"], c["in"], run, got))
+# 原型例（任务口径原句）同样对产物断言：中文段逐字保留、英文片段不动
+for t in ("领养 LGBTQ 群体", "AI 记忆 系统", "自我接纳", "蜂群调度 依赖门禁"):
+    got = unify_query(t)
+    for run in zh_runs(t):
+        ok(run in got and " ".join(run) not in got,
+           "原型例中文段逐字保留 [%r] 段=%r got=%r" % (t, run, got))
+ok(zh_runs("领养 LGBTQ 群体") == ["领养", "群体"], "中文段抽取判据自检")
+
+# ---- 7 · 空白折叠为单空格（段内/段间）----
+ok(unify_query("  beef   报告  ") == "牛肉 报告", "前后空白+多空格折叠")
+ok(unify_query("beef\t报告") == "牛肉 报告", "制表符折叠为单空格")
+
+# ---- 8 · 异常降级为原样（不阻断检索主链路）----
+import md_cg.semantic.canonical as _cn   # noqa: E402
+_saved = _cn.query_atoms
+_cn.query_atoms = lambda _t: (_ for _ in ()).throw(RuntimeError("boom"))
+try:
+    src = "beef 报告"
+    ok(unify_query(src) == src, "链路抛异常 → 原样返回")
+finally:
+    _cn.query_atoms = _saved
+
+# ---- 9 · 中文判据边界（2026-09-30 清理批次乙2）：仅长度恰为 1 的串可为真 ----
+# 事实读数（本机实测，见清理批次回执）：留池条目 ⑥ 记「`is_zh_char("")` 返回
+# True」——**实测不成立**：`ZH_LO <= ch <= ZH_HI` 是链式比较，对空串即假，
+# 收紧前 `is_zh_char("")` 已返回 False。真实外溢面是**多字符串**——
+# 收紧前 `is_zh_char("中文")` 判真（首字符在区间即真）。两处消费点
+# （unify._runs / 本文件 zh_runs）均逐字符传入，故本收紧对存量行为零变更，
+# 只把判据面（长度恰为 1）钉死。
+ok(is_zh_char("") is False, "空串不是中文（判据面外）")
+ok(is_zh_char("中文") is False, "多字符串为假（首字符在区间亦然）")
+ok(is_zh_char("中a") is False, "多字符串为假（汉字+ASCII 混合）")
+ok(is_zh_char("中") is True, "单汉字为真")
+ok(is_zh_char("\u4e00") is True, "区间下界单汉字为真")
+ok(is_zh_char("\u9fff") is True, "区间上界单汉字为真")
+ok(is_zh_char("\u4dff") is False, "区间下界外单字符为假（U+4DFF）")
+ok(is_zh_char("\ua000") is False, "区间上界外单字符为假（U+A000）")
+ok(is_zh_char("a") is False, "单 ASCII 字母为假")
+# 两侧边界语义一致性：Rust `text::is_zh` 收 char，天然无空/多字符二态；
+# 本侧判据收紧后，「长度 != 1 一律 False」与「按 char 判区间」等价
+# （见 rust/src/text.rs::is_zh docstring 的边界约定段）。
+for ch in ("\u4e00", "\u9fff"):
+    ok(is_zh_char(ch) and len(ch) == 1, "单字符区间内 → 真（与 Rust is_zh 等价）%r" % ch)
+
+os.environ.pop("MDCG_UNIFY_QUERY", None)   # 归还进程环境（本件全程已显式开完）
+
+if BAD:
+    print("[test_unify_scope] FAILED %d/%d 断言：" % (len(BAD), N))
+    for b in BAD:
+        print("  - " + b)
+    raise SystemExit(1)
+print("[test_unify_scope] %d 断言全绿（fixture %d 例，两侧同源）" % (N, len(FX)))

package/md_cg/test_v21r1_package_version.py

@@ -0,0 +1,310 @@
+# -*- coding: utf-8 -*-
+"""md_cg · 包版本读取 fail-closed 守卫（v21-R1：非对象 package.json 让服务起不来）
+
+缺陷（修复前）：`md_cg/mcp_server.py:47-53` 与 `hive/hive_mcp/mcp_server.py:48-54`
+的 `_package_version` 只捉 `(OSError, ValueError)`，随后**无条件** `.get("version")`：
+  · `package.json` 是**合法 JSON 但顶层非对象**（`[1,2]` / `"0.1.0"` / `123` /
+    `null` / `true`）→ `.get` 抛 AttributeError，**逃出 except**；
+  · 而 `SERVER_VERSION = _package_version()`（md_cg:57 / hive:58）是**模块级
+    立即求值**——异常发生在 import 期，`python -m md_cg.mcp_server` / `-m
+    hive.hive_mcp.mcp_server` 连 initialize 都发不出就退出（服务起不来，
+    与「版本号退化」完全不是一个量级）；
+  · `{"version": 123}` 不抛但把 **int** 当版本号塞进 initialize 的
+    serverInfo.version（协议要求字符串），调用方拿到错类型。
+
+修复：`_package_version` 只认「读到 dict 且 "version" 为**非空字符串**」，其余
+（不可读/JSON 非法/顶层非对象/version 非字符串/空串）一律回落 "0.1.0"；except
+补 TypeError/AttributeError 兜底。同族既有守卫 `md_cg/test_server_version.py`
+只覆盖「好文件 → 版本联动」，本守卫补**坏文件**面。
+
+守卫（四组，全部临时包根 + 哑主密钥/哑令牌，绝不写真实 package.json、绝不触
+真实 ~/.mdcg）：
+  [1] 变体矩阵（16 形态 × 2 模块，真实 import + importlib.reload 重跑模块级
+      `SERVER_VERSION = _package_version()`）：修前 `[1,2]` 等非对象形态报
+      AttributeError、`{"version": 123}` 得 int 123；修后一律回落 "0.1.0"，
+      合法形态（"9.9.9"/"0.6.0"）原样；
+  [2] hive 握手端到端（真实 stdio 子进程，临时包根内 `package.json=[1,2]`）：
+      修前进程 import 期即死、无任何响应；修后服务起得来且 initialize 自报
+      "0.1.0"；换合法 version 时自报该值（证明该腿真有判别力，不是常量）；
+  [3] md_cg 握手端到端（同上，另加临时 MDCG_ROOT + 哑令牌/哑主密钥）；
+  [4] 不回归：真实仓库的 md_cg/hive 两模块 SERVER_VERSION 仍等于真实
+      package.json 的 version（既有 test_server_version.py 口径）。
+
+运行：python -m md_cg.test_v21r1_package_version
+"""
+from __future__ import annotations
+
+import gc
+import glob
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+
+from . import crypto, tokens
+
+PASS = FAIL = 0
+FAILS = []
+
+REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+DUMMY_KEK = "ab" * 32                       # 哑主密钥：子进程绝不触真实密钥库
+
+
+def _clean(root):
+    """尽力清理临时包根：Windows 下句柄未释放会让 rmtree 静默失败，故重试并告警。"""
+    for _ in range(4):
+        shutil.rmtree(root, ignore_errors=True)
+        if not os.path.exists(root):
+            return
+        gc.collect()
+        time.sleep(0.2)
+    print("  [warn] 临时目录未能清理（句柄占用？）：%s" % os.path.basename(root))
+
+# (package.json 正文（None=删文件）, 期望版本)
+VARIANTS = [
+    ("[1, 2]", "0.1.0"),                     # 顶层数组（AttributeError 逃逸）
+    ('"0.9.9"', "0.1.0"),                    # 顶层裸字符串
+    ("123", "0.1.0"),                        # 顶层数字
+    ("null", "0.1.0"),                       # 顶层 null
+    ("true", "0.1.0"),                       # 顶层 bool
+    ('{"version": 123}', "0.1.0"),           # int 版本号曾原样进握手
+    ('{"version": ["9.9.9"]}', "0.1.0"),
+    ('{"version": {"a": 1}}', "0.1.0"),
+    ('{"version": null}', "0.1.0"),
+    ('{"version": ""}', "0.1.0"),
+    ('{"version": "   "}', "0.1.0"),
+    ('{"name": "x"}', "0.1.0"),              # 无 version 键
+    ("{", "0.1.0"),                          # JSON 非法（ValueError 老路）
+    (None, "0.1.0"),                         # 文件缺失
+    ('{"version": "9.9.9"}', "9.9.9"),       # 合法
+    ('{"version": "0.6.0", "extra": [1]}', "0.6.0"),   # 合法（多键）
+]
+
+DRIVER = '''# -*- coding: utf-8 -*-
+"""测试驱动：逐变体写 package.json 后 reload 两个 server 模块并回报结果。
+
+只做两件事：真实 import（触发模块级 `SERVER_VERSION = _package_version()`）
+与 importlib.reload（重跑同一句）——即缺陷的**真实消费点**，不改被测代码。
+"""
+import importlib
+import json
+import os
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+MODS = ("md_cg.mcp_server", "hive.hive_mcp.mcp_server")
+VARIANTS = json.load(open(os.path.join(HERE, "_variants.json"), encoding="utf-8"))
+
+
+def write_pkg(body):
+    p = os.path.join(HERE, "package.json")
+    if body is None:
+        if os.path.exists(p):
+            os.remove(p)
+        return
+    with open(p, "w", encoding="utf-8") as f:
+        f.write(body)
+
+
+def probe():
+    out = {}
+    for name in MODS:
+        try:
+            m = importlib.import_module(name)          # 首次 import
+        except Exception as e:                          # noqa: BLE001
+            out[name] = ["IMPORT_ERR", type(e).__name__]
+            continue
+        try:
+            m = importlib.reload(m)                     # 重跑模块级赋值
+            v = m.SERVER_VERSION
+            out[name] = ["OK", repr(v), type(v).__name__]
+        except Exception as e:                          # noqa: BLE001
+            out[name] = ["RELOAD_ERR", type(e).__name__]
+    return out
+
+
+results = []
+write_pkg('{"version": "0.0.0"}')                       # 先保证两模块能 import
+for i, body in enumerate(VARIANTS):
+    write_pkg(body)
+    results.append({"i": i, "r": probe()})
+print(json.dumps(results))
+'''
+
+
+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(f"{name} · {detail}" if detail else name)
+        print(f"  [FAIL] {name}" + (f" · {detail}" if detail else ""))
+
+
+def _mk_pkg_root(tmp, name: str) -> str:
+    """临时包根：md_cg/ 与 hive/hive_mcp/ 的真实源码副本 + 根 package.json 占位。
+
+    副本是**当前源码**（改动即生效），根下 package.json 决定 `_package_version`
+    读到的内容——真实 __file__ 推导，不 mock 任何函数。
+    """
+    root = os.path.join(tmp, name)
+    os.makedirs(root, exist_ok=True)
+    shutil.copytree(os.path.join(REPO, "md_cg"), os.path.join(root, "md_cg"),
+                    ignore=shutil.ignore_patterns("__pycache__"))
+    os.makedirs(os.path.join(root, "hive", "hive_mcp"), exist_ok=True)
+    shutil.copy(os.path.join(REPO, "hive", "__init__.py"),
+                os.path.join(root, "hive", "__init__.py"))
+    for fn in glob.glob(os.path.join(REPO, "hive", "hive_mcp", "*.py")):
+        shutil.copy(fn, os.path.join(root, "hive", "hive_mcp", os.path.basename(fn)))
+    with open(os.path.join(root, "package.json"), "w", encoding="utf-8") as f:
+        f.write('{"version": "0.0.0"}')
+    return root
+
+
+def _dry_run(root, variants) -> list:
+    """跑驱动（真实 import/reload），返回每个变体的逐模块结果。"""
+    with open(os.path.join(root, "_variants.json"), "w", encoding="utf-8") as f:
+        json.dump([b for b, _e in variants], f, ensure_ascii=False)
+    with open(os.path.join(root, "_drv.py"), "w", encoding="utf-8") as f:
+        f.write(DRIVER)
+    env = dict(os.environ)
+    env["PYTHONPATH"] = REPO                       # 同级仓库根模块（aeis_core 等）
+    env["PYTHONUTF8"] = "1"
+    p = subprocess.run([sys.executable, "-X", "utf8", "_drv.py"], cwd=root,
+                       env=env, capture_output=True, text=True,
+                       encoding="utf-8", timeout=300)
+    if p.returncode != 0:
+        raise RuntimeError("驱动失败 rc=%s stderr=%s" % (p.returncode,
+                                                        (p.stderr or "")[-400:]))
+    return json.loads(p.stdout.strip().splitlines()[-1])
+
+
+def _handshake(root, module: str, env: dict):
+    """真实 stdio 子进程发 initialize，返回 (版本, 原始响应, stderr)。"""
+    p = subprocess.Popen([sys.executable, "-X", "utf8", "-m", module],
+                         stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+                         stderr=subprocess.PIPE, text=True, encoding="utf-8",
+                         env=env, cwd=root)
+    try:
+        p.stdin.write(json.dumps({"jsonrpc": "2.0", "id": 1, "method": "initialize",
+                                  "params": {"protocolVersion": "2024-11-05",
+                                             "capabilities": {},
+                                             "clientInfo": {"name": "v21r1",
+                                                            "version": "1"}}}) + "\n")
+        p.stdin.flush()
+        line = p.stdout.readline()                  # 进程死 → EOF，不阻塞
+        if not line:
+            return None, None, (p.stderr.read() or "")[-300:]
+        resp = json.loads(line)
+        ver = ((resp.get("result") or {}).get("serverInfo") or {}).get("version")
+        return ver, resp, ""
+    finally:
+        try:
+            p.stdin.write(json.dumps({"jsonrpc": "2.0", "id": 2,
+                                      "method": "shutdown"}) + "\n")
+            p.stdin.flush()
+            p.wait(timeout=10)
+        except Exception:                           # noqa: BLE001
+            p.kill()
+
+
+def main():
+    print("=" * 68)
+    print("包版本读取 fail-closed（v21-R1）")
+    print("=" * 68)
+    tmp = tempfile.mkdtemp(prefix="v21r1_pkg_")
+    try:
+        root = _mk_pkg_root(tmp, "pkg")
+        mods = ("md_cg.mcp_server", "hive.hive_mcp.mcp_server")
+
+        # ---------- [1] 变体矩阵（真实 import + reload） ----------
+        print("\n[1] 变体矩阵（16 形态 × 2 模块，真实 import/reload）")
+        res = _dry_run(root, VARIANTS)
+        for rec, (body, want) in zip(res, VARIANTS):
+            for m in mods:
+                got = rec["r"].get(m) or ["<缺失>"]
+                ok = got[0] == "OK" and got[1] == repr(want) and got[2] == "str"
+                check(f"[1] {m.split('.')[0]}：{body!r} → {want!r}（必须 str）", ok,
+                      f"got {got!r}")
+
+        # ---------- [2] hive 握手端到端 ----------
+        print("\n[2] hive 握手端到端（临时包根 package.json=[1, 2]）")
+        bad_root = _mk_pkg_root(tmp, "pkg_bad")
+        with open(os.path.join(bad_root, "package.json"), "w", encoding="utf-8") as f:
+            f.write("[1, 2]")
+        env = dict(os.environ)
+        env["PYTHONPATH"] = REPO
+        env["PYTHONUTF8"] = "1"
+        ver, resp, err = _handshake(bad_root, "hive.hive_mcp.mcp_server", env)
+        check("[2] 绿：服务起得来且握手自报回落版本（修前 import 期 AttributeError，无响应）",
+              isinstance(ver, str) and ver == "0.1.0",
+              f"ver={ver!r} stderr={err!r}")
+        check("[2] 绿：serverInfo.version 为字符串（协议要求）",
+              isinstance(ver, str), f"{type(ver).__name__}")
+        with open(os.path.join(bad_root, "package.json"), "w", encoding="utf-8") as f:
+            f.write('{"version": "9.9.9"}')
+        ver2, _r2, err2 = _handshake(bad_root, "hive.hive_mcp.mcp_server", env)
+        check("[2] 判别力对照：合法 version 时握手自报 9.9.9", ver2 == "9.9.9",
+              f"ver={ver2!r} stderr={err2!r}")
+
+        # ---------- [3] md_cg 握手端到端 ----------
+        print("\n[3] md_cg 握手端到端（临时包根 + 临时 MDCG_ROOT + 哑令牌/哑密钥）")
+        cg_root = os.path.join(tmp, "cg_lib")
+        tf = os.path.join(tmp, "_tokens.json")
+        tok = tokens.issue("designer", actor="v21r1", path=tf)
+        aux = os.path.join(tmp, "auxdir")           # 注：不能叫 aux（Win32 保留设备名）
+        os.makedirs(aux, exist_ok=True)
+        env2 = dict(os.environ)
+        env2.update({"PYTHONPATH": REPO, "PYTHONUTF8": "1",
+                     "MDCG_ROOT": cg_root, "MDCG_TOKEN_FILE": tf,
+                     "MDCG_TOKEN": tok["token"], "MDCG_MASTER_KEY": DUMMY_KEK,
+                     "MDCG_AUX_ROOT": aux, "MDCG_SUSTAIN": "0",
+                     "MDCG_SUSTAIN_ENABLED": "0"})
+        for k in ("MDCG_LEGACY_ENV_AUTH", "MDCG_CAN_ADMIN", "MDCG_CAN_WRITE",
+                  "MDCG_CLEARANCE", "MDCG_ACTOR", "MDCG_LEGACY_ENV_ADMIN"):
+            env2.pop(k, None)
+        check("[3] 隔离声明：临时库 + 哑令牌 + 哑主密钥",
+              os.path.abspath(cg_root).startswith(os.path.abspath(tmp))
+              and env2["MDCG_MASTER_KEY"] == "ab" * 32
+              and env2["MDCG_TOKEN"] == tok["token"])
+        root_bad = _mk_pkg_root(tmp, "pkg_bad2")
+        with open(os.path.join(root_bad, "package.json"), "w", encoding="utf-8") as f:
+            f.write("[1, 2]")
+        ver3, _r3, err3 = _handshake(root_bad, "md_cg.mcp_server", env2)
+        check("[3] 绿：md_cg 服务起得来且握手自报回落版本", ver3 == "0.1.0",
+              f"ver={ver3!r} stderr={err3!r}")
+        check("[3] 绿：握手可用（result 结构完整，证明不是半启动）",
+              isinstance(_r3, dict) and (_r3.get("result") or {}).get("serverInfo"),
+              str(_r3)[:120])
+
+        # ---------- [4] 不回归：真实包根的版本联动 ----------
+        print("\n[4] 不回归：真实 package.json 版本仍被两模块读到")
+        from . import mcp_server as mdcg_server
+        from hive.hive_mcp import mcp_server as hive_server
+        with open(os.path.join(REPO, "package.json"), encoding="utf-8") as f:
+            want = json.load(f)["version"]
+        check("[4] md_cg SERVER_VERSION == 真实 package.json version",
+              mdcg_server.SERVER_VERSION == want,
+              f"got {mdcg_server.SERVER_VERSION!r} want {want!r}")
+        check("[4] hive SERVER_VERSION == 真实 package.json version",
+              hive_server.SERVER_VERSION == want,
+              f"got {hive_server.SERVER_VERSION!r} want {want!r}")
+        check("[4] 两者均为 str", all(isinstance(x, str) for x in
+                                     (mdcg_server.SERVER_VERSION, hive_server.SERVER_VERSION)))
+    finally:
+        _clean(tmp)
+
+    print("\n" + "=" * 68)
+    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_writepipe.py

@@ -45,8 +45,9 @@ def _mk_cg(tmp, role="designer"):
     return MdCGSecure(root, principal=p)
 
 
-def _policy(tmp, required=("PASSED",), forbidden=("FORBIDDEN_WORD",)):
-    path = os.path.join(tmp, "policy.json")
+def _policy(tmp, required=("PASSED",), forbidden=("FORBIDDEN_WORD",),
+            name="policy.json"):
+    path = os.path.join(tmp, name)
     with open(path, "w", encoding="utf-8") as f:
         json.dump({"forbidden": list(forbidden),
                    "required": list(required)}, f)
@@ -93,8 +94,13 @@ def _run(tmp):
     _check("REJECT负记忆", out.get("moved_to") == "rejected"
            and out.get("committed") is False, repr(out))
 
-    # DEFER（无规则文件 → 无法判定 → 入审核队列）+ 幂等去重联动
-    os.environ.pop("MDCG_POLICY_FILE", None)
+    # DEFER（空规则库 → 无法判定 → 入审核队列）+ 幂等去重联动
+    # 迁移（issue #43，2026-09-29）：修前「未设 env」= 空规则 → DEFER；修后未设
+    # 会回落到包内默认 data/policy.json，本用例内容无六要素 → 变 REJECT。此处
+    # 考的是 **DEFER 出口 + 幂等去重联动**（与策略来源无关），故显式给一份空
+    # 规则库复现原口径——断言一字不改。
+    os.environ["MDCG_POLICY_FILE"] = _policy(tmp, required=(), forbidden=(),
+                                             name="policy_empty.json")
     a = {"content_kind": "text", "content": "无规则可判的内容",
          "layer": "knowledge"}
     out1 = pipe.execute(cg, dict(a))