@furongjun1999/dsh-memory 0.4.11 → 0.5.1

package/md_cg/test_interop.py

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+"""批次10：互验工具库单测——A1/A2/A3 双态 + verdict 脱敏硬门禁。
+
+能红对照：A3 断言在「验证者指纹被本轮改动」（判据面漂移）时必红；
+脱敏门禁对绝对路径/prompt 字段/API key 必拦。
+运行：python -m md_cg.test_interop  （退出码 0 = 全绿）
+"""
+import json
+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.interop import (InteropSanityError, assert_a1, assert_a2, assert_a3,
+                           freeze, make_verdict, sanity_check_verdict)
+
+PASS = FAIL = 0
+
+
+def check(name, ok, detail=""):
+    global PASS, FAIL
+    if ok:
+        PASS += 1
+        print(f"  [ok] {name}")
+    else:
+        FAIL += 1
+        print(f"  [FAIL] {name}  {detail}")
+
+
+def main():
+    tmp = tempfile.mkdtemp(prefix="mdcg_interop_")
+    try:
+        print("[1] 冻结与 A3（承重墙）")
+        frozen = freeze("iter_test_001", out_dir=os.path.join(tmp, "interop"))
+        digest = frozen["digest"]
+        check("1a 冻结凭证含 digest 与文件清单",
+              bool(digest) and len(frozen["files"]) >= 3, str(digest)[:20])
+        r3 = assert_a3(frozen, digest)
+        check("1b A3 成立（指纹==冻结值）", r3["ok"] is True)
+        r3_bad = assert_a3(frozen, digest[:-1] + ("0" if digest[-1] != "0" else "1"))
+        check("1c A3 红（验证者指纹漂移=判据被本轮改动——必红）",
+              r3_bad["ok"] is False)
+        frozen2 = dict(frozen)
+        frozen2["digest"] = "different"
+        check("1d A3 红（冻结值与声明不符）",
+              assert_a3(frozen2, digest)["ok"] is False)
+
+        print("[2] A1/A2")
+        check("2a A1 成立（verifier≠subject）",
+              assert_a1("verifier", "main")["ok"] is True)
+        check("2b A1 红（同实例=自验无效）",
+              assert_a1("main", "main")["ok"] is False)
+        check("2c A2 成立（指纹不同）",
+              assert_a2("aaaa", "bbbb")["ok"] is True)
+        check("2d A2 红（同指纹）", assert_a2("aaaa", "aaaa")["ok"] is False)
+
+        print("[3] verdict 脱敏硬门禁（§7.3，入库即公开）")
+        v = make_verdict("iter_test_001", "verifier", "fp_ver", "main", "fp_sub",
+                         "verifier-worktree", "2026-09-23T00:00:00", "pass",
+                         27, 0, [{"test": "recover_by_artifact", "ok": True}])
+        check("3a 合规 verdict 通过门禁", isinstance(v, dict) and v["passed"] == 27)
+        for name, bad in [
+            ("3b 绝对路径拦截",
+             {**v, "details": [{"log": r"D:\program\secret\path.txt"}]}),
+            ("3c prompt 字段拦截",
+             {**v, "prompt": "你是一个…"}),
+            ("3d API key 拦截",
+             {**v, "details": [{"env": "sk-dummy0abcdefghijklmnop"}]}),
+            ("3e unix 家目录拦截",
+             {**v, "suite_origin": "/Users/test/worktree"}),
+        ]:
+            try:
+                sanity_check_verdict(bad)
+                check(name, False, "违规内容未被拦截")
+            except InteropSanityError:
+                check(name, True)
+
+        print("[4] 冻结文件落盘形态（入库可复核）")
+        fp = os.path.join(tmp, "interop", "frozen.json")
+        data = json.load(open(fp, encoding="utf-8"))
+        check("4a 冻结文件只含结构化事实（iter_id/frozen_at/digest/files"
+              "/missing_patterns）",
+              set(data.keys()) == {"iter_id", "frozen_at", "digest", "files",
+                                   "missing_patterns"},
+              str(sorted(data.keys())))
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+    print(f"\n=== interop tests: {PASS} passed, {FAIL} failed ===")
+    return 1 if FAIL else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_interop_judgment.py

