@furongjun1999/dsh-memory 0.4.3 → 0.4.5

package/md_cg/whitebox_kb/wisdom/test_compiler_self_bootstrap.py

@@ -0,0 +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)

package/md_cg/whitebox_kb/wisdom/test_ecosystem_assembly.py

@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+"""第七阶段: 7 终极目标 × 7 初级复现 生态盘点 + 跨域组装验证"""
+import sys
+import os, io, re
+sys.stdout.reconfigure(encoding='utf-8')
+
+TOOLS = os.path.dirname(os.path.abspath(__file__))
+MODS = [
+    ('compiler', 'compiler_code_units.py'),
+    ('pylang', 'python_code_units.py'),
+    ('graph', 'graph_db_units.py'),
+    ('os', 'os_units.py'),
+    ('browser', 'browser_units.py'),
+    ('net', 'net_units.py'),
+]
+TARGET = {
+    'compiler': '2 中文编译器', 'pylang': '1 中文编程语言',
+    'graph': '6 条件图数据库', 'os': '4 中文操作系统',
+    'browser': '5 中文浏览器', 'net': '7 蜂群连接网络',
+}
+
+print('=' * 60)
+print('第七阶段 · 7 终极目标 × 7 初级复现 生态盘点')
+print('=' * 60)
+total = 0
+for name, fn in MODS:
+    src = io.open(f'{TOOLS}\\{fn}', encoding='utf-8').read()
+    # 精确匹配单元 dict 键: 行首 4 空格 + "域-名(可含空格)": {
+    uids = re.findall(r'^    "([^"]+)":\s*\{', src, re.M)
+    total += len(uids)
+    print(f'  {TARGET[name]:14s} {name:9s} {len(uids):3d} 单元')
+print('-' * 60)
+print(f'  六域合计: {total} 单元')
+
+# 核对：正则盘点 vs code_compose 正式注册表（防正则漏匹配——含空格 uid 如
+# "异步-async await" / "并行-Service Worker" 曾被 \S+ 漏掉）
+sys.path.insert(0, TOOLS)
+from code_compose import DOMAIN_UNITS
+reg_total = sum(len(DOMAIN_UNITS[n]) for n, _ in MODS)
+if total == reg_total:
+    print(f'  注册表核对: 正则 {total} == DOMAIN_UNITS {reg_total} ✔')
+else:
+    print(f'  注册表核对: 正则 {total} != DOMAIN_UNITS {reg_total} ✘（正则漏匹配）')
+
+# ============ 跨域组装验证 ============
+print()
+print('=' * 60)
+print('跨域组装: 条件路由图(graph) → 图查询 → 网络可靠传输(net)')
+print('           → 操作系统内存(os) → 浏览器绘制(browser)')
+print('=' * 60)
+from code_compose import domain_route
+
+def get(uid, q):
+    r = domain_route(q)
+    assert r.get('ok') and r.get('code'), f'{uid} 生成失败: {r}'
+    ns = {}
+    exec(r['code'], ns)
+    return ns
+
+# ① graph: 建图（条件链）
+ns_g = get('图存储-节点边', '写一个图存储单元（节点和边）')
+Graph = ns_g['Graph']
+g = Graph()
+g.add_edge('气压低', '沸点降')
+g.add_edge('沸点降', '煮不熟')
+g.add_edge('气压低', '缺氧')
+g.add_edge('缺氧', '煮不熟')
+
+# ② graph: 最短路径 + 条件链查询
+ns_sp = get('图遍历-最短路径', '写一个图最短路径单元（BFS 最少跳数）')
+sp = ns_sp['shortest_path'](g, '气压低', '煮不熟')
+print(f'  ① 条件链最短路径: {" → ".join(sp)}')
+
+# ③ net: 滑动窗口可靠传输（把条件链当消息帧传）
+ns_sw = get('网络-滑动窗口', '写一个 TCP 滑动窗口单元（ACK 窗口前移）')
+ns_ca = get('网络-累积确认', '写一个 TCP 累积确认单元（连续序号推进）')
+recv, acks = set(), []
+for i, node in enumerate(sp, 1):
+    ack = ns_ca['cum_ack'](recv, i)
+    acks.append(ack)
+win = ns_sw['sliding_window'](0, 0, 3, max(acks))
+print(f'  ② 条件链作为消息帧传输: 累积确认 ack={max(acks)} 窗口={win["window"]}')
+
+# ④ os: 为每个节点分配内存页（页表映射）
+ns_pt = get('内存-页表映射', '写一个页表映射单元（虚拟页到物理帧）')
+ns_pf = get('内存-缺页处理', '写一个缺页处理单元（空闲帧加载）')
+pt, frames = {}, list(range(10, 10 + len(sp)))
+for vpn, node in enumerate(sp):
+    r = ns_pf['page_fault_handler'](pt, vpn, frames, lambda v, f: None)
+print(f'  ③ 条件链节点驻留内存: {len(pt)} 页 已映射 {sorted(pt)}')
+
+# ⑤ browser: 把条件链绘制到画布（可视化）
+ns_pn = get('渲染-绘制', '写一个绘制单元（布局到画布）')
+layout = [(i, 0, i, 1, 1) for i in range(len(sp))]
+canvas = ns_pn['paint'](layout, len(sp), len(sp))
+print(f'  ④ 条件链可视化画布: {canvas}')
+
+# ⑥ compiler: 用中文循环语义验证链遍历次数
+ns_cl = get('编译-循环', '写一个循环编译单元（当条件执行 while）')
+loop_code = ns_cl['compile_loop'](
+    [('LOAD', 'i'), ('PUSH', len(sp)), ('CMP_LT', None)],
+    [('LOAD', 's'), ('LOAD', 'i'), ('ADD', None), ('STORE', 's'),
+     ('LOAD', 'i'), ('PUSH', 1), ('ADD', None), ('STORE', 'i')])
+ns_vm = get('VM-循环执行', '写一个 VM 循环执行单元（while 循环运行）')
+res = ns_vm['vm_run_loop'](loop_code, {'i': 0, 's': 0})
+print(f'  ⑤ 中文循环语义: 链节点数 0..{len(sp)-1} 累积和 s={res["symbols"]["s"]}')
+
+# ⑦ 真实中文编译器输出贯穿全链：gcd(48,36)=12 → 网络传输 → 内存 → 图存储 → 可视化
+sys.path.insert(0, __import__('os').environ.get('AEIS_PROTOCOL_COMPILER') or __import__('os').path.join(__import__('os').path.dirname(__import__('os').path.dirname(__import__('os').path.abspath(__file__))), __import__('os').pardir, 'protocol-compiler'))
+from core.compiler import compile_source as pc_compile
+from core.condition_vm import ConditionVM
+src_gcd = '''
+定义 最大公约数（甲，乙）：若 甲 等于 乙，则 返回 甲，否则 若 甲 大于 乙，则 返回 最大公约数（甲 减 乙，乙），否则 返回 最大公约数（甲，乙 减 甲）；
+结果 = 最大公约数（48，36）；
+止。
+'''
+code_gcd, r_gcd = pc_compile(src_gcd, strict=False)
+st_gcd = ConditionVM().run(code_gcd)
+gcd_val = st_gcd['symbols'].get('结果', 0)
+print(f'  ⑥ 中文编译器计算 gcd(48,36)={gcd_val}')
+
+# ⑦a 结果作为消息帧经滑动窗口传输
+recv2, acks2 = set(), []
+for i in range(1, int(gcd_val) + 1):
+    ack = ns_ca['cum_ack'](recv2, i)
+    acks2.append(ack)
+win2 = ns_sw['sliding_window'](0, 0, 4, max(acks2))
+print(f'  ⑦ 结果经滑动窗口传输: ack={max(acks2)} 窗口={win2["window"]}')
+
+# ⑦b 结果驻留内存页
+pt2, frames2 = {}, list(range(20, 20 + int(gcd_val)))
+for vpn in range(int(gcd_val)):
+    ns_pf['page_fault_handler'](pt2, vpn, frames2, lambda v, f: None)
+print(f'  ⑧ 结果驻留内存: {len(pt2)} 页')
+
+# ⑦c 结果存入条件路由图（12 个节点链）
+g2 = Graph()
+for i in range(1, int(gcd_val)):
+    g2.add_edge(f'步{i}', f'步{i+1}')
+sp2 = ns_sp['shortest_path'](g2, '步1', f'步{int(gcd_val)}')
+print(f'  ⑨ 结果存入条件路由图: 12 步链 {"→".join(sp2[:3])}…')
+
+# ⑦d 结果可视化
+layout2 = [(i, 0, i, 1, 1) for i in range(min(len(sp2), 4))]
+canvas2 = ns_pn['paint'](layout2, 4, 4)
+print(f'  ⑩ 结果可视化画布: {canvas2}')
+
+ok2 = (gcd_val == 12.0 and win2['window'] == [12, 13, 14, 15]
+       and len(pt2) == 12 and len(sp2) == 12)
+
+ok = (sp == ['气压低', '沸点降', '煮不熟'] and win['window'] == [3, 4, 5]
+      and len(pt) == len(sp) and res['symbols']['s'] == 3
+      and canvas == ['#..', '#..', '#..'] and ok2)
+print()
+print('=' * 60)
+print(f'跨域组装判定: {"✔ 六域单元互相配合形成完整演示生态（含真实中文编译器输出贯穿全链）" if ok else "✘ 存在偏差"}')
+print('=' * 60)
+sys.exit(0 if ok else 1)