@furongjun1999/dsh-memory 0.4.11 → 0.5.1

package/md_cg/whitebox_kb/wisdom/test_compiler_self_bootstrap.py

@@ -1,354 +1,354 @@
-# -*- coding: utf-8 -*-
-"""test_compiler_self_bootstrap.py · 白箱自举写编译器 + 外部校准（第六阶段 C2 白箱化）
-流程：编译器代码条件单元库 → 白箱生成（模板填充）→ 三层自校验
-  L1 语法（ast.parse）→ L2 样例（args→期望断言运行）→ L3 边界（空/极端）
-→ 外部校准：语义对照（智能论语义基准）+ 集成（生成代码组装 VM 执行）
-"""
-import sys, os, ast
-sys.stdout.reconfigure(encoding='utf-8')
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from compiler_code_units import COMPILER_UNITS, route_compiler_unit
-
-pass_n = fail_n = 0
-def check(name, ok, detail=''):
-    """断言登记：通过/失败计数并打印 ✓✘ 结果行。"""
-    global pass_n, fail_n
-    if ok: pass_n += 1
-    else: fail_n += 1
-    print(f'[{"✓" if ok else "✘"}] {name}{" — " + detail if detail else ""}')
-
-# ============ 白箱生成 + 三层自校验 ============
-generated = {}
-for uid, u in COMPILER_UNITS.items():
-    code_text = u["pattern"]
-    # L1 语法自校验（物理基底：ast.parse）
-    try:
-        tree = ast.parse(code_text)
-        l1_ok = True
-    except SyntaxError as e:
-        l1_ok = False
-    check(f'L1 语法[{uid}]', l1_ok, str(e) if not l1_ok else '')
-    if not l1_ok:
-        continue
-    # L2 样例自校验（运行生成函数断言）
-    ns = {}
-    exec(compile(tree, "<unit>", "exec"), ns)
-    fn_names = [n.name for n in ast.walk(tree) if isinstance(n, ast.FunctionDef)]
-    fn = ns[fn_names[0]] if fn_names else None
-    l2_ok, detail = True, ""
-    if fn:
-        for args, expect in u["cases"]:
-            try:
-                if uid == "编译-类型检查":
-                    # 组装：注入「分析-类型推断」白箱生成的 infer_types（类型检查编译）
-                    infer_fn = generated["分析-类型推断"][1]
-                    got = fn(*args, infer_fn)
-                else:
-                    got = fn(*args) if isinstance(args, tuple) else fn(args)
-                if isinstance(expect, dict) and isinstance(got, dict):
-                    # dict 期望：子集匹配（VM 执行循环返回状态 dict）
-                    if not all(got.get(k) == v for k, v in expect.items()):
-                        l2_ok, detail = False, f"{args} → {got} ⊉ {expect}"
-                        break
-                elif got != expect:
-                    l2_ok, detail = False, f"{args} → {got!r} ≠ {expect!r}"
-                    break
-            except Exception as e:
-                l2_ok, detail = False, f"{args} → 异常 {e}"
-                break
-    check(f'L2 样例[{uid}]', l2_ok, detail)
-    if l2_ok:
-        generated[uid] = (code_text, fn)
-
-# ============ 外部校准 ============
-# 校准①：语义对照——生成代码与智能论语义基准一致
-cal_ok = all(u["calibration"] for u in COMPILER_UNITS.values())
-check('校准① 语义基准声明齐全', cal_ok, f'{len(COMPILER_UNITS)} 单元')
-
-# 校准②：集成——白箱生成的单元组装成迷你 VM 跑「若则+德」
-if "VM-条件跳转" in generated and "VM-信任累积" in generated:
-    jf, _ = generated["VM-条件跳转"]
-    at, _ = generated["VM-信任累积"]
-    # 组装：栈=[False(条件为假)] → 跳转跳过德 → 信任不变
-    ns = {}
-    exec(compile(ast.parse(jf), "<jf>", "exec"), ns)
-    exec(compile(ast.parse(at), "<at>", "exec"), ns)
-    trust = ns["accumulate_trust"](0.0, 0.5)
-    new_ip = ns["exec_jump_if_false"]([False], 3, 9)
-    check('校准② 集成(信任累积)', trust == 0.5, f'trust={trust}')
-    check('校准②b 集成(条件假跳转)', new_ip == 9, f'ip={new_ip}')
-
-# 校准③：任务识别
-check('校准③ 任务识别', route_compiler_unit("实现条件跳转") == "VM-条件跳转"
-      and route_compiler_unit("信任累积怎么写") == "VM-信任累积", '')
-
-# 校准④：端到端组装管线——白箱生成单元组装「中文程序 → 编译 → VM 执行」
-def _fn(uid):
-    """域桥接取函数：从 code_compose 命名空间安全取出目标函数。"""
-    t = ast.parse(COMPILER_UNITS[uid]["pattern"])
-    ns = {}
-    exec(compile(t, "<u>", "exec"), ns)
-    return ns[[n.name for n in ast.walk(t) if isinstance(n, ast.FunctionDef)][0]]
-
-vm_run = _fn("VM-执行循环")
-compile_instr = _fn("编译-指令")
-instr_token = _fn("词法-道德经")
-check('校准④a 词法→编译→执行(道/德/止)',
-      instr_token("道") == "DAO" and compile_instr("DAO", "路径甲") == ("DAO", "路径甲"), '')
-prog = [("DAO", "新信任路径"), ("DE", "0.3"), ("DE", "0.5"), ("ZHI", None)]
-instrs = [compile_instr(k, v) for k, v in prog if compile_instr(k, v)]
-state = vm_run(instrs)
-check('校准④b 端到端(信任累积+条件空间+止)',
-      state["trust"] == 0.8 and state["cond"] == [{"name": "新信任路径"}]
-      and state["halt"] == "halt",
-      f'trust={state["trust"]} cond={state["cond"]} halt={state["halt"]}')
-# 若则端到端：条件为假跳过 then
-compile_condition = _fn("编译-若则")
-cond_code = compile_condition([("PUSH", False)], [("DE", 0.5)], [("DE", 0.1)])
-state2 = vm_run(cond_code)
-check('校准④c 端到端(若则假跳→else)',
-      state2["trust"] == 0.1 and state2["halt"] is None,
-      f'trust={state2["trust"]}（假→跳过 then 的 0.5 执行 else 的 0.1）')
-
-# 校准⑤：完整中文源码端到端（词法→编译→VM 执行）
-lex_line = _fn("词法-中文程序")
-compile_program = _fn("编译-程序")
-instr_token = _fn("词法-道德经")
-source = """问曰：如何验证信任？
-答曰：信任值大于0.7。
-术曰：
-1。道 新信任路径；
-2。若 信任值 大于 0.3，则 德 0.5；
-3。德 0.3；
-4。止。
-"""
-stmts = []
-for line in source.splitlines():
-    r = lex_line(line)
-    if r is None:
-        continue
-    kind, payload = r
-    if kind in ("问曰_STRUCT", "答曰_STRUCT", "术曰_STRUCT"):
-        stmts.append((kind, payload))
-    elif kind == "STEP":
-        words = payload[1].split()
-        en = instr_token(words[0])
-        if en:
-            stmts.append(("INSTR", en, words[1] if len(words) > 1 else None))
-    elif kind == "COND":
-        cond_txt, then_txt, else_txt = payload
-        then_parts = then_txt.split()
-        en = instr_token(then_parts[0])
-        stmts.append(("COND", cond_txt,
-                      [(en if en else then_parts[0],
-                        then_parts[1] if len(then_parts) > 1 else None)], []))
-    elif kind == "INSTR":
-        en = instr_token(payload[0])
-        if en:
-            stmts.append(("INSTR", en, payload[1]))
-check('校准⑤a 中文源码词法', any(s[0] == "术曰_STRUCT" for s in stmts)
-      and any(s[0] == "INSTR" and s[1] == "DAO" for s in stmts)
-      and any(s[0] == "INSTR" and s[1] == "DE" for s in stmts),
-      f'{len(stmts)} 条语句')
-code5 = compile_program(stmts, compile_instr, compile_condition)
-state5 = vm_run(code5)
-check('校准⑤b 端到端执行(信任≥0.8+条件空间+halt)',
-      state5["trust"] >= 0.8 and state5["cond"] == [{"name": "新信任路径"}]
-      and state5["halt"] == "halt",
-      f'trust={state5["trust"]} cond={state5["cond"]} halt={state5["halt"]}')
-
-# 校准⑥：编译期静态检查拦截（条件空间=类型系统/名实=静态检查）
-compile_pipeline = _fn("编译-管线静态检查")
-check_condition_spaces = _fn("校验-条件空间存在性")
-check('校准⑥a 条件空间存在性校验',
-      check_condition_spaces(["伴侣"], {"伴侣"}) == []
-      and check_condition_spaces(["未知"], {"伴侣"}) == ["未知"], '')
-# 类型错误源码：德 操作数非数值 → 编译期拦截
-_, r_bad = compile_pipeline([("INSTR", "DE", "高信任"), ("止", None)],
-                            {"信任值": "数值"}, {"伴侣"})
-check('校准⑥b 类型错误编译期拦截', r_bad["ok"] is False
-      and any("类型错误" in e for e in r_bad["errors"]), str(r_bad["errors"]))
-# 未声明条件空间 → 编译期拦截
-_, r_bad2 = compile_pipeline([("COND", "条件空间为未知 则 德 0.5", [("DE", "0.5")], [])],
-                             {"信任值": "数值"}, {"伴侣"})
-check('校准⑥c 未声明条件空间拦截', r_bad2["ok"] is False
-      and any("条件空间未声明" in e for e in r_bad2["errors"]), str(r_bad2["errors"]))
-# 正确源码 → 通过
-code_ok, r_ok = compile_pipeline([("INSTR", "DE", "0.5"), ("止", None)],
-                                 {"信任值": "数值"}, {"伴侣"})
-check('校准⑥d 正确源码通过', r_ok["ok"] and code_ok == [("COMPILED", 2)], str(r_ok))
-
-# 校准⑦：单入口完整编译（白箱版 pc compile：词法→静态检查→编译）
-compile_full = _fn("编译-完整管线")
-src_ok = "道 新信任路径\n德 0.3\n止。\n"
-code7, r7 = compile_full(src_ok, {"伴侣"})
-check('校准⑦a 单入口编译(道/德/止)',
-      r7["ok"] and code7 == [("DAO", "新信任路径"), ("DE", 0.3), ("ZHI", None)],
-      str(code7))
-if r7["ok"]:
-    state7 = vm_run(code7)
-    check('校准⑦b 单入口执行(信任0.3+条件空间+halt)',
-          state7["trust"] == 0.3 and state7["cond"] == [{"name": "新信任路径"}]
-          and state7["halt"] == "halt",
-          f'trust={state7["trust"]} cond={state7["cond"]} halt={state7["halt"]}')
-# 未声明条件空间 → 单入口拦截
-_, r7_bad = compile_full("若 条件空间为未知 则 德 0.5\n止。\n", {"伴侣"})
-check('校准⑦c 单入口拦截未声明空间', r7_bad["ok"] is False
-      and any("条件空间未声明" in e for e in r7_bad["errors"]), str(r7_bad["errors"]))
-# 未知行 → 拦截
-_, r7_bad2 = compile_full("随便文本\n", set())
-check('校准⑦d 单入口拦截未知行', r7_bad2["ok"] is False
-      and any("无法识别" in e for e in r7_bad2["errors"]), str(r7_bad2["errors"]))
-# 声明空间后通过（若则）
-code7b, r7b = compile_full("若 条件空间为伴侣 则 德 0.5\n止。\n", {"伴侣"})
-check('校准⑦e 声明空间后通过', r7b["ok"] and len(code7b) >= 2,
-      f'{len(code7b)} 条指令')
-
-# 校准⑧：条件真值计算（若则真实判定）
-eval_condition = _fn("求值-条件表达式")
-check('校准⑧a 条件表达式求值',
-      eval_condition("信任值 大于 0.3", {"信任值": 0.5}) is True
-      and eval_condition("信任值 大于 0.3", {"信任值": 0.2}) is False
-      and eval_condition("未知量 大于 0.3", {"信任值": 0.5}) is None, '')
-# 单入口：信任值 0.5 → 真 → 执行 then
-src_t = "若 信任值 大于 0.3，则 德 0.5\n止。\n"
-code8, r8 = compile_full(src_t, {"伴侣"})
-check('校准⑧b 条件真值编译(LOAD+PUSH+CMP)',
-      r8["ok"] and any(op == "CMP_GT" for op, _ in code8), str(code8))
-if r8["ok"]:
-    state8 = vm_run(code8, symbols={"信任值": 0.5})
-    check('校准⑧c 真条件执行then(信任0.5)',
-          state8["trust"] == 0.5, f'trust={state8["trust"]}')
-    state8b = vm_run(code8, symbols={"信任值": 0.2})
-    check('校准⑧d 假条件跳过then(信任0)',
-          state8b["trust"] == 0.0, f'trust={state8b["trust"]}')
-
-# 校准⑨：赋值/变量（名实动态绑定）
-src9 = "甲 = 3\n若 甲 大于 2，则 德 0.5\n止。\n"
-code9, r9 = compile_full(src9, {"伴侣"})
-check('校准⑨a 赋值编译(STORE)', r9["ok"]
-      and any(op == "STORE" and arg == "甲" for op, arg in code9), str(code9))
-if r9["ok"]:
-    state9 = vm_run(code9)
-    check('校准⑨b 赋值+条件执行(符号甲=3, 3>2真→德0.5)',
-          state9["symbols"].get("甲") == 3 and state9["trust"] == 0.5
-          and state9["halt"] == "halt",
-          f'symbols={state9["symbols"]} trust={state9["trust"]} halt={state9["halt"]}')
-# 变量复制：乙 = 甲
-code9b, r9b = compile_full("甲 = 3\n乙 = 甲\n止。\n", set())
-if r9b["ok"]:
-    state9b = vm_run(code9b)
-    check('校准⑨c 变量复制(乙=甲)', state9b["symbols"].get("甲") == 3
-          and state9b["symbols"].get("乙") == 3,
-          f'symbols={state9b["symbols"]}')
-
-# 校准⑩：对接 protocol-compiler 真实 lexer/parser（同一源码 → 白箱编译 → VM 执行）
-import sys as _sys
-import os as _os
-_pc = os.environ.get('AEIS_PROTOCOL_COMPILER') or os.path.join(
-    _os.path.dirname(_os.path.dirname(_os.path.abspath(__file__))),
-    _os.pardir, 'protocol-compiler')
-if _os.path.isdir(_pc) and _pc not in _sys.path:
-    _sys.path.insert(0, _pc)
-bridge_token = _fn("对接-协议词法")
-try:
-    from core.lexer import tokenize, TokenType
-    from core.parser import parse_tokens, NodeType
-    src_pc = """问曰：如何验证信任？
-答曰：信任值大于0.7。
-术曰：
-1。道 新信任路径；
-2。德 0.3；
-3。止。"""
-    tokens_pc, lex_err = tokenize(src_pc)
-    ast_pc = parse_tokens(tokens_pc, [])
-    instrs_pc = []
-    for stmt in ast_pc.statements:
-        if getattr(stmt, "type", None) == NodeType.SHUYUE:
-            for step in stmt.steps:
-                s = step.statement
-                if getattr(s, "type", None) == NodeType.INSTRUCTION_STMT:
-                    kind = bridge_token(s.instruction.name)
-                    operand = None
-                    if s.operands:
-                        op0 = s.operands[0]
-                        operand = getattr(op0, "name", None) or getattr(
-                            op0, "literal_value", None)
-                    ci = compile_instr(kind, operand)
-                    if ci:
-                        instrs_pc.append(ci)
-    check('校准⑩a 真实解析→白箱编译', len(instrs_pc) >= 2
-          and ("DAO", "新信任路径") in instrs_pc
-          and ("DE", 0.3) in instrs_pc, str(instrs_pc))
-    if instrs_pc:
-        state_pc = vm_run(instrs_pc)
-        check('校准⑩b VM执行(真实AST→信任0.3+条件空间+halt)',
-              state_pc["trust"] == 0.3
-              and state_pc["cond"] == [{"name": "新信任路径"}]
-              and state_pc["halt"] == "halt",
-              f'trust={state_pc["trust"]} cond={state_pc["cond"]} halt={state_pc["halt"]}')
-except ImportError as e:
-    check('校准⑩ protocol-compiler 对接', False, f'导入失败: {e}')
-
-# 校准⑪：知足（信任达标跳转，道德经指令全覆盖验证）
-src_z1 = "德 0.3\n知足 0.7\n德 0.5\n止。\n"
-code_z1, r_z1 = compile_full(src_z1, set())
-check('校准⑪a 知足编译(达标目标末尾回填)', r_z1["ok"]
-      and any(op == "ZHIZU" and arg == (0.7, 4) for op, arg in code_z1), str(code_z1))
-if r_z1["ok"]:
-    state_z1 = vm_run(code_z1)
-    check('校准⑪b 知足不达标继续(信任0.8)',
-          state_z1["trust"] == 0.8, f'trust={state_z1["trust"]}')
-src_z2 = "德 0.8\n知足 0.7\n德 0.5\n止。\n"
-code_z2, r_z2 = compile_full(src_z2, set())
-if r_z2["ok"]:
-    state_z2 = vm_run(code_z2)
-    check('校准⑪c 知足达标跳结束(信任0.8,跳过德0.5)',
-          state_z2["trust"] == 0.8, f'trust={state_z2["trust"]}')
-
-# 校准⑫：C3 原生编译——字节码序列化/反序列化往返 + .pbc 执行
-serialize = _fn("字节码-序列化")
-deserialize = _fn("字节码-反序列化")
-src_pbc = "德 0.3\n若 信任值 大于 0.2，则 德 0.5\n止。\n"
-code_pbc, r_pbc = compile_full(src_pbc, {"伴侣"})
-check('校准⑫a 编译成功', r_pbc["ok"] and code_pbc, str(r_pbc.get("errors", []))[:30])
-if r_pbc["ok"]:
-    data = serialize(code_pbc)
-    check('校准⑫b 序列化字节串', isinstance(data, bytes) and len(data) > 0,
-          f'{len(data)} 字节')
-    code_rt = deserialize(data)
-    check('校准⑫c 反序列化往返一致', code_rt == code_pbc,
-          f'len={len(code_rt)}')
-    # .pbc 独立执行（不依赖编译流程，直接 VM 加载执行）
-    state_pbc = vm_run(code_rt, symbols={"信任值": 0.5})
-    state_direct = vm_run(code_pbc, symbols={"信任值": 0.5})
-    check('校准⑫d .pbc 执行结果一致(信任0.8)',
-          state_pbc["trust"] == state_direct["trust"] == 0.8,
-          f'trust={state_pbc["trust"]}')
-
-# 校准⑬：类型推断（目标3 分析器完整化——编译期类型流）
-infer_types = _fn("分析-类型推断")
-r_t = infer_types([("assign", "甲", 3), ("assign", "乙", "x"), ("assign", "丙", True)])
-check('校准⑬a 类型推断(数值/文本/布尔)',
-      r_t["types"] == {"甲": "数值", "乙": "文本", "丙": "布尔"}, str(r_t["types"]))
-r_t2 = infer_types([("assign", "甲", 3), ("assign", "甲", "x")])
-check('校准⑬b 类型冲突→混合', r_t2["types"]["甲"] == "混合", str(r_t2["types"]))
-r_t3 = infer_types([("COND", "条件空间为伴侣 则 德 0.5", [], [])])
-check('校准⑬c 条件空间声明登记', r_t3["spaces"] == {"伴侣": "已声明"}, str(r_t3["spaces"]))
-
-# 校准⑭：类型检查接入编译管线（未推断/混合类型编译期拦截）
-compile_typed = _fn("编译-类型检查")
-code_t, r_t4 = compile_typed([("assign", "甲", 3), ("COND", "甲 大于 2 则 德 0.5", [], [])],
-                             infer_types)
-check('校准⑭a 类型一致通过', r_t4["ok"] and code_t == [("TYPED_OK", 2)],
-      str(r_t4.get("errors", []))[:30])
-_, r_t5 = compile_typed([("COND", "未知量 大于 2 则 德 0.5", [], [])], infer_types)
-check('校准⑭b 未推断类型拦截', r_t5["ok"] is False
-      and any("未推断类型" in e for e in r_t5["errors"]), str(r_t5["errors"]))
-_, r_t6 = compile_typed([("assign", "甲", 3), ("assign", "甲", "x"),
-                         ("COND", "甲 大于 2 则 德 0.5", [], [])], infer_types)
-check('校准⑭c 混合类型拦截', r_t6["ok"] is False
-      and any("类型冲突" in e for e in r_t6["errors"]), str(r_t6["errors"]))
-
-print(f'\n=== 白箱自举写编译器（C2 白箱化）: {pass_n}/{pass_n + fail_n} 通过 ===')
-sys.exit(0 if fail_n == 0 else 1)
+# -*- coding: utf-8 -*-
+"""test_compiler_self_bootstrap.py · 白箱自举写编译器 + 外部校准（第六阶段 C2 白箱化）
+流程：编译器代码条件单元库 → 白箱生成（模板填充）→ 三层自校验
+  L1 语法（ast.parse）→ L2 样例（args→期望断言运行）→ L3 边界（空/极端）
+→ 外部校准：语义对照（智能论语义基准）+ 集成（生成代码组装 VM 执行）
+"""
+import sys, os, ast
+sys.stdout.reconfigure(encoding='utf-8')
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from compiler_code_units import COMPILER_UNITS, route_compiler_unit
+
+pass_n = fail_n = 0
+def check(name, ok, detail=''):
+    """断言登记：通过/失败计数并打印 ✓✘ 结果行。"""
+    global pass_n, fail_n
+    if ok: pass_n += 1
+    else: fail_n += 1
+    print(f'[{"✓" if ok else "✘"}] {name}{" — " + detail if detail else ""}')
+
+# ============ 白箱生成 + 三层自校验 ============
+generated = {}
+for uid, u in COMPILER_UNITS.items():
+    code_text = u["pattern"]
+    # L1 语法自校验（物理基底：ast.parse）
+    try:
+        tree = ast.parse(code_text)
+        l1_ok = True
+    except SyntaxError as e:
+        l1_ok = False
+    check(f'L1 语法[{uid}]', l1_ok, str(e) if not l1_ok else '')
+    if not l1_ok:
+        continue
+    # L2 样例自校验（运行生成函数断言）
+    ns = {}
+    exec(compile(tree, "<unit>", "exec"), ns)
+    fn_names = [n.name for n in ast.walk(tree) if isinstance(n, ast.FunctionDef)]
+    fn = ns[fn_names[0]] if fn_names else None
+    l2_ok, detail = True, ""
+    if fn:
+        for args, expect in u["cases"]:
+            try:
+                if uid == "编译-类型检查":
+                    # 组装：注入「分析-类型推断」白箱生成的 infer_types（类型检查编译）
+                    infer_fn = generated["分析-类型推断"][1]
+                    got = fn(*args, infer_fn)
+                else:
+                    got = fn(*args) if isinstance(args, tuple) else fn(args)
+                if isinstance(expect, dict) and isinstance(got, dict):
+                    # dict 期望：子集匹配（VM 执行循环返回状态 dict）
+                    if not all(got.get(k) == v for k, v in expect.items()):
+                        l2_ok, detail = False, f"{args} → {got} ⊉ {expect}"
+                        break
+                elif got != expect:
+                    l2_ok, detail = False, f"{args} → {got!r} ≠ {expect!r}"
+                    break
+            except Exception as e:
+                l2_ok, detail = False, f"{args} → 异常 {e}"
+                break
+    check(f'L2 样例[{uid}]', l2_ok, detail)
+    if l2_ok:
+        generated[uid] = (code_text, fn)
+
+# ============ 外部校准 ============
+# 校准①：语义对照——生成代码与智能论语义基准一致
+cal_ok = all(u["calibration"] for u in COMPILER_UNITS.values())
+check('校准① 语义基准声明齐全', cal_ok, f'{len(COMPILER_UNITS)} 单元')
+
+# 校准②：集成——白箱生成的单元组装成迷你 VM 跑「若则+德」
+if "VM-条件跳转" in generated and "VM-信任累积" in generated:
+    jf, _ = generated["VM-条件跳转"]
+    at, _ = generated["VM-信任累积"]
+    # 组装：栈=[False(条件为假)] → 跳转跳过德 → 信任不变
+    ns = {}
+    exec(compile(ast.parse(jf), "<jf>", "exec"), ns)
+    exec(compile(ast.parse(at), "<at>", "exec"), ns)
+    trust = ns["accumulate_trust"](0.0, 0.5)
+    new_ip = ns["exec_jump_if_false"]([False], 3, 9)
+    check('校准② 集成(信任累积)', trust == 0.5, f'trust={trust}')
+    check('校准②b 集成(条件假跳转)', new_ip == 9, f'ip={new_ip}')
+
+# 校准③：任务识别
+check('校准③ 任务识别', route_compiler_unit("实现条件跳转") == "VM-条件跳转"
+      and route_compiler_unit("信任累积怎么写") == "VM-信任累积", '')
+
+# 校准④：端到端组装管线——白箱生成单元组装「中文程序 → 编译 → VM 执行」
+def _fn(uid):
+    """域桥接取函数：从 code_compose 命名空间安全取出目标函数。"""
+    t = ast.parse(COMPILER_UNITS[uid]["pattern"])
+    ns = {}
+    exec(compile(t, "<u>", "exec"), ns)
+    return ns[[n.name for n in ast.walk(t) if isinstance(n, ast.FunctionDef)][0]]
+
+vm_run = _fn("VM-执行循环")
+compile_instr = _fn("编译-指令")
+instr_token = _fn("词法-道德经")
+check('校准④a 词法→编译→执行(道/德/止)',
+      instr_token("道") == "DAO" and compile_instr("DAO", "路径甲") == ("DAO", "路径甲"), '')
+prog = [("DAO", "新信任路径"), ("DE", "0.3"), ("DE", "0.5"), ("ZHI", None)]
+instrs = [compile_instr(k, v) for k, v in prog if compile_instr(k, v)]
+state = vm_run(instrs)
+check('校准④b 端到端(信任累积+条件空间+止)',
+      state["trust"] == 0.8 and state["cond"] == [{"name": "新信任路径"}]
+      and state["halt"] == "halt",
+      f'trust={state["trust"]} cond={state["cond"]} halt={state["halt"]}')
+# 若则端到端：条件为假跳过 then
+compile_condition = _fn("编译-若则")
+cond_code = compile_condition([("PUSH", False)], [("DE", 0.5)], [("DE", 0.1)])
+state2 = vm_run(cond_code)
+check('校准④c 端到端(若则假跳→else)',
+      state2["trust"] == 0.1 and state2["halt"] is None,
+      f'trust={state2["trust"]}（假→跳过 then 的 0.5 执行 else 的 0.1）')
+
+# 校准⑤：完整中文源码端到端（词法→编译→VM 执行）
+lex_line = _fn("词法-中文程序")
+compile_program = _fn("编译-程序")
+instr_token = _fn("词法-道德经")
+source = """问曰：如何验证信任？
+答曰：信任值大于0.7。
+术曰：
+1。道 新信任路径；
+2。若 信任值 大于 0.3，则 德 0.5；
+3。德 0.3；
+4。止。
+"""
+stmts = []
+for line in source.splitlines():
+    r = lex_line(line)
+    if r is None:
+        continue
+    kind, payload = r
+    if kind in ("问曰_STRUCT", "答曰_STRUCT", "术曰_STRUCT"):
+        stmts.append((kind, payload))
+    elif kind == "STEP":
+        words = payload[1].split()
+        en = instr_token(words[0])
+        if en:
+            stmts.append(("INSTR", en, words[1] if len(words) > 1 else None))
+    elif kind == "COND":
+        cond_txt, then_txt, else_txt = payload
+        then_parts = then_txt.split()
+        en = instr_token(then_parts[0])
+        stmts.append(("COND", cond_txt,
+                      [(en if en else then_parts[0],
+                        then_parts[1] if len(then_parts) > 1 else None)], []))
+    elif kind == "INSTR":
+        en = instr_token(payload[0])
+        if en:
+            stmts.append(("INSTR", en, payload[1]))
+check('校准⑤a 中文源码词法', any(s[0] == "术曰_STRUCT" for s in stmts)
+      and any(s[0] == "INSTR" and s[1] == "DAO" for s in stmts)
+      and any(s[0] == "INSTR" and s[1] == "DE" for s in stmts),
+      f'{len(stmts)} 条语句')
+code5 = compile_program(stmts, compile_instr, compile_condition)
+state5 = vm_run(code5)
+check('校准⑤b 端到端执行(信任≥0.8+条件空间+halt)',
+      state5["trust"] >= 0.8 and state5["cond"] == [{"name": "新信任路径"}]
+      and state5["halt"] == "halt",
+      f'trust={state5["trust"]} cond={state5["cond"]} halt={state5["halt"]}')
+
+# 校准⑥：编译期静态检查拦截（条件空间=类型系统/名实=静态检查）
+compile_pipeline = _fn("编译-管线静态检查")
+check_condition_spaces = _fn("校验-条件空间存在性")
+check('校准⑥a 条件空间存在性校验',
+      check_condition_spaces(["伴侣"], {"伴侣"}) == []
+      and check_condition_spaces(["未知"], {"伴侣"}) == ["未知"], '')
+# 类型错误源码：德 操作数非数值 → 编译期拦截
+_, r_bad = compile_pipeline([("INSTR", "DE", "高信任"), ("止", None)],
+                            {"信任值": "数值"}, {"伴侣"})
+check('校准⑥b 类型错误编译期拦截', r_bad["ok"] is False
+      and any("类型错误" in e for e in r_bad["errors"]), str(r_bad["errors"]))
+# 未声明条件空间 → 编译期拦截
+_, r_bad2 = compile_pipeline([("COND", "条件空间为未知 则 德 0.5", [("DE", "0.5")], [])],
+                             {"信任值": "数值"}, {"伴侣"})
+check('校准⑥c 未声明条件空间拦截', r_bad2["ok"] is False
+      and any("条件空间未声明" in e for e in r_bad2["errors"]), str(r_bad2["errors"]))
+# 正确源码 → 通过
+code_ok, r_ok = compile_pipeline([("INSTR", "DE", "0.5"), ("止", None)],
+                                 {"信任值": "数值"}, {"伴侣"})
+check('校准⑥d 正确源码通过', r_ok["ok"] and code_ok == [("COMPILED", 2)], str(r_ok))
+
+# 校准⑦：单入口完整编译（白箱版 pc compile：词法→静态检查→编译）
+compile_full = _fn("编译-完整管线")
+src_ok = "道 新信任路径\n德 0.3\n止。\n"
+code7, r7 = compile_full(src_ok, {"伴侣"})
+check('校准⑦a 单入口编译(道/德/止)',
+      r7["ok"] and code7 == [("DAO", "新信任路径"), ("DE", 0.3), ("ZHI", None)],
+      str(code7))
+if r7["ok"]:
+    state7 = vm_run(code7)
+    check('校准⑦b 单入口执行(信任0.3+条件空间+halt)',
+          state7["trust"] == 0.3 and state7["cond"] == [{"name": "新信任路径"}]
+          and state7["halt"] == "halt",
+          f'trust={state7["trust"]} cond={state7["cond"]} halt={state7["halt"]}')
+# 未声明条件空间 → 单入口拦截
+_, r7_bad = compile_full("若 条件空间为未知 则 德 0.5\n止。\n", {"伴侣"})
+check('校准⑦c 单入口拦截未声明空间', r7_bad["ok"] is False
+      and any("条件空间未声明" in e for e in r7_bad["errors"]), str(r7_bad["errors"]))
+# 未知行 → 拦截
+_, r7_bad2 = compile_full("随便文本\n", set())
+check('校准⑦d 单入口拦截未知行', r7_bad2["ok"] is False
+      and any("无法识别" in e for e in r7_bad2["errors"]), str(r7_bad2["errors"]))
+# 声明空间后通过（若则）
+code7b, r7b = compile_full("若 条件空间为伴侣 则 德 0.5\n止。\n", {"伴侣"})
+check('校准⑦e 声明空间后通过', r7b["ok"] and len(code7b) >= 2,
+      f'{len(code7b)} 条指令')
+
+# 校准⑧：条件真值计算（若则真实判定）
+eval_condition = _fn("求值-条件表达式")
+check('校准⑧a 条件表达式求值',
+      eval_condition("信任值 大于 0.3", {"信任值": 0.5}) is True
+      and eval_condition("信任值 大于 0.3", {"信任值": 0.2}) is False
+      and eval_condition("未知量 大于 0.3", {"信任值": 0.5}) is None, '')
+# 单入口：信任值 0.5 → 真 → 执行 then
+src_t = "若 信任值 大于 0.3，则 德 0.5\n止。\n"
+code8, r8 = compile_full(src_t, {"伴侣"})
+check('校准⑧b 条件真值编译(LOAD+PUSH+CMP)',
+      r8["ok"] and any(op == "CMP_GT" for op, _ in code8), str(code8))
+if r8["ok"]:
+    state8 = vm_run(code8, symbols={"信任值": 0.5})
+    check('校准⑧c 真条件执行then(信任0.5)',
+          state8["trust"] == 0.5, f'trust={state8["trust"]}')
+    state8b = vm_run(code8, symbols={"信任值": 0.2})
+    check('校准⑧d 假条件跳过then(信任0)',
+          state8b["trust"] == 0.0, f'trust={state8b["trust"]}')
+
+# 校准⑨：赋值/变量（名实动态绑定）
+src9 = "甲 = 3\n若 甲 大于 2，则 德 0.5\n止。\n"
+code9, r9 = compile_full(src9, {"伴侣"})
+check('校准⑨a 赋值编译(STORE)', r9["ok"]
+      and any(op == "STORE" and arg == "甲" for op, arg in code9), str(code9))
+if r9["ok"]:
+    state9 = vm_run(code9)
+    check('校准⑨b 赋值+条件执行(符号甲=3, 3>2真→德0.5)',
+          state9["symbols"].get("甲") == 3 and state9["trust"] == 0.5
+          and state9["halt"] == "halt",
+          f'symbols={state9["symbols"]} trust={state9["trust"]} halt={state9["halt"]}')
+# 变量复制：乙 = 甲
+code9b, r9b = compile_full("甲 = 3\n乙 = 甲\n止。\n", set())
+if r9b["ok"]:
+    state9b = vm_run(code9b)
+    check('校准⑨c 变量复制(乙=甲)', state9b["symbols"].get("甲") == 3
+          and state9b["symbols"].get("乙") == 3,
+          f'symbols={state9b["symbols"]}')
+
+# 校准⑩：对接 protocol-compiler 真实 lexer/parser（同一源码 → 白箱编译 → VM 执行）
+import sys as _sys
+import os as _os
+_pc = os.environ.get('AEIS_PROTOCOL_COMPILER') or os.path.join(
+    _os.path.dirname(_os.path.dirname(_os.path.abspath(__file__))),
+    _os.pardir, 'protocol-compiler')
+if _os.path.isdir(_pc) and _pc not in _sys.path:
+    _sys.path.insert(0, _pc)
+bridge_token = _fn("对接-协议词法")
+try:
+    from core.lexer import tokenize, TokenType
+    from core.parser import parse_tokens, NodeType
+    src_pc = """问曰：如何验证信任？
+答曰：信任值大于0.7。
+术曰：
+1。道 新信任路径；
+2。德 0.3；
+3。止。"""
+    tokens_pc, lex_err = tokenize(src_pc)
+    ast_pc = parse_tokens(tokens_pc, [])
+    instrs_pc = []
+    for stmt in ast_pc.statements:
+        if getattr(stmt, "type", None) == NodeType.SHUYUE:
+            for step in stmt.steps:
+                s = step.statement
+                if getattr(s, "type", None) == NodeType.INSTRUCTION_STMT:
+                    kind = bridge_token(s.instruction.name)
+                    operand = None
+                    if s.operands:
+                        op0 = s.operands[0]
+                        operand = getattr(op0, "name", None) or getattr(
+                            op0, "literal_value", None)
+                    ci = compile_instr(kind, operand)
+                    if ci:
+                        instrs_pc.append(ci)
+    check('校准⑩a 真实解析→白箱编译', len(instrs_pc) >= 2
+          and ("DAO", "新信任路径") in instrs_pc
+          and ("DE", 0.3) in instrs_pc, str(instrs_pc))
+    if instrs_pc:
+        state_pc = vm_run(instrs_pc)
+        check('校准⑩b VM执行(真实AST→信任0.3+条件空间+halt)',
+              state_pc["trust"] == 0.3
+              and state_pc["cond"] == [{"name": "新信任路径"}]
+              and state_pc["halt"] == "halt",
+              f'trust={state_pc["trust"]} cond={state_pc["cond"]} halt={state_pc["halt"]}')
+except ImportError as e:
+    check('校准⑩ protocol-compiler 对接', False, f'导入失败: {e}')
+
+# 校准⑪：知足（信任达标跳转，道德经指令全覆盖验证）
+src_z1 = "德 0.3\n知足 0.7\n德 0.5\n止。\n"
+code_z1, r_z1 = compile_full(src_z1, set())
+check('校准⑪a 知足编译(达标目标末尾回填)', r_z1["ok"]
+      and any(op == "ZHIZU" and arg == (0.7, 4) for op, arg in code_z1), str(code_z1))
+if r_z1["ok"]:
+    state_z1 = vm_run(code_z1)
+    check('校准⑪b 知足不达标继续(信任0.8)',
+          state_z1["trust"] == 0.8, f'trust={state_z1["trust"]}')
+src_z2 = "德 0.8\n知足 0.7\n德 0.5\n止。\n"
+code_z2, r_z2 = compile_full(src_z2, set())
+if r_z2["ok"]:
+    state_z2 = vm_run(code_z2)
+    check('校准⑪c 知足达标跳结束(信任0.8,跳过德0.5)',
+          state_z2["trust"] == 0.8, f'trust={state_z2["trust"]}')
+
+# 校准⑫：C3 原生编译——字节码序列化/反序列化往返 + .pbc 执行
+serialize = _fn("字节码-序列化")
+deserialize = _fn("字节码-反序列化")
+src_pbc = "德 0.3\n若 信任值 大于 0.2，则 德 0.5\n止。\n"
+code_pbc, r_pbc = compile_full(src_pbc, {"伴侣"})
+check('校准⑫a 编译成功', r_pbc["ok"] and code_pbc, str(r_pbc.get("errors", []))[:30])
+if r_pbc["ok"]:
+    data = serialize(code_pbc)
+    check('校准⑫b 序列化字节串', isinstance(data, bytes) and len(data) > 0,
+          f'{len(data)} 字节')
+    code_rt = deserialize(data)
+    check('校准⑫c 反序列化往返一致', code_rt == code_pbc,
+          f'len={len(code_rt)}')
+    # .pbc 独立执行（不依赖编译流程，直接 VM 加载执行）
+    state_pbc = vm_run(code_rt, symbols={"信任值": 0.5})
+    state_direct = vm_run(code_pbc, symbols={"信任值": 0.5})
+    check('校准⑫d .pbc 执行结果一致(信任0.8)',
+          state_pbc["trust"] == state_direct["trust"] == 0.8,
+          f'trust={state_pbc["trust"]}')
+
+# 校准⑬：类型推断（目标3 分析器完整化——编译期类型流）
+infer_types = _fn("分析-类型推断")
+r_t = infer_types([("assign", "甲", 3), ("assign", "乙", "x"), ("assign", "丙", True)])
+check('校准⑬a 类型推断(数值/文本/布尔)',
+      r_t["types"] == {"甲": "数值", "乙": "文本", "丙": "布尔"}, str(r_t["types"]))
+r_t2 = infer_types([("assign", "甲", 3), ("assign", "甲", "x")])
+check('校准⑬b 类型冲突→混合', r_t2["types"]["甲"] == "混合", str(r_t2["types"]))
+r_t3 = infer_types([("COND", "条件空间为伴侣 则 德 0.5", [], [])])
+check('校准⑬c 条件空间声明登记', r_t3["spaces"] == {"伴侣": "已声明"}, str(r_t3["spaces"]))
+
+# 校准⑭：类型检查接入编译管线（未推断/混合类型编译期拦截）
+compile_typed = _fn("编译-类型检查")
+code_t, r_t4 = compile_typed([("assign", "甲", 3), ("COND", "甲 大于 2 则 德 0.5", [], [])],
+                             infer_types)
+check('校准⑭a 类型一致通过', r_t4["ok"] and code_t == [("TYPED_OK", 2)],
+      str(r_t4.get("errors", []))[:30])
+_, r_t5 = compile_typed([("COND", "未知量 大于 2 则 德 0.5", [], [])], infer_types)
+check('校准⑭b 未推断类型拦截', r_t5["ok"] is False
+      and any("未推断类型" in e for e in r_t5["errors"]), str(r_t5["errors"]))
+_, r_t6 = compile_typed([("assign", "甲", 3), ("assign", "甲", "x"),
+                         ("COND", "甲 大于 2 则 德 0.5", [], [])], infer_types)
+check('校准⑭c 混合类型拦截', r_t6["ok"] is False
+      and any("类型冲突" in e for e in r_t6["errors"]), str(r_t6["errors"]))
+
+print(f'\n=== 白箱自举写编译器（C2 白箱化）: {pass_n}/{pass_n + fail_n} 通过 ===')
+sys.exit(0 if fail_n == 0 else 1)