@@ -0,0 +1,228 @@
+# -*- coding: utf-8 -*-
+"""test_interop_judgment —— 互验执行链判据强度守卫（issue #37 六项）
+
+J1  valid=单一放行位（断言 AND 套件）——套件全挂时必须 False
+J2  A2 标注 self-reported；伪造 subject_fp 不影响 A3（承重墙输入不含自报值）
+J3  failure_reason 枚举四象限结构化
+J4  interop_gate 机械消费方三态（pass 放行 / fail 拒绝 / 缺产物 fail-closed）
+J5  脱敏黑名单扩面（UNC/unix/~/$HOME/密钥形态/Bearer/文本形态）+ 形状白名单
+J6  freeze 显式 out_dir 警告（不被 runner 识别）
+
+运行：python -X utf8 -m md_cg.test_interop_judgment
+"""
+import importlib.util
+import json
+import os
+import subprocess
+import sys
+import tempfile
+
+HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, HERE)
+
+from md_cg.interop import (                        # noqa: E402
+    InteropSanityError, assert_a2, assert_a3, freeze,
+    make_verdict, sanity_check_verdict, shape_check_verdict)
+
+_spec = importlib.util.spec_from_file_location(
+    "verify_runner", os.path.join(HERE, "hive", "verify_runner.py"))
+vr = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(vr)
+
+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 _mk(a_ok, suite_ok):
+    return vr._compose_semantics(a_ok, suite_ok)
+
+
+def main():
+    print("[1] J1/J3：verdict 语义四象限")
+    v, valid, a_ok, fr = _mk(True, True)
+    check("全过 → pass/valid=True/reason=None",
+          v == "pass" and valid and a_ok and fr is None)
+    v, valid, a_ok, fr = _mk(True, False)
+    check("断言过+套件挂 → fail/valid=False/assertions_ok=True/reason=suite_failed"
+          "（#37 实测形态：套件全挂时 valid 必须不再是 true）",
+          v == "fail" and valid is False and a_ok is True
+          and fr == "suite_failed")
+    v, valid, a_ok, fr = _mk(False, True)
+    check("断言挂+套件过 → reason=assertions_failed",
+          v == "fail" and valid is False and a_ok is False
+          and fr == "assertions_failed")
+    v, valid, a_ok, fr = _mk(False, False)
+    check("双挂 → reason=both", v == "fail" and fr == "both")
+
+    print("[2] J2：A2 self-reported 分层 + A3 不受伪造 subject_fp 影响")
+    a2 = assert_a2("a" * 64, "deadbeef" * 8)
+    check("伪造 subject_fp 可过 A2（弱断言如实）", a2["ok"] is True)
+    check("A2 输出标注 subject_fp_source=self-reported（#27 分层复用）",
+          a2.get("subject_fp_source") == "self-reported")
+    frozen = {"digest": "f" * 64}
+    a3 = assert_a3(frozen, "e" * 64)
+    check("A3 输入不含 subject_fp（伪造自报值过不了 A3——承重墙）",
+          "subject" not in json.dumps(a3) and a3["ok"] is False)
+
+    print("[3] J5：脱敏黑名单扩面（issue 列举形态全部拦截）")
+    leaks = [
+        ("UNC 路径", "\\\\server\\share\\secret.txt"),
+        ("macOS /Volumes", "/Volumes/disk/proj/x.md"),
+        ("unix /etc", "配置在 /etc/passwd 附近"),
+        ("家目录 ~", "见 ~/secret/keys.txt"),
+        ("$HOME", "文件在 $HOME/.aws 下"),
+        # 假 token 字面量须自带占位符标记（fake/example 等）：形状正则
+        # （md_cg/interop.py 的 `ghp_[A-Za-z0-9]{20,}`）照旧命中 → 本用例的
+        # 拦截断言不变；同时 scripts/check_publish_artifact.py 的 R1 会把它
+        # 记为 NOTE 而非 FAIL（否则出货门禁对「测试夹具里的假值」恒红——
+        # 红着等于没门禁）。见 FAKE_TOKEN_MARKERS。
+        ("ghp_ token", "ghp_dummyABCDEFGHIJKLMNOPQRSTUVWXYZ1234"),
+        ("AIza key", "AIzaSyABCDEFGHIJKLMNOPQRSTUVWXYZ1234567"),
+        ("AKIA key", "AKIAIOSFODNN7EXAMPLE"),
+        ("Bearer", "Authorization: Bearer eyJhbGciOiJIUzI1NiJ9.payload.sig"),
+        ("文本形态 user_prompt", "note: user_prompt: tell me a secret"),
+    ]
+    base = {"iter_id": "t", "verifier_instance": "v", "verifier_fingerprint":
+            "a" * 64, "subject_instance": "m", "subject_fingerprint":
+            "b" * 64, "suite_origin": "w", "frozen_at": "x", "verdict":
+            "fail", "passed": 0, "failed": 0, "details": [], "valid": False,
+            "assertions_ok": False, "failure_reason": "both"}
+    for label, payload in leaks:
+        try:
+            v2 = dict(base, iter_id=payload[:40])
+            v2["details"] = [{"note": payload}]
+            sanity_check_verdict(v2)
+            check(f"拦截 {label}", False, payload)
+        except InteropSanityError:
+            check(f"拦截 {label}", True)
+    try:
+        sanity_check_verdict(dict(base))
+        check("正常 verdict 过脱敏门禁（无误伤）", True)
+    except InteropSanityError as e:
+        check("正常 verdict 过脱敏门禁（无误伤）", False, str(e))
+
+    print("[4] J5：形状白名单（越权字段/坏形状/坏枚举）")
+    for label, mut in [
+            ("越权顶层字段", {"extra_key": "x"}),
+            ("指纹非十六进制", {"verifier_fingerprint": "zzz!*"}),
+            ("verdict 枚举外", {"verdict": "PASS"}),
+            ("failure_reason 枚举外", {"failure_reason": "whatever"}),
+            ("计数非整数", {"passed": "3"}),
+            ("计数负数", {"failed": -1})]:
+        try:
+            shape_check_verdict(dict(base, **mut))
+            check(f"形状拦截 {label}", False)
+        except InteropSanityError:
+            check(f"形状拦截 {label}", True)
+    try:
+        shape_check_verdict(dict(base, verdict="fail", failure_reason=None,
+                                 passed=1, failed=2))
+        check("合法形状通过白名单", True)
+    except InteropSanityError as e:
+        check("合法形状通过白名单", False, str(e))
+
+    print("[5] J6：freeze 显式 out_dir 警告")
+    import contextlib
+    with tempfile.TemporaryDirectory() as td:
+        buf = io_err = None
+        try:
+            import io as _io
+            buf = _io.StringIO()
+            with contextlib.redirect_stderr(buf):
+                freeze("zz-guard-j6", out_dir=td)
+        finally:
+            pass
+        check("显式 out_dir → stderr 警告（不被 runner 识别）",
+              buf is not None and "不被" in (buf.getvalue() or ""))
+        std = os.path.join(HERE, "hive", "interop", "zz-guard-j6")
+        import shutil
+        shutil.rmtree(std, ignore_errors=True)
+
+    print("[6] J4：interop_gate 机械消费方三态")
+    gate = os.path.join(HERE, "scripts", "interop_gate.py")
+    with tempfile.TemporaryDirectory() as td:
+        vp = os.path.join(td, "verdict.json")
+        ok_v = dict(base, verdict="pass", valid=True, assertions_ok=True,
+                    failure_reason=None, passed=9, failed=0)
+        json.dump(ok_v, open(vp, "w", encoding="utf-8"), ensure_ascii=False)
+        r = subprocess.run([sys.executable, gate, "--path", vp],
+                           capture_output=True, text=True, encoding="utf-8")
+        check("pass+valid → exit 0（放行）", r.returncode == 0, r.stdout)
+        json.dump(dict(base), open(vp, "w", encoding="utf-8"),
+                  ensure_ascii=False)
+        r = subprocess.run([sys.executable, gate, "--path", vp],
+                           capture_output=True, text=True, encoding="utf-8")
+        check("fail/valid=False → exit 1（拒绝合并）", r.returncode == 1)
+        os.remove(vp)
+        r = subprocess.run([sys.executable, gate, "--path", vp],
+                           capture_output=True, text=True, encoding="utf-8")
+        check("无 verdict → exit 2（未互验 fail-closed）", r.returncode == 2)
+        json.dump({"verdict": "pass"}, open(vp, "w", encoding="utf-8"))
+        r = subprocess.run([sys.executable, gate, "--path", vp],
+                           capture_output=True, text=True, encoding="utf-8")
+        check("旧版产物缺契约字段 → exit 3（拒绝猜测）", r.returncode == 3)
+
+    print("[7] make_verdict 全链（新字段经双门禁落盘）")
+    v3 = make_verdict(iter_id="t", verifier_instance="v",
+                      verifier_fingerprint="a" * 64, subject_instance="m",
+                      subject_fingerprint="b" * 64,
+                      suite_origin="w", frozen_at="x", verdict="fail",
+                      passed=0, failed=1,
+                      details=[assert_a2("a" * 64, "b" * 64)])
+    v3.update({"valid": False, "assertions_ok": False,
+               "failure_reason": "both"})
+    try:
+        sanity_check_verdict(v3)
+        shape_check_verdict(v3)
+        check("含 self-reported 标注的完整产物过双门禁", True)
+    except InteropSanityError as e:
+        check("含 self-reported 标注的完整产物过双门禁", False, str(e))
+
+    print("[8] _parse_counts 与 run_tests SUMMARY 实际形态契约（v6 N28）")
+    # 契约断裂实形：run_tests.py:216 打印 `===== SUMMARY N/M 通过，Z 跳过…`，
+    # 而 _parse_counts 旧第三正则只认 `通过 X / 失败 Y`（run_tests 从未打印）
+    # → python 侧计数恒 (0,0)，verdict.json passed/failed 系统性失真
+    # （判决靠 exit code 仍对，留痕假零）。
+    p188, f188 = vr._parse_counts(
+        "===== SUMMARY 188/189 通过，1 跳过（依赖缺失/平台不符） =====")
+    check("实跑 SUMMARY 形态可解析（188/189 → passed=188，非 0）",
+          p188 == 188, p188)
+    check("failed 由 runnable-passed 推出（→ 1，非 0）", f188 == 1, f188)
+    # 生产者现场取证：真跑 run_tests（scripts 组 -k 过滤到单测），SUMMARY
+    # 行必须能被消费端解析——两侧契约同一守卫钉死，任一侧漂移必红。
+    r = subprocess.run(
+        [sys.executable, "-X", "utf8",
+         os.path.join(HERE, "scripts", "run_tests.py"), "scripts",
+         "-k", "judgment"],
+        capture_output=True, text=True, encoding="utf-8", errors="replace",
+        cwd=HERE, timeout=600)
+    summ = [ln for ln in (r.stdout or "").splitlines() if "SUMMARY" in ln]
+    check("run_tests 实跑产出 SUMMARY 行（生产者在场）", bool(summ),
+          (r.stdout or "")[-200:])
+    if summ:
+        pp, ff = vr._parse_counts(r.stdout)
+        check("消费端能解析生产端实跑输出（非 (0,0) 假读）",
+              (pp, ff) != (0, 0), (pp, ff, summ[-1]))
+    # cargo 形态不回归；跳过单列不计失败（裸 clone SKIP 面不虚增 failed）
+    pc, fc = vr._parse_counts("test result: ok. 3 passed; 1 failed; 0 ignored")
+    check("cargo 形态照旧（3 passed; 1 failed → (3,1)）", (pc, fc) == (3, 1),
+          (pc, fc))
+    ps, fs = vr._parse_counts("===== SUMMARY 187/187 通过，2 跳过（依赖缺失） =====")
+    check("跳过不计入 failed（187/187+2 跳过 → (187,0)）", (ps, fs) == (187, 0),
+          (ps, fs))
+
+    print(f"\ninterop_judgment: {passed} 通过 / {failed} 失败")
+    return 0 if not failed else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/md_cg/test_issue39_utf8_stdio.py

@@ -0,0 +1,273 @@
+# -*- coding: utf-8 -*-
+"""test_issue39_utf8_stdio.py · Windows 控制台代码页下 stdio MCP 中文必炸的守卫（issue #39）
+
+现场（外部用户实测，issue #39）：Windows 控制台代码页（GBK/CP936）下，md_cg 的
+stdio MCP server 写中文必失败——宿主按 UTF-8 发来的中文参数被按 GBK 解码：
+· ``gbk:strict`` → 读侧直接 ``UnicodeDecodeError``（本守卫实弹注入的形态，已实证
+  「中文标题：编码守卫」的 UTF-8 字节序列按 GBK 严格解码必非法）；
+· ``surrogateescape`` → 解出代理对 ``\\udcXX``，``_j()``（ensure_ascii=False）
+  按 UTF-8 编码时抛 ``UnicodeEncodeError: surrogates not allowed``。
+两种形态整条请求同亡；写英文正常，用户难自查。桥层 0.4.10 已在
+``src/lib/mdcg_client.ts`` 的 ``mdcgChildEnv()`` 注入 ``PYTHONUTF8=1``，但只覆盖
+DSH 桥路径——Claude Code / code CLI 直接 mcp.json 接入不经桥，仍踩。
+
+修复（本守卫的红绿两态锚点）：``md_cg/mcp_server.py`` 与
+``hive/hive_mcp/mcp_server.py``（同族全修）各加模块级 ``_force_utf8_stdio()``，
+并在 ``main()`` **首行**调用——进程内把 stdio 三流 reconfigure 成
+``utf-8``/``errors="replace"``，是对桥层 PYTHONUTF8=1 的纵深补位；``replace``
+保证坏字节最多丢字符、不炸整条请求。
+
+实弹形态：subprocess spawn ``[sys.executable, "-m", "md_cg.mcp_server"]``
+（cwd=仓根，**不带** ``-X utf8``），env 显式设 ``PYTHONIOENCODING=gbk:strict``
+模拟 CP936 控制台；按行分隔 JSON-RPC（initialize → notifications/initialized →
+tools/call cg {op:"write", content:中文}）。断言：响应行是合法 JSON、write 响应
+不含 ``UnicodeEncodeError`` 且返回 ``ok``/``moved_to`` 字段。hive 面同款实弹
+（中文 hive_spawn；HIVE_EXE 指向不存在的探针路径——``_ensure_serve`` 在 isfile
+即返回，绝不拉起真 serve）。修复前此面红（进程在读侧崩、响应行缺失），修复后绿。
+
+隔离纪律：MDCG_ROOT/MDCG_STATE_ROOT/MDCG_DATA_ROOT/MDCG_AUX_ROOT/
+MDCG_TENANT_REGISTRY/HIVE_JOBS_DIR/HIVE_CONFIG 全部指向 tempfile.mkdtemp 临时
+目录（登记表指向不存在的临时路径=空表回落），身份走既有豁免面
+``MDCG_LEGACY_ENV_AUTH=1``（env 直连 designer，零令牌、不回落真实 ~/.mdcg），
+MDCG_SUSTAIN=0 关常驻循环；finally rmtree——绝不触真实令牌库与真实数据目录。
+
+自检 floor：实弹断言低于 LIVE_FLOOR 视为失败——防止「spawn 面失效 → 假绿」。
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+
+try:
+    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+except AttributeError:
+    pass
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+LIVE_FLOOR = 2          # 实弹断言下限（md_cg 面 ≥1 + hive 面 ≥1）
+PROBE = "中文标题：编码守卫"   # UTF-8 字节按 GBK strict 解码必非法（红态机制，见头注）
+
+PASS, FAIL, LIVE = 0, 0, 0
+
+
+def check(name, cond, detail="", live=False):
+    global PASS, FAIL, LIVE
+    if live:
+        LIVE += 1
+    if cond:
+        PASS += 1
+        print(f"  [ok] {name}")
+    else:
+        FAIL += 1
+        print(f"  [FAIL] {name}  {detail}")
+
+
+# 模拟 CP936 控制台前，先把父进程可能携带的「身份/路径/编码」注入面清干净——
+# 守卫子进程只吃临时目录，绝不吃本机真实 ~/.mdcg / 真实 MDCG_ROOT。
+_DIRTY_KEYS = (
+    "MDCG_TOKEN", "MDCG_CLEARANCE", "MDCG_TENANT", "MDCG_TENANT_REGISTRY",
+    "MDCG_CAN_ADMIN", "MDCG_CAN_WRITE", "MDCG_LEGACY_ENV_AUTH",
+    "MDCG_LEGACY_ENV_ADMIN", "MDCG_SESSION", "DSH_SESSION_ID",
+    "MDCG_HARNESS", "MDCG_UNIT", "MDCG_ROOT", "MDCG_STATE_ROOT",
+    "MDCG_DATA_ROOT", "MDCG_AUX_ROOT", "MDCG_SUSTAIN", "MDCG_SUSTAIN_NAME",
+    "MDCG_MCP_SURFACE", "MDCG_TOOL_FACE", "MDCG_ACTOR",
+    "MDCG_VERIFIER_MODULES", "MDCG_HIVE_JOBS",
+    "PYTHONUTF8", "PYTHONIOENCODING", "PYTHONLEGACYWINDOWSSTDIO",
+    "HIVE_JOBS_DIR", "HIVE_CONFIG", "HIVE_EXE", "HIVE_API_KEY",
+)
+
+
+def _base_env(tmp: str) -> dict:
+    env = {k: v for k, v in os.environ.items() if k not in _DIRTY_KEYS}
+    env["PYTHONIOENCODING"] = "gbk:strict"     # 模拟 CP936 控制台（无 -X utf8）
+    env["MDCG_SUSTAIN"] = "0"                  # 关常驻循环（线程面归零）
+    env["MDCG_ACTOR"] = "issue39-guard"
+    # 身份走既有豁免面：env 直连 designer（二次开关齐全），零令牌、不回落真实凭据面
+    env["MDCG_LEGACY_ENV_AUTH"] = "1"
+    env["MDCG_CAN_ADMIN"] = "1"
+    env["MDCG_LEGACY_ENV_ADMIN"] = "1"
+    _ = tmp
+    return env
+
+
+def _mdcg_env(tmp: str) -> dict:
+    env = _base_env(tmp)
+    env["MDCG_ROOT"] = os.path.join(tmp, "cgroot")
+    env["MDCG_TENANT_REGISTRY"] = os.path.join(tmp, "_tenants_absent.json")
+    env["MDCG_STATE_ROOT"] = os.path.join(tmp, "state")
+    env["MDCG_DATA_ROOT"] = os.path.join(tmp, "data")
+    # 子目录名不可取 "aux"：AUX 是 Windows 保留设备名，ntpath.abspath 经
+    # GetFullPathNameW 会把末段 aux 解析成设备路径 \\.\aux（实测），导致
+    # aux_root() 覆盖键静默失联——取名 auxroot 避开。
+    env["MDCG_AUX_ROOT"] = os.path.join(tmp, "auxroot")
+    return env
+
+
+def _hive_env(tmp: str) -> dict:
+    env = _base_env(tmp)
+    env["HIVE_JOBS_DIR"] = os.path.join(tmp, "hivejobs")
+    # 指向不存在的配置与可执行文件：_ensure_serve 在 isfile 即返回，绝不拉起真 serve
+    env["HIVE_CONFIG"] = os.path.join(tmp, "hive_config_absent.json")
+    env["HIVE_EXE"] = os.path.join(tmp, "no_such_hive.exe")
+    return env
+
+
+def _rpc(rid, method, params=None):
+    msg = {"jsonrpc": "2.0", "id": rid, "method": method}
+    if params is not None:
+        msg["params"] = params
+    return json.dumps(msg, ensure_ascii=False)
+
+
+def _talk(cmd_args, env, lines, timeout=180):
+    """spawn server → 写 JSON-RPC 行 → 收 (returncode, stdout_text, stderr_text)。"""
+    proc = subprocess.Popen(
+        cmd_args, cwd=ROOT, env=env,
+        stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+        text=True, encoding="utf-8", errors="replace")
+    try:
+        out, err = proc.communicate("\n".join(lines) + "\n", timeout=timeout)
+    except subprocess.TimeoutExpired:
+        proc.kill()
+        out, err = proc.communicate()
+    return proc.returncode, out or "", err or ""
+
+
+def _resp_lines(out: str):
+    """stdout 逐行解析成 (raw_line, obj_or_None)。"""
+    got = []
+    for ln in out.splitlines():
+        ln = ln.strip()
+        if not ln:
+            continue
+        try:
+            got.append((ln, json.loads(ln)))
+        except ValueError:
+            got.append((ln, None))
+    return got
+
+
+def _find_resp(resps, rid):
+    for _raw, obj in resps:
+        if isinstance(obj, dict) and obj.get("id") == rid:
+            return obj
+    return None
+
+
+def _main_body_has_call(src: str) -> bool:
+    """源断言：main() 函数体首段含 _force_utf8_stdio() 调用（定义与调用都在）。"""
+    if "def _force_utf8_stdio()" not in src:
+        return False
+    idx = src.find("def main")
+    if idx < 0:
+        return False
+    window = src[idx:idx + 400]
+    return "_force_utf8_stdio()" in window
+
+
+def main():
+    tmp = tempfile.mkdtemp(prefix="mdcg_issue39_")
+    try:
+        # ---- 1. md_cg 面实弹：GBK 代码页下写中文 ----
+        print("[1] md_cg stdio 实弹（PYTHONIOENCODING=gbk:strict，无 -X utf8）")
+        rc, out, err = _talk(
+            [sys.executable, "-m", "md_cg.mcp_server"], _mdcg_env(tmp), [
+                _rpc(1, "initialize", {}),
+                _rpc(None, "notifications/initialized"),
+                _rpc(3, "tools/call", {"name": "cg", "arguments": {
+                    "op": "write", "content": PROBE}}),
+            ])
+        resps = _resp_lines(out)
+        init = _find_resp(resps, 1)
+        check("1a initialize 握手在 GBK 控制台下存活（合法 JSON 响应）",
+              isinstance(init, dict)
+              and (init.get("result") or {}).get("serverInfo", {}).get(
+                  "name") == "mdcg-mcp",
+              f"rc={rc} lines={len(resps)} err_tail={err[-200:]!r}", live=True)
+        wr = _find_resp(resps, 3)
+        wr_ok = False
+        if isinstance(wr, dict):
+            try:
+                payload = json.loads(
+                    (wr.get("result") or {}).get("content", [{}])[0].get(
+                        "text", "{}"))
+                wr_ok = ("ok" in payload) or ("moved_to" in payload)
+            except (ValueError, AttributeError, IndexError):
+                wr_ok = False
+        check("1b 中文 write 响应合法且返回 ok/moved_to 字段（红态：进程在读侧崩，本条缺失）",
+              wr_ok, f"wr={str(wr)[:200]}", live=True)
+        check("1c 全程无 UnicodeEncodeError（stdout/stderr 不见代理对编码炸点）",
+              "UnicodeEncodeError" not in out and "UnicodeEncodeError" not in err,
+              f"out_tail={out[-160:]!r} err_tail={err[-160:]!r}", live=True)
+        check("1d 进程正常下线（EOF 后 returncode=0，非中途崩死）",
+              rc == 0, f"rc={rc} err_tail={err[-200:]!r}", live=True)
+
+        # ---- 2. hive 面实弹：同族 server 同款代码页 ----
+        print("[2] hive stdio 实弹（同款 PYTHONIOENCODING=gbk:strict）")
+        rc2, out2, err2 = _talk(
+            [sys.executable, "-m", "hive.hive_mcp.mcp_server"],
+            _hive_env(tmp), [
+                _rpc(1, "initialize", {}),
+                _rpc(None, "notifications/initialized"),
+                _rpc(3, "tools/call", {"name": "hive_spawn", "arguments": {
+                    "model": "probe-model", "user_prompt": PROBE}}),
+            ])
+        resps2 = _resp_lines(out2)
+        init2 = _find_resp(resps2, 1)
+        check("2a initialize 握手存活（合法 JSON 响应，serverInfo=hive-mcp）",
+              isinstance(init2, dict)
+              and (init2.get("result") or {}).get("serverInfo", {}).get(
+                  "name") == "hive-mcp",
+              f"rc={rc2} lines={len(resps2)} err_tail={err2[-200:]!r}", live=True)
+        sp = _find_resp(resps2, 3)
+        sp_ok = False
+        if isinstance(sp, dict):
+            try:
+                payload = json.loads(
+                    (sp.get("result") or {}).get("content", [{}])[0].get(
+                        "text", "{}"))
+                sp_ok = payload.get("ok") is True and bool(payload.get("job_id"))
+            except (ValueError, AttributeError, IndexError):
+                sp_ok = False
+        check("2b 中文 hive_spawn 返回 ok=true+job_id（探针 exe 不存在，绝不拉真 serve）",
+              sp_ok, f"resp={str(sp)[:200]}", live=True)
+        check("2c hive 面无 UnicodeEncodeError",
+              "UnicodeEncodeError" not in out2
+              and "UnicodeEncodeError" not in err2,
+              f"err_tail={err2[-160:]!r}", live=True)
+        # 探针诚实边界：任务必须落在守卫自己的临时池，真实 jobs 池零触碰
+        jobs_dir = os.path.join(tmp, "hivejobs")
+        probe_jobs = [n for n in (os.listdir(jobs_dir) if os.path.isdir(jobs_dir)
+                                  else []) if n.startswith("h")]
+        check("2d 任务落在临时 jobs 池（隔离面自证）",
+              len(probe_jobs) == 1 if sp_ok else len(probe_jobs) == 0,
+              f"probe_jobs={probe_jobs}")
+
+        # ---- 3. 源断言：两 server 的 main() 首段强制 UTF-8 ----
+        print("[3] 源断言（main() 首段 _force_utf8_stdio()）")
+        for rel in ("md_cg/mcp_server.py", "hive/hive_mcp/mcp_server.py"):
+            with open(os.path.join(ROOT, rel), encoding="utf-8",
+                      errors="replace") as fh:
+                src = fh.read()
+            check(f"3·{rel}: 定义存在且 main() 首段调用 _force_utf8_stdio()",
+                  _main_body_has_call(src),
+                  "缺定义或 main() 首段未调用（必须早于一切 stderr 中文写与 stdin 读取）")
+
+        # ---- 4. 守卫自检 floor：实弹断言不足即假绿 ----
+        print("[4] 守卫自检")
+        check(f"4a 实弹断言数 ≥ {LIVE_FLOOR}（防 spawn/扫描面失效假绿）",
+              LIVE >= LIVE_FLOOR, f"LIVE={LIVE}")
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+    print(f"\n=== issue39 utf8 stdio tests: {PASS} passed, {FAIL} failed "
+          f"(live={LIVE}) ===")
+    sys.exit(1 if FAIL else 0)
+
+
+if __name__ == "__main__":
+    sys.exit(main())