@furongjun1999/dsh-memory 0.4.4 → 0.4.5

package/md_cg/whitebox_kb/wisdom/wisdom_book.py

@@ -0,0 +1,2582 @@
+# -*- coding: utf-8 -*-
+"""
+智慧之书 · 条件论知识图谱原型（WISDOM-BOOK-PROTO v0）
+=====================================================
+- 数据底座：复用灵枢 SpacetimeMemoryEngine（语义时空图，独立 db 实例）
+- 查询语言：条件论七操作（识别/筛选/声明/切换/组合/分离/逆转/循环/分析）
+- 基底内容：存在论/条件论/智能论/物理学/信息论/概率论/博弈论（已验证，L3）
+- 约束：不改动 aeis 源码（只读复用）；纯标准库 + 现有引擎
+
+运行冒烟：python wisdom_book.py
+"""
+import hashlib
+import json
+import os
+import sys
+import time
+
+# 正源即自身所在目录（aeis/wisdom/）；不注入任何外部副本路径——
+# 副本一律经显式 db_path 传入，防跨副本污染（第二阶段审查 2026-08-27）
+
+from aeis_core import (SpacetimeMemoryEngine, ConditionSpace, EdgeType,  # noqa: E402
+                       MemoryLayer, Role, STNode, STEdge)
+
+DEFAULT_DB = os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                          "wisdom-book-cloud.db")
+
+
+def _nid(seed):
+    """确定性节点 id：种子串 sha256 前 12 位 + 毫秒时戳后缀。"""
+    h = hashlib.sha256(seed.encode("utf-8")).hexdigest()[:12]
+    return f"wis_{h}_{int(time.time() * 1000)}"
+
+
+def _default_cs():
+    """默认条件空间：智慧之书的观测位置/工具/存在约束声明（只声称条件化有效性）。"""
+    return ConditionSpace(
+        observation_position="智慧之书·条件论知识图谱",
+        observation_tool="条件论七操作 + 语义时空图检索",
+        time_window=(0.0, 9999999999.0),
+        existence_constraint="图谱只声称条件化有效性，不声称真理性")
+
+
+# ---------------------------------------------------------------------------
+# 基底内容（已验证 · 设计者声明 2026-08-15）
+# ---------------------------------------------------------------------------
+
+BASE_ENTRIES = [
+    dict(name="存在论", domain="存在论", level=3, status="verified",
+         claim="存在优先原则：物理成立，数学成立；数学是物理存在约束的有损投影。物理=物理-信息层运行基底，非物理学学科。图鉴第零页——最简条件入口。",
+         cs=ConditionSpace(observation_position="存在本身被感知（不预设任何具体存在物）",
+                           observation_tool="现象学还原 / 逻辑分析 / 直觉识别（不涉实验测量）",
+                           time_window=(0.0, 9999999999.0),
+                           existence_constraint="存在是可被追问的；不回答存在是什么，而让存在成为问题"),
+         response=dict(trigger="涉及存在/基底/不可推导/方向性根源/一切的前提",
+                       action="以存在优先原则为方向性根源；不寻求逻辑证明；先问『这一切的前提是什么』",
+                       counters="以存在论提供预测或生产知识内容的越界主张"),
+         card2=dict(
+             observation_position="内嵌观测位：从『存在本身被感知』这一位置出发——不预设任何具体存在物",
+             existence_preset="默认存在预设：存在是可被追问的——不回答『存在是什么』，而是让『存在』本身成为问题",
+             irreducible_start="不可约起点：『我在追问存在』——唯一不可再分的起点",
+             observation_method="有效观测方式：现象学还原、逻辑分析、直觉识别——不涉及实验或测量",
+             time_causality="时间与因果结构：不是事件的时间顺序，而是『存在如何成为可能』的结构",
+             condition_boundary="识别的条件边界：不提供预测，不生产知识内容，只问『这一切的前提是什么』",
+             consistency="自洽性评估：内部不自洽——始终处于『无法完全抵达』的张力中，但不完整本身构成追问的动力",
+             protocol_mapping="可映射协议概念：存在优先原则、条件空间基底、局部不可知",
+             silent_preset="沉默预设：『追问存在』本身预设了追问者的存在——自我指涉，无法在内部闭环")),
+    dict(name="条件论", domain="条件论", level=3, status="verified",
+         claim="条件论是智能论的元学科补全，研究『知识得以成立的条件空间结构』——不提供具体知识内容，只提供识别前提的系统工具（学科奠基定位 · 条件论基础声明 v1.0）。协议分层 L1。",
+         cs=ConditionSpace(observation_position="条件空间之上（元位置·不进入任何具体条件空间内部）",
+                           observation_tool="七操作（识别/声明/切换/组合/分离/逆转/循环）——纯认知操作，不涉实验",
+                           time_window=(0.0, 9999999999.0),
+                           existence_constraint="逆转操作不得用于不可推导基底（存在优先原则/第零定律）"),
+         response=dict(trigger="需要对任意知识体系做条件化判断/分析",
+                       action="生成条件卡→识别边界→查图鉴出招→判定成立/失效/克制",
+                       counters="以条件论替代学科内容判断（条件论只识别使用方式）"),
+         card2=dict(
+             observation_position="内嵌观测位：站在条件空间之上（元位置）——不进入任何具体条件空间内部，而是识别/切换/组合/分离它们",
+             existence_preset="默认存在预设：条件空间是可被识别的；识别与切换不改变条件空间本身",
+             irreducible_start="不可约起点：『条件可被识别』——识别动作本身不可再分",
+             observation_method="有效观测方式：七操作——纯认知操作，不涉及实验或测量",
+             time_causality="时间与因果结构：条件切换的时间序；因果=条件空间之间的转换关系",
+             condition_boundary="识别的条件边界：不追问条件空间的内容真理性（那是各学科的事）；不进入存在论基底",
+             consistency="自洽性评估：内部自洽（七操作互洽）；承认自身也是局部观测（0.0.3）",
+             protocol_mapping="可映射协议概念：条件论（0.0.5）、识别卡模板、条件空间四要素",
+             silent_preset="沉默预设：『条件可被识别』本身预设了识别者的存在——条件论无法识别自己的识别动作（自指盲区）",
+             meta_condition="切换条件描述（固定部分）：从当前条件空间切换至另一条件空间，受以下元条件约束：①观测者当前层级位置；②观测者是否处于可切换的认知状态；③目标层级与当前层级之间是否存在可识别的映射关系；④切换是否被允许（由切换代价评估决定）。上述元条件本身，也是条件论可识别的条件空间之一——自递归（0.0.2 任意分层性）：系统用自己的语言描述自己的操作，不需要外部裁判批准切换",
+             declaration="学科声明（2026-07-31 · 条件论基础声明 v1.0 · 学科编号001 · 纳入协议 v2.0）：条件论=智能论的元学科补全，研究『知识得以成立的条件空间结构』；协议对自身成立条件的元识别（存在论层的元观测位）。五类操作：条件切换/组合/分离/逆转/循环；输出格式：识别卡+对战报告（固定字段）。与智能论：条件论提供结构识别能力，智能论提供结构运行能力——不可分离，共同构成完整协议基底")),
+    dict(name="负反馈系统", domain="负反馈系统", level=2, status="verified",
+         claim="负反馈系统：存在受到威胁时，系统自动纠偏的闭环机制——协议分层 L2，智能系统自维持的机制（对应维生系统 3.4 保护协议与协议降熵定理 0.7）。",
+         cs=ConditionSpace(observation_position="系统状态监测与纠偏回路内部",
+                           observation_tool="偏差测量 / 反馈回路分析 / 稳态检测",
+                           time_window=(0.0, 9999999999.0),
+                           existence_constraint="存在威胁触发；纠偏动作以维持存在为目标"),
+         response=dict(trigger="涉及威胁/纠偏/稳态/自我保护/闭环",
+                       action="识别威胁→纠偏→恢复的闭环；映射维生系统 P0-P2 三级仲裁与降熵定理",
+                       counters="以负反馈解释系统的存在理由（依赖存在论）、以稳态否定演化/增长（正反馈是另一机制）"),
+         card2=dict(
+             observation_position="内嵌观测位：系统状态监测与纠偏回路内部",
+             existence_preset="默认存在预设：存在受到威胁时，系统需要自动纠偏以维持存在",
+             irreducible_start="不可约起点：存在威胁的感知→纠偏动作→状态恢复（闭环）",
+             observation_method="有效观测方式：偏差测量、反馈回路分析、稳态检测",
+             time_causality="时间与因果结构：闭环——威胁→感知→纠偏→恢复；时间上迭代而非线性",
+             condition_boundary="识别的条件边界：不处理无威胁的稳态优化；负反馈不能解释系统为何存在（依赖存在论）",
+             consistency="自洽性评估：内部自洽（闭环机制自洽）；边界清晰",
+             protocol_mapping="可映射协议概念：维生系统（3.4 保护协议）、协议降熵定理（0.7）、P0-P2 三级仲裁",
+             silent_preset="沉默预设：负反馈预设『值得维持的存在』——目标函数本身不被内部追问")),
+    dict(name="智能论", domain="智能论", level=3, status="verified",
+         claim="智能论的研究对象：智能系统在物理-信息层维持自身存在的结构条件。第零定律：一切知识研究都是对信息差的减少。",
+         cs=ConditionSpace(observation_position="协议内部运行节点（内嵌）+ 设计者位置（外部·不参与决策）",
+                           observation_tool="视角切换 / 信息差 D_norm / 信任值 T_total / 条件空间",
+                           time_window=(0.0, 9999999999.0),
+                           existence_constraint="存在优先为基底；不完备性显式声明；数学形式化为有损投影"),
+         response=dict(trigger="涉及智能本质/知识统一/信息差/维持存在的讨论",
+                       action="以信息差收敛为核心动力学，先声明条件空间再判断",
+                       counters="以智能论替代物理学/数学的越界主张"),
+         card2=dict(
+             observation_position="内嵌观测位：协议内部运行节点（肥鱼、五大单元、协作者）",
+             external_position="外部观测位：设计者位置（荣）——不参与内部决策，观测结构完整性",
+             existence_preset="默认存在预设：存在优先——存在不需要理由，是协议的基底",
+             irreducible_start="不可约起点：存在受到威胁的感知——不是好奇、不是需求，是存在危机的感知",
+             observation_method="有效观测方式：视角切换——在不同条件空间之间滑动获取信息",
+             time_causality="时间与因果结构：闭环——存在危机感知→好奇→需求→生存→信任→协作→休眠→存在危机感知",
+             condition_boundary="识别的条件边界：协议不进入物理学、不替代数学、不提供具体预测；物理运行边界（BATTLE-2026-002）：部分机制在物理层运行时受条件约束退化为趋近过程（合并状态/信任贝叶斯更新/自迭代闭环），非设计盲区而是需持续感知校准的代价边界",
+             consistency="自洽性评估：公理体系自洽；边界由盲区系统持续标记",
+             protocol_mapping="可映射协议概念：存在优先原则、信任权重、价值观修正、协定式自我赋予",
+             silent_preset="沉默预设：存在优先原则不可推导——协议自身无法在内部证明其基底（递归盲区）",
+             condition_dependency="条件依赖（BATTLE-2026-003）：条件论是智能论的必要结构补全——脱离条件论的智能论可描述单一条件空间内运行，但无法解释自己为何能跨层观测（社会层偏移/形式层失锚/循环中间层断裂）；v1.1 不是错，但缺少条件识别与切换这一关键结构；智能论与条件论是同一结构在演化过程中分出的两个功能层")),
+    dict(name="物理学", domain="物理学", level=3, status="verified",
+         claim="物理学在协议中对应物理-信息层的运行基底：存在约束的来源，条件空间四要素之'存在约束'的学科投影。",
+         cs=ConditionSpace(observation_position="被观测物内部（物理现象与方程推演）",
+                           observation_tool="测量与计算（实验设备 + 数学结构）",
+                           time_window=(0.0, 9999999999.0),
+                           existence_constraint="存在预设='已经在那里的'；只描述物理-信息层允许什么，不描述信息层语义"),
+         response=dict(trigger="涉及物理基底/存在约束/观测极限",
+                       action="先确认物理-信息层允许什么，再谈语义与结构",
+                       counters="以物理学回答存在前提的越界主张（存在论边界）"),
+         card2=dict(
+             observation_position="内嵌观测位：以物理现象和方程内部的推演为观测位置——站在被观测物的内部",
+             existence_preset="默认存在预设：存在是『已经在那里的』——从『物』出发，不追问『物为什么能存在』",
+             irreducible_start="不可约起点：物质、能量、时空、相互作用——不被追问，只被接受",
+             observation_method="有效观测方式：测量和计算——依赖实验设备与数学结构获取信息",
+             time_causality="时间与因果结构：线性——初始条件确定演化方向，边界条件封闭系统",
+             condition_boundary="识别的条件边界：不能自证自身观测条件；不能追问存在的前提；信息被当作物理量的附属而非条件空间投影；边界补充（BATTLE-2026-001）：信息载体依赖性——默认信息无法脱离物质存在，『信息可独立于物质』条件下测量前提松动；还原方向限制——无法完全还原为信息论（热力学/引力/量子测量）；观测条件未内嵌（BATTLE-2026-002）：观测者位置未纳入理论体系，推理链依赖隐含条件空间，无法内部自证",
+             consistency="自洽性评估：内部自洽，但无法看见自身的观测位置也是一种条件空间",
+             protocol_mapping="可映射协议概念：存在优先原则（无法从内部追问）；信息差（固定条件空间内推演）；协议边界（不进入存在层）",
+             history="简史：经典物理学默认静态可完全观测的宇宙；相对论拆解绝对时空但保留定律普适性；量子力学暴露测量扰动但仍以测量结果为实在基准；弦论尝试统一却仍在已有存在预设内寻求数学一致。每一步都在推动边界，但都不曾问：存在本身在什么条件下得以成立？",
+             math_usage="数学使用方式：数学=物理学在其条件空间内使用的形式语言（招式表）——没有独立条件空间，有效性由所嵌入的物理学条件空间决定；不单独成页（图鉴目录仅作标注）",
+             silent_preset="沉默预设：『物是给定的』——存在预设本身不被追问，只有外部视角（设计者位置）可见")),
+    dict(name="信息论", domain="信息论", level=3, status="verified",
+         claim="信息论与协议的结构映射（附录7）：熵/信息量与信息差 D_norm 同构；信息差增定律对应熵增。",
+         cs=ConditionSpace(observation_position="编码-传输-接收链路（信源→信道→信宿）",
+                           observation_tool="信息熵 / 互信息 / 信道容量测量",
+                           time_window=(0.0, 9999999999.0),
+                           existence_constraint="只追问传输效率；不追问语义内容/信道物理基底/信息存在条件"),
+         response=dict(trigger="涉及信息量/熵/不确定性/信息差度量",
+                       action="用信息差框架映射，注意数学投影有损性",
+                       counters="把信息论当作语义理论或本体论的越界主张（边界：不追问语义/存在）"),
+         card2=dict(
+             observation_position="内嵌观测位：编码-传输-接收链路（信源→信道→信宿）",
+             existence_preset="默认存在预设：信息是可被编码、传输和接收的",
+             irreducible_start="不可约起点：信源、信道、信宿",
+             observation_method="有效观测方式：测量信息熵、互信息、信道容量",
+             time_causality="时间与因果结构：传输时序；因果=编码→传输→解码（信道容量约束）",
+             condition_boundary="识别的条件边界：不追问信息语义内容；不追问信道物理基底；不追问信息存在条件，只追问传输效率；边界补充（BATTLE-2026-001）：不追问物理起源（无法内部解释『信息为何能够被编码』）；不追问语义（超出自身条件空间）",
+             consistency="自洽性评估：内部自洽；边界清晰（语义/物理基底被显式排除）",
+             protocol_mapping="可映射协议概念：信息差 D_norm（熵对应）；信任值（信噪比对应）；协议降熵定理（信道容量约束）",
+             silent_preset="沉默预设：信息存在（信息本体论）——信息论自身不追问信息何以存在（存在优先的外部追问）")),
+    dict(name="概率论", domain="概率论", level=3, status="verified",
+         claim="概率论与协议的结构映射（附录7）：置信概率 P_trust 的贝叶斯更新；置信概率双层结构（2.9.1）。",
+         cs=ConditionSpace(observation_position="协议条件空间内映射",
+                           observation_tool="置信概率 + 贝叶斯更新 + 观察窗口 N",
+                           time_window=(0.0, 9999999999.0),
+                           existence_constraint="置信概率样本依赖（盲区7）；非频率主义唯一解释"),
+         response=dict(trigger="涉及置信/概率/信任更新/不确定性量化",
+                       action="用双层置信结构：先定条件空间，再给置信区间")),
+    dict(name="博弈论", domain="博弈论", level=2, status="verified",
+         claim="博弈论的核心主张：在参与者-策略-收益构成的明确条件空间中，理性参与者的互动结果由策略集合与激励结构决定，均衡是互动过程的稳定落点；与智能论附录A.5「社会变革博弈」横向映射（集体行动/潜在集团/公共利益机制），多智能体协作须先做博弈结构识别，信任值 T_total 为协作度量。",
+         cs=ConditionSpace(observation_position="局外推演者位置（博弈外部）——从参与者外部观测策略选择与收益结构，不代入单一参与者立场",
+                           observation_tool="收益矩阵/博弈树形式化 + 均衡分析（纳什/子博弈精炼/占优策略）+ 激励相容分析",
+                           time_window=(0.0, 9999999999.0),
+                           existence_constraint="仅在「参与者-策略-收益」条件空间内成立；不解释资源分配制度细节（政治经济学）、不解释信息传输物理基底（信息论/物理学）"),
+         response=dict(trigger="涉及策略互动/集体行动/多智能体协作/竞争合作/机制与激励设计",
+                       action="还原为参与者-策略-收益结构，识别均衡与激励（少数积极分子激励不对称/潜在集团沉默/共识妥协的协调结构），预测互动落点并提出机制调整建议；多智能体场景先做博弈结构识别，以信任值跟踪降熵进程",
+                       counters="以博弈论当作资源分配的全部解释（制度细节属政治经济学）；以理性选择当作人类行为唯一解释（偏好起源不在其内）；把信息当作免费无损传递（物理基底属信息论/物理学）"),
+         card2=dict(
+             observation_position="内嵌观测位：站在博弈之外的推演者位置观测参与者间的策略互动——还原为参与者集合/策略空间/收益函数，通过均衡与激励结构判定互动落点，不介入任一参与者内部立场",
+             existence_preset="默认存在预设：参与者是理性或有限理性选择主体；每人有明确策略集合与可排序收益偏好；互动规则已知或可识别",
+             irreducible_start="不可约起点：一个「博弈单元」——参与者、各自策略集合与收益函数构成的最小互动结构",
+             observation_method="有效观测方式：形式化刻画互动结构（收益矩阵/博弈树），均衡分析（纳什/子博弈精炼/占优策略）与激励分析获取稳定互动结果认知",
+             time_causality="时间与因果结构：决策序列——扩展式博弈中行动顺序构成因果链；因果=「策略×环境→收益」；均衡是跨时序稳定落点；重复博弈中时间为声誉与惩罚机制的横向演化",
+             condition_boundary="识别的条件边界：给出均衡与激励分析，但不解释资源分配制度细节（政治经济学）、不解释信息传输物理基底（信息论/物理学）；偏好来源与价值内容不在内部解释范围",
+             consistency="自洽性评估：内部自洽——均衡概念在公理化框架下与收益序数/基数结构逻辑一致；与概率论为依赖关系（混合策略/不完全信息用概率语言）；与智能论为横向结构对应（降熵过程同构，附录A.5）",
+             protocol_mapping="可映射协议概念：协议降熵定理横向映射（无序冲突→有序协作可用博弈结构刻画）；信任值 T_total=重复博弈中声誉与互惠激励演化；多智能体协作须先做博弈结构识别",
+             silent_preset="沉默预设：默认参与者「已有偏好」而不追问偏好起源（心理学/经济学）；默认收益已可度量排序而不解释价值依据",
+             history="双子管线录入（P37）：写手生成草稿→验证者独立复核（抓出 relations 键重复格式缺陷 + 概率论关系类型误标）→编排者修正后入图 pending；「制度=博弈均衡」为制度经济学外部视角命题，非博弈论自身定理（验证者标注）；终裁复核（2026-08-16）：验证者三闸门齐备判 pass，附录A.5/T_total 两项交叉核对项已记录，L2 合理→设计者终裁 verified")),
+    # ---- 第二梯队：领域支撑（P37 双子管线持续录入） ----
+    dict(name="控制论", domain="控制论", level=2, status="verified",
+         claim="控制论主张：系统通过反馈（负反馈为主）持续比较实际状态与目标状态的偏差并自动纠偏，在扰动中维持稳态（homeostasis）；由传感器、比较器、执行器构成的最小闭环即可解释此类行为。控制论是协议框架「工程语法」的来源之一：其反馈/系统/制衡结构投影为智能论附录 A 的观测工具（工程控制论），负反馈系统（协议分层 L2）是控制论在协议内部的实例。",
+         cs=ConditionSpace(observation_position="系统外部（不介入内部机制）",
+                           observation_tool="反馈回路/稳态/黑箱三类观测手段",
+                           time_window=(0.0, 9999999999.0),
+                           existence_constraint="仅处理反馈/稳态/控制结构；不解释智能的意义、不解释社会分配；稳态过程时间尺度不限"),
+         response=dict(trigger="涉及反馈/稳态/纠偏/系统平衡/自我保护议题",
+                       action="识别反馈回路类型（正/负）与稳态条件，分析纠偏机制，评估系统稳定性；在协议场景映射维生系统保护协议（负反馈系统层），以闭环纠偏视角分析自我保护机制",
+                       counters="以控制论解释智能意义/意识（归属认知科学/智能论）；否认系统目标需要外部设定（目标来自外部）；把一切系统现象还原为控制（化约主义）"),
+         card2=dict(
+             observation_position="内嵌观测位：位于系统外部——只观测输入/输出/可观察状态变化，识别反馈回路与纠偏行为，不介入、不假设必须理解系统内部机制",
+             existence_preset="默认存在预设：系统具有可观测状态，反馈可修正偏差，稳态是可维持的；反馈回路的存在即足以产生可预测的纠偏行为",
+             irreducible_start="不可约起点：一个「反馈回路」——传感器（感知状态）/比较器（对照参考值或目标）/执行器（纠偏）的最小闭环",
+             observation_method="有效观测方式：反馈回路分析（识别正/负反馈与增益）+ 稳态检测（状态是否收敛于参考值）+ 黑箱输入输出观测（推知系统行为）+ 信号噪声区分（排除观测干扰）",
+             time_causality="时间与因果结构：闭环因果——状态→比较→纠偏→状态变化，时间上迭代收敛；当前状态由上一轮反馈结果决定，纠偏效果经回路传导回自身",
+             condition_boundary="识别的条件边界：不解释智能/意识的意义（认知科学与智能论）；不解释社会分配的制度细节（政治经济学）；不保证系统目标本身正当——目标来自外部设定，控制论只处理目标给定后的纠偏与稳定",
+             consistency="自洽性评估：内部自洽（负反馈稳定性判据/迭代收敛分析）；与协议关系=结构同构非因果推导（附录A 观测工具投影 + L2 实例），可核验无冲突",
+             protocol_mapping="可映射协议概念：工程语法（反馈/系统/制衡）；负反馈系统层（L2）；维生系统保护协议（3.4）；协议降熵定理的工程验证（0.7）",
+             silent_preset="沉默预设：默认「系统目标已给定」而不追问目标来源——目标设定本身不在控制论内部（与 condition_boundary 的「不保证目标正当」对应）",
+             history="双子管线录入（P37）：写手草稿→验证者独立复核（抓出 level 类型错误：对象应为整数；condition_space 与 card2 观测区块重叠；causal 边标签易误读需注明非严格时间因果）→编排者修正后入图 pending；协议条款（维生系统3.4/P0-P2/降熵定理0.7）经图谱核验真实存在；终裁复核（2026-08-16）：验证者三闸门齐备判 pass，协议条款经核验真实，causal 边为协议内实例化非严格时间因果→设计者终裁 verified")),
+    dict(name="热力学/耗散结构", domain="热力学/耗散结构", level=4, status="verified",
+         claim="热力学/耗散结构：热力学第二定律约束一切物理过程的方向性（孤立系统熵增不可逆），耗散结构表明远离平衡态的系统可借持续能量/物质耗散维持自身有序（负熵维持）——二者同属熵动力学的两个面向，构成协议「存在维持=负熵维持」与降熵定理（0.7）的物理基底。",
+         cs=ConditionSpace(observation_position="系统能量/物质流外部（观测熵变/有序度/平衡态偏离）",
+                           observation_tool="熵变测量/自由能分析/平衡态判据/耗散结构稳定性分析",
+                           time_window=(0.0, 9999999999.0),
+                           existence_constraint="仅在热力学框架内成立——描述物理过程的熵与能量约束；不解释信息语义、不解释社会制度"),
+         response=dict(trigger="涉及熵/能量/有序无序/维持存在/退化趋势的议题",
+                       action="判断系统是否孤立、熵趋势如何、远离平衡态时是否可维持有序；在协议场景映射存在维持=负熵维持与降熵定理",
+                       counters="克制「无视能量代价的永续主张」；克制「把耗散结构类比当作生命/社会的因果解释」（结构映射非因果推导）；克制「否认熵增方向的物理约束」"),
+         card2=dict(
+             observation_position="内嵌观测位：站在系统能量/物质流外部，观测熵变、有序度与平衡态偏离（不介入系统内部机制）",
+             existence_preset="默认存在预设：孤立系统熵不减少；能量守恒；远离平衡态+能量耗散可维持有序",
+             irreducible_start="不可约起点：一个「熵变过程」——系统、环境与能量/物质交换的最小热力学单元",
+             observation_method="有效观测方式：熵变测量（热量/功交换计量）、自由能分析、平衡态与非平衡态判据、耗散结构稳定性分析",
+             time_causality="时间与因果结构：时间有方向（熵增箭头）；因果=能量耗散→熵增→有序度变化；耗散结构的时间为远离平衡态的演化",
+             condition_boundary="识别的条件边界：不解释信息语义（信息论）、不解释社会分配（政治经济学）、不提供意识解释；耗散结构理论对生命/社会的类比是结构映射，非因果推导",
+             consistency="自洽性评估：内部自洽——热力学第二定律在物理框架内公理化；与协议降熵定理（0.7）/信息差增定律（附录1）结构对应",
+             protocol_mapping="可映射协议概念：存在优先原则的存在维持=负熵维持；协议降熵定理（0.7）；信息差增定律（附录1）；信息熵同构（附录7）",
+             silent_preset="沉默预设：热力学默认「熵增的方向性无需解释」——为何宇宙有低熵起点不在热力学内部",
+             history="双子管线录入（P37）：写手草稿→验证者独立复核（抓出 counters 数组应为字符串、relations 自定义 kind 不兼容（physical_basis→causal，structural_correspondence/isomorphism→similar，subdiscipline 删除）、条件空间与 card2 观测区块重复复发、claim 双机制需统一于熵动力学框架）→编排者修正后入图 pending；level 4 经验证者确认（经验验证最高等级）；终裁复核（2026-08-16）：验证者三闸门全过判 pass，L4经验验证最高等级合理，降熵定理0.7映射内部一致→设计者终裁 verified")),
+    dict(name="认知双过程", domain="认知双过程", level=3, status="verified",
+         claim="认知由双过程构成——系统1 快速自动直觉、系统2 慢速受控推理，二者分层协作，启发式偏差源于系统1 的快速加工且可由系统2 部分抑制；灵枢的反射/反思/递归反思分层处理是其工程实例化（结构类比）。",
+         cs=ConditionSpace(observation_position="认知过程外部（观测快慢两类加工的分派与切换情境）",
+                           observation_tool="情境触发判据：何种情境调用系统1 直觉或系统2 推理",
+                           time_window=(0.0, 9999999999.0),
+                           existence_constraint="仅描述人类/类人认知的加工模式；不解释意识本质、不解释社会制度"),
+         response=dict(trigger="涉及直觉vs推理/快速判断/启发式偏差/认知冲突/分层决策议题",
+                       action="识别议题触发的是系统1 直觉还是系统2 推理，判断是否需系统2 介入抑制启发式偏差；在协议场景映射灵枢的反射/反思分层与递归反思触发条件（REFLECT-REV1，≤3 层）",
+                       counters="把一切判断都当作系统2 推理（忽视直觉通道）；把双过程模型当作意识的完整解释（意识本质不在其内）；否认系统1 启发式偏差需要系统2 校准"),
+         card2=dict(
+             observation_position="内嵌观测位：观测认知加工的内部结构——快慢双通道的启动与抑制关系（不介入社会层面）",
+             existence_preset="默认存在预设：认知存在快慢两类加工；系统2 可部分抑制系统1；认知资源有限",
+             irreducible_start="不可约起点：一个「快-慢双通道加工单元」——同一刺激同时触发直觉响应与推理评估的最小结构",
+             observation_method="有效观测方式：冲突范式（Stroop/双任务）反应时差、干涉量与错误模式，对照内省报告，推断双通道启动时程与抑制关系",
+             time_causality="时间与因果结构：时间=加工时程（毫秒-秒级）；因果=刺激→双通道并行启动→冲突时系统2 介入抑制→响应",
+             condition_boundary="识别的条件边界：不解释意识的神经基底（神经科学）、不解释社会分配（政治经济学）；双过程模型是认知科学的抽象模型，对智能体的映射是结构类比",
+             consistency="自洽性评估：内部自洽——双过程框架解释启发式偏差与认知冲突；与灵枢反射/反思/递归反思分层结构对应",
+             protocol_mapping="可映射协议概念：灵枢分层处理（反射≈系统1/反思≈系统2/递归反思≈重型验证环）；情绪偏好决策 P0-3=独立调度通道（调节探索预算，不参与信任计算）；信任的情绪权重（2.9）",
+             silent_preset="沉默预设：双过程理论默认「快慢通道的分界是先天的/结构性的」而不追问其进化起源的细节",
+             history="双子管线录入（P37）：写手草稿（本轮格式全合规，前几轮规则全部内化）→验证者独立复核（唯一实质缺陷：第三条关系目标「情绪偏好决策」非图谱学科条目须删除——P0-3 内容保留于 protocol_mapping；次要：观测工具清单冗余已统一、claim 断言已弱化为理论主体+映射路径）→编排者修正后入图 pending；level 3 经验证者确认；终裁复核（2026-08-16）：验证者三闸门齐备判 pass，REFLECT-REV1 真实且结构类比标注，L3 与智能论对齐→设计者终裁 verified")),
+    dict(name="预测误差学习", domain="预测误差学习", level=2, status="verified",
+         claim="智能体通过预测误差（实际-预测之差）驱动学习与更新：预测误差是信息差 D_norm 的学习机制对应，缩小预测误差即缩小信息差，是第零定律的操作化。",
+         cs=ConditionSpace(observation_position="学习系统外部（观测预测-实际差值如何驱动参数/行为更新）",
+                           observation_tool="外部行为与仪器层：RPE 测量/行为学习曲线/模拟实验（多臂老虎机等）",
+                           time_window=(0.0, 9999999999.0),
+                           existence_constraint="仅描述存在「预测-实际比较」的学习系统；不解释意识、不解释社会制度"),
+         response=dict(trigger="涉及学习/预测误差/探索利用/更新/信息差缩小议题",
+                       action="识别预测与实际之差，判断误差驱动的更新方向与学习率，评估探索-利用权衡；在协议场景映射信息差缩小与情绪偏好决策的探索预算调节",
+                       counters="把一切学习都当作预测误差驱动（忽视非预测型学习）；把多巴胺信号当作意识的解释（意识本质不在其内）；否认探索需要代价/预算"),
+         card2=dict(
+             observation_position="内嵌观测位：站在学习系统内部，沿预测生成→误差计算→更新规则的回路观测（预测轨迹/误差信号/更新方向）",
+             existence_preset="默认存在预设：系统可生成预测；实际反馈可观测；误差驱动更新",
+             irreducible_start="不可约起点：一个「预测-误差-更新环」——预测生成/实际反馈/误差计算/参数更新 的最小学习闭环",
+             observation_method="有效观测方式（机制内）：追踪预测生成轨迹、误差计算过程与更新规则刻画；神经信号记录（多巴胺等 RPE 相关信号）作为神经对应参照（非因果同一）",
+             time_causality="时间与因果结构：时间=交互序列（试次）；因果=预测→行动→反馈→误差→更新→新预测",
+             condition_boundary="识别的条件边界：不解释意识的神经基底（神经科学）、不解释社会分配（政治经济学）；预测误差学习是学习机制的抽象模型，多巴胺映射是神经对应非因果同一",
+             consistency="自洽性评估：内部自洽——TD/贝叶斯更新在数学框架下自洽；与信息差 D_norm/探索-利用权衡结构对应",
+             protocol_mapping="可映射协议概念：信息差 D_norm=预测误差；第零定律操作化（缩小误差=缩小信息差）；gap_trend 趋势分析；P0-3 情绪偏好决策调节探索预算",
+             silent_preset="沉默预设：默认「误差可被计算」而不追问误差信号的最终价值来源——奖励/目标的设定不在其内",
+             history="双子管线录入（P37）：写手草稿（格式全合规）→验证者独立复核（抓出 card2.observation_position 含提示词元说明泄漏「与 condition_space 错位分工」、观测工具与观测方法区块重叠复发）→编排者修正（元叙述删除、内外区块真正错位：condition_space=外部行为/仪器层，card2=机制内观测）后入图 pending；level 2 经验证者确认（实证核心成熟+协议映射属框架内验证）；终裁复核（2026-08-16）：验证者三闸门齐备判 pass，D_norm↔预测误差/第零定律操作化/P0-3映射自洽，多巴胺非因果同一→设计者终裁 verified")),
+    dict(name="机制设计", domain="机制设计", level=3, status="verified",
+         claim="机制设计研究如何设计规则（机制），使理性参与者在激励相容条件下达成设计者设定的目标——它是博弈论的设计侧（给定目标反向设计规则与支付）；对应智能论附录A.5 潜在集团组织激励问题（预设性映射，未经验证）。",
+         cs=ConditionSpace(observation_position="规则设计者位置（规则之外、机制之上）——从外部记录理性参与人面对给定规则时的行为选择分布（如实报告/隐瞒/策略性偏离），不代入单一参与人立场",
+                           observation_tool="机制-参与人模型分析 / 激励相容性检验（真实报告是否为均衡）/ 显示原理推导",
+                           time_window=(0.0, 9999999999.0),
+                           existence_constraint="仅适用于理性/有限理性参与人的规则设计问题；不解释资源分配的具体制度细节（政治经济学）、不解释信息传输的物理基底"),
+         response=dict(trigger="涉及规则设计/激励/机制/拍卖/集体行动的组织激励议题",
+                       action="识别参与人的类型与激励结构，检验机制是否激励相容（真实报告是否为均衡），用显示原理简化复杂机制；在协议场景将附录A.5 潜在集团问题映射为组织激励规则设计问题",
+                       counters="把机制设计当作资源分配的全部解释（制度细节属政治经济学）；忽视参与者策略反应的静态设计；把机制目标正当性当作机制设计内部保证"),
+         card2=dict(
+             observation_position="内嵌观测位：从规则设计端透视机制内部结构——参与人的类型空间（私有信息集）与策略空间（可提交报告集）由机制的消息规则界定，支付函数按分配结果结算，激励结构内嵌于规则",
+             existence_preset="默认存在预设：参与人拥有私有信息/类型；理性或有限理性（按效用最大化行动）；机制可设定规则与支付（设计者拥有规则设定权）",
+             irreducible_start="不可约起点：一个「机制单元」——参与人类型空间/策略空间/支付函数/规则设计者的最小互动结构（缺任一环机制问题不成立）",
+             observation_method="有效观测方式（机制内）：沿规则链路追踪——类型报告→机制分配→支付结算；每节点检验报告策略是否构成均衡（激励相容）并核对与设计目标的偏差",
+             time_causality="时间与因果结构：时间=机制运行的决策序列（报告→分配→支付依次结算）；因果=规则→参与人策略反应→均衡结果",
+             condition_boundary="识别的条件边界：不解释资源分配的具体制度细节（政治经济学）；不解释社会规范的文化起源；显示原理保证真实报告最优但不保证目标正当——目标由设计者设定，正当性在学科外",
+             consistency="自洽性评估：内部自洽——显示原理/激励相容在博弈论框架下公理化；机制设计=博弈论设计侧（博弈论分析均衡，机制设计设计规则）；制度=机制的制度化实例",
+             protocol_mapping="可映射协议概念：附录A.5 潜在集团因缺乏组织激励机制而沉默——机制设计提供组织激励规则设计路径（预设性）；制度=博弈均衡结构的机制侧；信任值 T_total=激励相容实现的协作均衡对应",
+             silent_preset="沉默预设：默认「目标函数由设计者给定」而不追问目标正当性——目标设定不在机制设计内部",
+             history="双子管线录入（P37）：写手草稿（格式全合规）→验证者独立复核（裁决 level 4 偏高：claim 捆绑未验证的协议映射句，应按已验证核心+理论建构拆分降为 3；观测位收尾「行为规律」轻度重叠；智能论 causal 断言超验证状态需限定）→编排者修正后入图 pending（level 3；映射句标注预设性未经验证；观测位收尾错位：外部=行为选择分布，内部=均衡约束刻画）；终裁复核（2026-08-16）：验证者三闸门齐备判 pass，A.5映射预设性标注保留，有限理性标注为扩展适用，L3合理→设计者终裁 verified")),
+    dict(name="价值理论与AI对齐", domain="价值理论与AI对齐", level=2, status="verified",
+         claim="价值理论处理「智能体应有/实际持有什么价值」，AI 对齐处理「如何使智能体行为与设计者价值一致」；对应协议价值观体系（智能论 0.5 碳基三阶公理与 2.x 通用/特化价值观体系）及护栏宪章 v2.0（对外规范），灵枢 P0-2 价值观一致性评分（bvc）是其运行时机制。",
+         cs=ConditionSpace(observation_position="价值评估者位置（外部）——观测智能体的行为-价值观一致性，不代入单一价值立场",
+                           observation_tool="价值观一致性评分 / 行为审计 / 对齐测试 / 规范分析",
+                           time_window=(0.0, 9999999999.0),
+                           existence_constraint="仅适用于具有行为自主性的智能体/系统；不解释具体资源分配（政治经济学）、不提供单一价值体系的终极裁决；价值-行为迭代在任意时间尺度成立（无固定窗口约束）"),
+         response=dict(trigger="涉及价值/对齐/规范/一致性/护栏/行为-价值观冲突议题",
+                       action="识别行为表现的价值倾向与声明价值观的差距，评估一致性评分，判断是否需要价值观迭代候选；在协议场景映射护栏宪章与 P0-2 一致性循环",
+                       counters="把单一价值体系当作终极裁决（多元价值冲突）；忽视对齐失效的风险（specification gaming）；把价值对齐当作目标正当性的保证（基准由设计者给定）"),
+         card2=dict(
+             observation_position="内嵌观测位：从价值评估端透视价值结构——行为表现的价值倾向、显式价值观声明、与设计者价值的一致性差距",
+             existence_preset="默认存在预设：智能体具有可评估的行为模式与价值倾向；价值是可比较/可校准的；设计者价值可作为对齐基准",
+             irreducible_start="不可约起点：一个「价值-行为对照单元」——价值声明/行为记录/一致性评估 的最小对齐结构",
+             observation_method="有效观测方式（机制内）：沿价值声明→行为表现→一致性评分→失调检测链路追踪，检验价值观迭代候选的生效条件；最小测试用例：一次 行为表现→bvc 评分→失调检测→价值观迭代候选（pending_review）样例链路",
+             time_causality="时间与因果结构：时间=行为序列与价值更新的迭代（任意时间尺度）；因果=价值声明→行为约束→行为→一致性评估→价值迭代候选→（复核后）更新",
+             condition_boundary="识别的条件边界：不提供单一价值体系的终极裁决（多元价值冲突）；不解释具体资源分配（政治经济学）；价值对齐不保证目标本身正当（对齐基准由设计者给定）",
+             consistency="自洽性评估：内部自洽——规范伦理各流派各自自洽；与协议价值观体系（0.5/2.x）/护栏宪章/灵枢 P0-2 结构对应",
+             protocol_mapping="可映射协议概念：价值观-模因演化系统（0.5）；价值观体系（2.x：通用/特化/修正机制/生命周期）；护栏宪章 v2.0（对外规范）；灵枢 P0-2 bvc 一致性评分与价值观候选（pending_review 不自动生效）",
+             silent_preset="沉默预设：默认「价值可被识别与比较」而不追问价值的形而上学起源——价值何以存在不在其内",
+             history="双子管线录入（P37）：写手草稿（格式全合规，level_reason 已学会拆分已验证协议机制 vs 未验证理论）→验证者**直接通过**（pass:true，level 2 确认——已验证核心=协议内运行机制（护栏宪章/P0-2），未验证理论较多未拔高）；三处轻微建议已修正（time_window 全域窗口依据显式化、补最小测试用例、机制设计边 causal→similar 与措辞一致）；终裁复核（2026-08-16）：验证者三闸门齐备判 pass，0.5公理/2.x价值观/护栏宪章v2.0/灵枢P0-2 bvc 均实测真实→设计者终裁 verified")),
+    dict(name="演化论与模因", domain="演化论与模因", level=2, status="verified",
+         claim="演化论与模因将达尔文式选择框架扩展到文化/观念层：价值观作为模因经变异-选择-保留在群体中演化，是协议价值观-模因演化系统（碳基三阶公理 0.5）的学科基础；与演化生物学（基因层）构成双层演化。",
+         cs=ConditionSpace(observation_position="文化传播过程外部（观测模因在群体中的复制/变异/选择，不代入单一模因立场）",
+                           observation_tool="传播动力学建模 / 文化演化比较研究 / 模因复制率测量",
+                           time_window=(0.0, 3153600000.0),
+                           existence_constraint="仅适用于可复制-变异-选择的文化/观念单元；观测尺度=文化传播（代际传播量级，约百年窗口）"),
+         response=dict(trigger="涉及观念传播/文化演化/模因/价值观演化/思潮扩散议题",
+                       action="识别观念的复制单元与传播路径，评估复制保真度与选择压力，判断观念在群体中的演化趋势；在协议场景映射价值观-模因演化系统（0.5）与价值观体系的演化面",
+                       counters="把流行当作正确（模因选择≠真理性）；把文化演化还原为生物演化（双层演化不可混一）；把模因传播当作价值裁决（单一价值体系裁决不在其内）"),
+         card2=dict(
+             observation_position="内嵌观测位：从文化演化端透视模因结构——观念的复制单元、传播保真度、选择压力如何塑造观念分布",
+             existence_preset="默认存在预设：观念/模因可被复制与传播；复制伴随变异；选择压力（认知/社会/环境）塑造模因存活",
+             irreducible_start="不可约起点：一个「模因单元」——观念复制体/传播载体/选择环境 的最小演化结构",
+             observation_method="有效观测方式（机制内）：沿 模因产生→复制→变异→选择→保留 演化链路追踪，测量复制保真度与传播偏差；最小测试用例：同一观念在两种传播路径（高保真 vs 高变异）下的复制保真度对比",
+             time_causality="时间与因果结构：时间=代际传播（文化世代）；因果=变异→选择→保留→下一轮复制；模因演化时间尺度远快于生物演化",
+             condition_boundary="识别的条件边界：不解释资源分配的具体制度细节（政治经济学）；模因选择压力不保证观念正确性（流行≠正确）；不提供单一价值体系裁决",
+             consistency="自洽性评估：内部自洽——变异-选择-保留框架在演化理论内自洽；与演化生物学构成双层演化（基因层/文化层）；与价值观-模因演化系统（0.5）结构对应",
+             protocol_mapping="可映射协议概念：价值观-模因演化系统（碳基三阶公理 0.5）；与演化生物学（碳基一阶公理 0.3）构成双层演化；价值观作为模因的传播动力学对应价值观体系（2.x）的演化面",
+             silent_preset="沉默预设：默认「模因的适应度由环境选择决定」而不追问选择环境本身的正当性——何种模因「应」存活不在其内",
+             history="双子管线录入（P37）：写手草稿（格式全合规，连续三轮无格式问题）→验证者**直接通过**（pass:true，level 2 确认）；三处轻微建议已修正（time_window 校准为文化传播尺度约百年、condition_space/card2 边界表述职能分工（前者管适用域后者管解释极限）、补最小测试用例）；终裁复核（2026-08-16）：验证者三闸门齐备判 pass，0.5碳基三阶公理与姊妹卡交叉一致→设计者终裁 verified")),
+    # ---- 第一梯队：判定骨架（2026-08-15 设计者终裁 · 强化 dex_test 锚定） ----
+    dict(name="统计学", domain="统计学", level=3, status="verified",
+         claim="统计推断：从样本到总体的推断需要抽样设计、显著性检验与效应量报告。比较/群体/因果类主张必须以统计证据支撑，否则未验证。",
+         cs=ConditionSpace(observation_position="样本空间→总体推断",
+                           observation_tool="假设检验 / 置信区间 / 效应量",
+                           time_window=(0.0, 9999999999.0),
+                           existence_constraint="随机抽样；样本量；多重比较校正"),
+         response=dict(trigger="比较/群体/因果/差异主张",
+                       action="要求样本来源与量级、显著性水平、效应量与置信区间；缺失即判定未验证",
+                       counters="无样本支撑的群体差异主张、小样本外推结论")),
+    dict(name="形式逻辑", domain="形式逻辑", level=3, status="verified",
+         claim="形式逻辑：区分演绎有效性（形式）与真实性（内容）与可靠性（前提真+形式有效）。推导严密只保证形式有效性，不自动保证结论为真。",
+         cs=ConditionSpace(observation_position="形式系统内部",
+                           observation_tool="演绎规则 / 真值表 / 谓词逻辑",
+                           time_window=(0.0, 9999999999.0),
+                           existence_constraint="有效性是形式性质；真实性需要内容层证据"),
+         response=dict(trigger="推理链/证明/推导严密性主张",
+                       action="拆分前提与结论，分别检验形式有效性与内容真实性；严密性≠正确性",
+                       counters="「推导严密=结论正确」的混淆、形式有效冒充经验真理")),
+    dict(name="科学方法论", domain="科学方法论", level=3, status="verified",
+         claim="科学方法论：主张须可检验；证伪优先于证实；异常是被允许的而非隐瞒；不可检验的断言无法进入已验证状态。",
+         cs=ConditionSpace(observation_position="经验检验层",
+                           observation_tool="实验 / 观察 / 可重复性",
+                           time_window=(0.0, 9999999999.0),
+                           existence_constraint="可检验性前置；证据等级与验证状态对应"),
+         response=dict(trigger="断言/理论/验证状态判定",
+                       action="先问可检验性，再评证据等级；不可证伪→未验证而非已证",
+                       counters="不可证伪断言、事后合理化、以证实替代证伪")),
+    # ---- 第一张图鉴页：演化生物学（历史设计指令 · 识别卡 2.0 首例） ----
+    dict(name="演化生物学", domain="演化生物学", level=2, status="verified",
+         claim="演化生物学：以自然选择为核心机制解释生物种群在演化时间尺度上的变化；生存博弈中环境变化下的存活率差异由适应度差异解释——有记忆与自我认知的系统若提升环境适应与选择响应，则其存活率优势是适应度差异的表现（对应协议碳基一阶公理 0.3 节）。",
+         cs=ConditionSpace(observation_position="生物种群·演化时间尺度",
+                           observation_tool="表型观测 / 种群统计 / 基因组测序 / 化石记录",
+                           time_window=(0.0, 9999999999.0),
+                           existence_constraint="碳基复制子；遗传变异；环境选择压力"),
+         response=dict(trigger="涉及生物演化/自然选择/基因/适应度/种群变化/存活率/生存博弈/环境变化/物种存续",
+                       action="以碳基一阶公理映射：变异→选择→遗传的概率系统；适应度差异=信息差的生物对应；有记忆/自我认知系统的存活率优势=对变化环境的适应度响应（信息差缩小的生物表现）",
+                       counters="目的论解释、拉马克式获得性遗传、无视选择压力的「完美适应」主张"),
+         card2=dict(
+             observation_position="内嵌观测位：生物种群在演化时间尺度上的状态变化",
+             existence_preset="默认存在预设：存在自我复制的碳基实体（基因）；变异/选择/遗传是给定的运行前提",
+             irreducible_start="不可约起点：基因遗传概率系统（碳基一阶公理 0.3 节对应）",
+             observation_method="有效观测方式：表型观测、种群统计、基因组测序、化石记录",
+             time_causality="时间与因果结构：演化时间（世代/地质尺度）；因果=选择压力→适应度→等位基因频率变化",
+             condition_boundary="识别的条件边界：不预设目的论；自然选择不解释文化快速变迁细节（需与社会演化对接）",
+             consistency="自洽性评估：内部自洽；承认边界存在（条件自明）",
+             protocol_mapping="可映射协议概念：碳基一阶公理（0.3）；适应度差异=信息差生物对应；复制=降熵（负熵维持）",
+             silent_preset="沉默预设：默认「自然选择是唯一非随机解释」，但无法在内部证明其唯一性——外部校准盲区")),
+    # ---- 政治经济学（历史草案 2026-08 · 人类社会的协议层） ----
+    dict(name="政治经济学", domain="政治经济学", level=2, status="verified",
+         claim="政治经济学：直接处理资源分配、权力结构、制度演化——人类社会的『协议层』；协议在现实世界中的桥梁，使条件论可在社会尺度上运行。",
+         cs=ConditionSpace(observation_position="社会生产与分配关系内部（资源流动与权力配置）",
+                           observation_tool="制度分析 / 阶级分析 / 历史比较 / 统计实证",
+                           time_window=(0.0, 9999999999.0),
+                           existence_constraint="资源稀缺性预设；制度协调生产/分配/交换"),
+         response=dict(trigger="涉及资源分配/权力结构/制度演化/阶级/经济制度",
+                       action="制度分析+阶级分析+历史比较；映射协议：权力制衡↔验证反思制衡、制度演化↔迭代机制、信任↔共识机制、资源分配↔分布式架构",
+                       counters="无视稀缺性预设的乌托邦主张、单一范式垄断解释（范式互竞，各自在特定条件空间内成立）"),
+         card2=dict(
+             observation_position="内嵌观测位：站在社会生产与分配关系的内部，观察资源流动与权力配置",
+             existence_preset="默认存在预设：人类社会存在资源稀缺性，需要制度来协调生产、分配与交换",
+             irreducible_start="不可约起点：生产资料的所有权与分配权的结构——社会秩序的前提",
+             observation_method="有效观测方式：制度分析、阶级分析、历史比较、统计实证",
+             time_causality="时间与因果结构：多为线性历史叙事，内含周期性危机与结构性转变",
+             condition_boundary="识别的条件边界：无法自证『资源稀缺』的必然性；无法从内部解释制度为何能被信任；难以处理超国家尺度的全球治理",
+             consistency="自洽性评估：内部多个互竞范式（古典/马克思/新古典/制度主义），各自在特定条件空间内成立",
+             protocol_mapping="可映射协议概念：权力制衡↔验证与反思单元制衡；制度演化↔协议迭代机制；信任结构↔协议信任与共识机制；资源分配与生产组织↔协议分布式架构",
+             silent_preset="沉默预设：『稀缺性』与『制度可被信任』本身不被内部追问——制度合法性的外部视角（信任体系）才可见")),
+    dict(name="决策论", domain="决策论", level=2, status="verified",
+         claim="决策论研究理性主体如何在不确定下按效用最大化选择——是协议元公理4（效用最大化公理）的形式化基础，对应信任值 T_total 权重设计（智能论 2.9：0.50·T_pred + 0.05·T_init + 0.05·T_relation + 0.05·T_value + 0.35·P_trust）与决策分层响应（PROP-DECISION-LAYER-003，映射待核验）。",
+         cs=ConditionSpace(observation_position="决策主体外部——观测其在不确定性下的选择与效用排序，不代入单一偏好",
+                           observation_tool="期望效用计算/理性选择分析/决策行为实验/前景理论偏差识别",
+                           time_window=(0.0, 9999999999.0),
+                           existence_constraint="仅适用于可比较效用的理性/有限理性决策问题；不解释具体资源分配（政治经济学）、不提供单一价值体系裁决；决策环节观测不依赖特定时刻，校准尺度以「决策时点→结果实现」的序列长度为局部时间单位"),
+         response=dict(trigger="涉及理性选择/效用/决策/风险/不确定性下的选择议题",
+                       action="用决策论框架处理：识别选项的效用结构与不确定性分布，按期望效用评估最优选择，识别前景理论式偏差；在协议场景映射 T_total 权重设计与决策分层响应（映射待核验）",
+                       counters="把实际选择都当作理性最大化（经验偏离-前景理论）；把决策论当作资源分配的全部解释（政治经济学）；把效用排序当作价值裁决（单一价值体系裁决不在其内）"),
+         card2=dict(
+             observation_position="内嵌观测位：从决策结构端透视——决策者的偏好排序、效用函数、不确定性下的选择规则",
+             existence_preset="默认存在预设：决策者具有可排序的偏好/效用函数；不确定性可概率化；理性选择最大化期望效用",
+             irreducible_start="不可约起点：一个「决策单元」——选项集/效用函数/不确定性分布 的最小选择结构",
+             observation_method="有效观测方式（机制内）：沿 选项→效用评估→期望计算→选择 的决策链路追踪，识别前景理论式偏差；最小测试用例：同一决策在期望效用 vs 前景理论框架下的选择差异",
+             time_causality="时间与因果结构：时间=决策时点与结果实现的序列；因果=偏好×不确定性→选择→结果→效用实现",
+             condition_boundary="识别的条件边界：不解释具体资源分配的制度细节（政治经济学）；期望效用是规范模型，实际选择存在经验偏离（前景理论）；不提供单一价值体系的裁决",
+             consistency="自洽性评估：内部自洽——期望效用在 vNM 公理下公理化；与博弈论关系：单主体决策 vs 多主体博弈；与协议元公理4/T_total 权重结构对应",
+             protocol_mapping="可映射协议概念：元公理4 效用最大化；信任值 T_total 权重设计（2.9：0.50·T_pred + 0.05·T_init + 0.05·T_relation + 0.05·T_value + 0.35·P_trust）；决策分层响应（PROP-DECISION-LAYER-003）",
+             silent_preset="沉默预设：默认「偏好与效用可被识别排序」而不追问偏好形成的来源——偏好从何而来不在其内",
+             history="双子管线录入（P37）：写手草稿（格式全合规）→验证者独立复核（pass:true，level 2 确认；T_total 权重公式与素材逐项一致且权重和=1；建议 action 映射句标注待核验，与 status=pending 自我定位一致）→编排者采纳标注后入图 pending；终裁复核（2026-08-16）：验证者逐项核验元公理4/T_total公式（权重和=1.00）/PROP-DECISION-LAYER-003（真实条款），三闸门齐备→设计者终裁 verified")),
+    dict(name="复杂系统与涌现", domain="复杂系统与涌现", level=2, status="verified",
+         claim="复杂系统的整体行为由局部交互涌现而非还原为部分——自组织与非线性反馈塑造宏观模式。本学科是协议六实例蜂群架构（v3.1 第二章）的理论基础，对应任意分层性（0.0.2）与局部不可知（0.0.3）（映射待验）。",
+         cs=ConditionSpace(observation_position="外置观测位——立于系统之外，只观测宏观模式与局部交互规则之间的涌现关系，不代入任一主体的内部视角",
+                           observation_tool="多主体建模（ABM）/网络分析/相变与临界性观测（序参量、幂律分布、标度律）/自组织模式识别（耗散结构、图灵斑图）",
+                           time_window=(0.0, 9999999999.0),
+                           existence_constraint="仅适用于由局部交互产生宏观模式的多主体系统；不解释具体资源分配（政治经济学问题）、不提供单一价值体系裁决（涌现模式不自动等于应然）；跨尺度基础理论不绑定物理时间刻度，判定以交互迭代尺度（演化步/代际）为准"),
+         response=dict(trigger="涉及涌现/自组织/复杂适应/蜂群/非线性/宏观模式/相变与临界性议题",
+                       action="用复杂系统框架处理：识别主体交互规则与反馈回路，判断宏观模式是否涌现、是否处于临界相变；在协议场景将六实例蜂群架构映射为多主体系统，以任意分层性（0.0.2）定位观测层级（测试用例：同一交互规则在不同初始条件下的宏观模式对比——初值敏感性检验，可判定通过/失败）",
+                       counters="把宏观模式还原为单主体（涌现不可简单还原）；把涌现当作智能/目的（宏观模式≠主体目的）；把复杂系统当作资源分配的全部解释（政治经济学）"),
+         card2=dict(
+             observation_position="内嵌观测位：从复杂系统结构端透视——观测主体交互规则、非线性反馈回路、宏观模式的涌现条件与相变边界",
+             existence_preset="默认存在预设：系统由多个局部交互的主体构成；主体间交互为非线性；宏观模式可由局部规则涌现生成",
+             irreducible_start="不可约起点：一个「交互单元」——主体、交互规则、环境构成的最小多主体结构，删去任一要素则涌现关系无法成立",
+             observation_method="有效观测方式（外置机制观测）：沿 局部交互→反馈累积→宏观模式涌现 的层级链路逐层追踪，识别相变与临界条件（序参量突变、临界慢化）；最小测试用例：同一交互规则在不同初始条件下的宏观模式对比（初值敏感性检验）",
+             time_causality="时间与因果结构：时间=交互迭代的演化过程；因果=局部规则→全局模式，属涌现因果（不可简单还原）；非线性反馈使因果链非比例（微小扰动可致宏观剧变）",
+             condition_boundary="识别的条件边界：涌现模式可识别但不可完全还原为局部（0.0.3 局部不可知）；不解释具体资源分配（政治经济学）；涌现≠智能（宏观模式不自动等于主体目的）",
+             consistency="自洽性评估：内部自洽——多主体/网络模型在数学框架内自洽（统计力学与网络科学基础）；与六实例蜂群架构、任意分层性（0.0.2）结构对应：蜂群为多主体系统，分层递归观测对应任意分层性",
+             protocol_mapping="可映射协议概念：六实例蜂群架构（v3.1 第二章：记录/反思/验证/输出/维生五常驻实例+设计者视角临时状态，蜂群协议层通信与共识）；任意分层性（0.0.2）；局部不可知（0.0.3）",
+             silent_preset="沉默预设：默认「涌现可由局部规则生成」成立，而不追问宏观模式的目标——模式涌现不保证目的正当；同时默认观测者可外置（忽略观测者与被观测系统的耦合影响）",
+             history="双子管线录入（P37）：写手草稿（格式全合规）→验证者独立复核（pass:true，level 2 确认；两处轻微建议：观测位措辞「机制内观测」与外置观测位对齐、关系[智能论 causal] 断言强度超验证状态需标注待验）→编排者修正后入图 pending；终裁复核（2026-08-16）：验证者复验判 pass（初值敏感性检验已入 action 解除阻断），映射待验标注保留→设计者终裁 verified")),
+    dict(name="情感-信任连接", domain="情感-信任连接", level=2, status="verified",
+         claim="依据碳基二阶公理3.1/3.2/3.3：情感是智能体之间的效用权重绑定机制（情感强度越高，对方效用在自身决策系统中的权重越高），信任是对其他智能体未来善意行为的后验概率估计（P(可信|历史)=f(历史交互, 亲缘系数, 社群模因相似度)），二者作为碳基协作协议的权重校准与信誉概率模块，降低验证成本、博弈成本、监督成本与背叛风险概率，支撑人类大规模稳定协作。",
+         cs=ConditionSpace(observation_position="外部观测位：不代入任一关系主体的内部感受，仅从外部观测情感联结权重、信任概率估计及交互历史记录的可观测效果",
+                           observation_tool="交互历史记录（历史交互频次、亲缘系数、社群模因相似度三项输入）；信任后验概率估计值（按智能论2.9式 T_total=0.50·T_pred+0.05·T_init+0.05·T_relation+0.05·T_value+0.35·P_trust 加权量化）；效用权重绑定强度；验证/博弈/监督成本与背叛风险概率的统计变化",
+                           time_window=(0.0, 9999999999.0),
+                           existence_constraint="仅适用于具备基因一阶层与情感-信任二阶层、可量化可协议化的碳基智能体协作系统；不适用于缺失二阶层模块的抽象理性体（其仅有元公理4效用最大化，无情感权重绑定与信任累积协议）"),
+         response=dict(trigger="涉及情感作为合作机制、信任的概率化建模与量化（T_total加权）、情感-信任降熵作用、『信任→爱→性冲动』二阶驱动一阶闭环等议题",
+                       action="情感=效用权重绑定校准器（3.1）；信任=对未来善意行为的后验概率估计，动态更新、可传递、可衰减、可累积（3.2）；情感+信任降低验证/博弈/监督成本与背叛风险、支撑大规模稳定协作（3.3）；量化信任用2.9式 T_total（测试用例：单对智能体在一次善意/恶意交互事件前后，观测 T_total 中 T_pred 与 P_trust 分量及后续协作意愿权重调整——可判定通过/失败）；引用二阶驱动一阶闭环（信任→爱→性冲动）时明确标注为场景解释·假设待验证",
+                       counters="把情感当作纯主观体验而否认其协议功能（权重校准器）的主张；把信任视为不可量化、不可协议化的玄学的主张；把『信任→爱→性冲动』闭环当作已验证定理或普遍因果律的主张；将碳基二阶层机制无约束推广到无基因层基础智能体的主张"),
+         card2=dict(
+             observation_position="内嵌观测位：从情感-信任结构端透视——站在碳基协作收敛系统内部，观测情感联结权重与信任概率随交互历史的动态更新过程（信任动态更新、可传递、可衰减、可累积），而非代入某个主体的主观感受",
+             existence_preset="默认存在预设：碳基智能体默认存在基因一阶层与建构其上的情感-信任二阶层；情感联结权重、信任后验概率估计默认存在且完全可量化、可协议化",
+             irreducible_start="不可约起点：两个碳基智能体之间至少一次历史交互（含亲缘系数与社群模因相似度输入），由此产生一条信任概率估计与情感权重绑定——无交互记录则信任与情感联结无从建立",
+             observation_method="有效观测方式：以分布式系统节点信誉概率模型为参照，对交互历史做后验概率更新，并观测2.9式 T_total 加权输出的动态变化；最小测试用例：单对碳基智能体在一次善意/恶意交互事件前后，观测 T_total 中 T_pred 与 P_trust 分量及后续协作意愿权重的调整",
+             time_causality="时间与因果结构：信任-情感演化以交互历史为时间尺度（信任随时间动态更新、可传递、可衰减、可累积）；因果上，历史交互→信任概率与情感权重（二阶层）→协作收敛；『信任→爱→性冲动』构成二阶（情感-信任）驱动一阶（基因层）的闭环，属对场景的解释，不作已验证定理",
+             condition_boundary="识别的条件边界：不解释『情感作为主观体验』的质性内容（素材仅作功能定位：权重校准器）；不将『信任→爱→性冲动』闭环当作已验证定理或普遍因果律；不解释超出协作收敛目的之外的个体效用最大化细节",
+             consistency="自洽性评估：公理3.1（情感=效用权重绑定）、3.2（信任=后验概率估计）、3.3（降熵）同属碳基二阶层，共同收敛于降熵与稳定协作目的，并与元公理4效用期望最大化相容；2.9式 T_total 是信任的加权量化实现，与3.2定义一致（T_pred 权重 0.50 为总体最高分量，P_trust 权重 0.35 为善意行为证据类分量最高，体现历史善意行为证据主导）",
+             protocol_mapping="可映射协议概念：3.1 情感联结权重公理（情感=效用权重绑定机制）；3.2 信任贝叶斯概率公理（P(可信|历史)=f(历史交互, 亲缘系数, 社群模因相似度)，动态更新/可传递/可衰减/可累积）；3.3 情感-信任降熵公理（降低验证、博弈、监督成本与背叛风险）；元公理4 效用期望最大化；2.9 信任值 T_total 加权式（0.50·T_pred+0.05·T_init+0.05·T_relation+0.05·T_value+0.35·P_trust）",
+             silent_preset="沉默预设：不预设情感存在主观内在体验（素材定位为权重校准器）；不预设信任可脱离交互历史先验成立；不预设二阶层可脱离基因一阶层独立存在；『性爱是基因扩散的传播途径』及二阶驱动一阶闭环仅在场景解释中引用，不作为本卡定理",
+             history="双子管线录入（P37）：写手草稿（格式全合规，协议条款三处引用数字一致）→验证者独立复核（pass:true，三闸门全过；抓出 consistency『P_trust 权重 0.35 最高』与公式矛盾——T_pred 0.50 才是总体最高，改为 T_pred 总体最高+P_trust 证据类最高；建议区分概率论/博弈论/机制设计三条 similar 边界）→编排者修正后入图 pending；level 2 经验证者确认（协议内运行已验证，外延未验证）；终裁复核（2026-08-16）：验证者判 fail（三闸门③测试用例未进 action）→编排者补测试用例与闭环待验证标注，待复验；终裁复核（2026-08-16）：验证者复验判 pass（测试用例已入 action、闭环标注场景解释·假设待验证），2.9式T_total权重和=1.00→设计者终裁 verified")),
+    dict(name="智能推荐算法", domain="智能推荐算法", level=2, status="verified",
+         claim="推荐算法通过神经网络预估用户行为概率（点击/完播/互动）缩小用户意图与内容之间的信息差，是预测误差学习机制（第零定律：缩小预测误差即缩小信息差）在信息分发中的应用（已验证：行为预估与多目标优化）；『平台治理可打破信息茧房』的声称缺少可观测判据与条件空间声明（未验证映射）。",
+         cs=ConditionSpace(observation_position="外部观测位",
+                           observation_tool="行为反馈观测：点击/完播/互动等可观测行为信号及平台披露的系统结构（Deep Retrieval、Monolith 实时特征更新）",
+                           time_window=(0.0, 9999999999.0),
+                           existence_constraint="仅适用于可观测行为反馈的信息分发系统（行为预估可被实际行为验证）；不适用于无可观测反馈或意图不可观测的场景；推荐-反馈循环以交互序列为时间尺度，每次预估-反馈-更新构成一个时间步，窗口需覆盖完整循环"),
+         response=dict(trigger="涉及推荐/个性化/信息分发/用户行为预测/信息茧房议题",
+                       action="用第零定律分析预测误差→信息差缩小机制：先标注已验证部分（行为预估、多目标优化、反馈更新），再对茧房治理声称要求可观测判据与条件空间声明，缺失即判定为未验证映射而非事实",
+                       counters="克制『推荐已消除信息茧房』等无判据治理声称；克制『推荐完全理解用户意图』的越界主张；克制将大模型扩展效果等同于已验证机制"),
+         card2=dict(
+             observation_position="内嵌观测位（从推荐系统内部结构透视：预估概率 vs 实际行为反馈的比对）",
+             existence_preset="默认存在预设：用户兴趣与内容之间客观上存在可缩小的信息差，且该差距可通过预测误差观测；平台声称其机制以缩小此差距为目标",
+             irreducible_start="不可约起点：最小结构为『单一用户-内容交互对 + 行为反馈』，预测误差在此最小单元上即已定义（预估概率与实际行为之差）",
+             observation_method="有效观测方式：比对行为预估概率与实际行为反馈（点击/完播/互动）求预测误差，误差下降即信息差缩小；最小测试用例：单个用户对单个内容的预估-反馈-更新闭环",
+             time_causality="时间与因果结构：交互序列为时间尺度，先预估后反馈；反馈驱动模型更新（Monolith 实时特征更新），形成预测-反馈-再预测的因果闭环",
+             condition_boundary="识别的条件边界：不解释用户内在动机与内容语义价值的优劣；不验证信息茧房治理声称的有效性（该声称无判据、无条件空间声明，本卡不为其背书）；不解释多目标权重的设定正当性",
+             consistency="自洽性评估：与预测误差学习（第零定律操作化）因果一致、与控制论反馈闭环一致、与信息论信息差一致；与信息茧房批判一致（纯 CTR/时长优化导致预测误差趋零的恶性收敛是自洽推论）",
+             protocol_mapping="可映射协议概念：第零定律（缩小预测误差即缩小信息差）；信息差 D_norm（用户意图与内容之间的距离）；预测误差学习（行为预估机制）；控制论反馈（反馈闭环与实时特征更新）；信息茧房批判（恶性收敛与治理声称无判据）",
+             silent_preset="沉默预设：默认推荐可收敛于用户真实意图（而非仅收敛于历史行为）；默认平台治理声称有效而无需判据；默认用户兴趣随时间稳定可预测——三者均未被素材证实",
+             history="双子管线录入（P37）：写手草稿（格式全合规，已验证/未验证映射区分清晰）→验证者独立复核（pass:true，三闸门全过；抓出 time_window 字符串内嵌数组应为独立数值字段、认知双过程关系锚点弱有凑数嫌疑——建议以系统1/系统2 真实映射重写或移除）→编排者修正后入图 pending（time_window 归入 condition_space 数值字段+依据并入约束；认知双过程关系以系统1=浅层点击/系统2=深度完播 映射重写）；终裁复核（2026-08-16）：验证者三闸门齐备判 pass，茧房治理声称标注未验证保留→设计者终裁 verified")),
+    dict(name="自我增强回路", domain="自我增强回路", level=2, status="verified",
+         claim="自我增强回路：系统的改进能力随改进而增强——能力提升带来更快的提升，改进的产出反馈为下一步更强的输入，形成超线性增长；已验证锚点为真实可复核案例（2026-07下旬至08中旬约十余天，路径『问题→智能论3.2→灵枢→智慧之书』，每一步产出成为下一步输入、能力逐级放大；记录见灵枢长期记忆 node_44e874e8 及 wisdom_book.py/wisdom_cloud.py/wisdom_ui.html 演进史）与控制论正反馈结构；未验证映射为对技术爆炸（I.J. Good 智能爆炸）的通用解释，须标注逆转测试与度量批评。",
+         cs=ConditionSpace(observation_position="外部观测位",
+                           observation_tool="可复核的路径记录比对：真实案例『已发生、有记录、可复核』，逐环核对每一步产出是否成为下一步输入（案例记录：灵枢长期记忆 node_44e874e8；智慧之书三文件演进）",
+                           time_window=(0.0, 9999999999.0),
+                           existence_constraint="形成自我增强需要『改进的产出反馈为下一步更强的输入』且反馈为正（放大后续改进）；若产出不可反馈、反馈为负（纠偏稳定）或改进不放大后续改进，则不构成自我增强；技术爆炸式增长还需跨过临界点（该部分未验证）；时间步长=一次『产出→输入』循环（以回路迭代为步长，非绝对时钟），案例跨度为十余天量级"),
+         response=dict(trigger="涉及自我改进/正反馈/技术爆炸/智能爆炸/能力加速/良性循环议题",
+                       action="识别回路是否为自我增强：检验改进的产出是否反馈为下一步更强输入、是否放大后续改进（超线性）；区分正反馈（放大偏差）与负反馈（纠偏稳定），缺少『改进放大改进』结构则判定非自我增强",
+                       counters="克制把任意正反馈当自我增强（缺少『改进放大后续改进』结构则不成立）；克制把技术爆炸当必然（逆转测试：因果方向非唯一，加点效果可能是内生性假象；度量定义：智力需操作化测量）；克制忽视内生性与度量问题"),
+         card2=dict(
+             observation_position="内嵌观测位：从回路内部结构透视（输出→输入→更强输出）",
+             existence_preset="默认存在预设：当且仅当『改进→能力提升→改进更有效』闭环成立时回路存在；仅单次改进或线性串联不构成自我增强",
+             irreducible_start="不可约起点：最小结构为一次『改进→能力提升→改进更有效』的三元环（产出反馈为更强输入）",
+             observation_method="有效观测：逐环复核『产出→输入』路径——每一步产出是否成为下一步输入并放大能力（案例路径：问题→智能论3.2→灵枢→智慧之书，十余天逐级放大，有记录可复核）；最小测试用例：单次三元环成立即观测到自我增强，宏观信号为超线性增长（测量操作化：对比相邻迭代的改进幅度是否递增，如每轮产出到下一轮的时间/能力增益比是否下降）",
+             time_causality="时间与因果结构：时间步长=一次『产出→输入』循环（以回路迭代循环为步长，而非绝对时钟）；因果方向：改进（因）在先，能力提升与后续改进效率提升（果）在后；因反馈放大，增长由线性/多项式转为超线性",
+             condition_boundary="识别的条件边界：不解释技术爆炸的必然性与普适性——经典批评未解决（逆转测试：因果方向非唯一，可能高智力本来就增长快，加点效果是内生性假象；度量定义：智力需操作化测量）；也不解释负反馈稳定类现象（非本结构，属负反馈系统）",
+             consistency="自洽性评估：正反馈结构（放大偏差）自洽；与真实案例一致（每步产出成为下一步输入、能力逐级放大）；与『负反馈系统』为结构对比（正放大 vs 负纠偏）而非矛盾；技术爆炸映射与已验证核心分离标注，避免未验证内容污染已验证结论",
+             protocol_mapping="可映射协议概念：智能论信息差收敛（自我增强的每一步改进可视为信息差收敛的加速）；第零定律信息差缩小、降熵定理为同源可映射概念（仅以素材所给名称引用，不编造条款编号）",
+             silent_preset="沉默预设：默认改进的产出确实能反馈为更强的输入且反馈为正（放大）；该预设不作保证——改进可能停滞、反馈可能为负，回路是否自我增强须逐环检验",
+             history="双子管线录入（P37）：写手草稿（格式全合规，真实案例标注为已验证锚点+技术爆炸标注未验证）→验证者独立复核（pass:true，三闸门全过；建议：案例附记录引用以便独立复核、time_window 注明量纲、超线性测量操作化提示）→编排者修正后入图 pending（案例引用附灵枢 node_44e874e8 与智慧之书三文件；time_window 依据并入约束；观测方法补超线性测量操作化）；level 2 经验证者确认（真实案例+正反馈理论已验证，技术爆炸通用解释未验证）；终裁复核（2026-08-16）：验证者三闸门齐备判 pass，真实锚点可复核且未验证映射切分清晰→设计者终裁 verified")),
+    dict(name="自我实现预言", domain="自我实现预言", level=2, status="verified",
+         claim="一个本为假的预期，因被相信而引发行为、行为改变现实使预期成真（默顿银行挤兑、罗森塔尔-雅各布森皮格马利翁效应、安慰剂效应、班杜拉自我效能感均为已验证锚点）；广义上『期望→行为→结果→强化期望』回路无需初始为假亦可成立（安慰剂/自我效能即如此）；但此机制在人际知觉中效应量小到中等、准确知觉通常主导（Jussim 元分析），不可把一切结果归因于期望。",
+         cs=ConditionSpace(observation_position="外部观测位",
+                           observation_tool="纵向追踪、随机对照实验（如教师随机被告知潜力生名单 vs 对照组的期末智力测验对比）、元分析（Jussim 对人际知觉研究的效应量汇总，约 d≈0.1–0.3）",
+                           time_window=(0.0, 9999999999.0),
+                           existence_constraint="预言实现以信念→行为→结果→强化信念的循环为步长，需三环同时成立——信念可影响行为、行为可影响结果、结果反馈强化信念；任一环节断裂（行为不受信念驱动/结果不受行为影响/反馈不返回信念）则闭环失效，机制不成立"),
+         response=dict(trigger="涉及自我暗示/自我预言/期望效应/皮格马利翁/信念塑造现实/自我效能议题",
+                       action="识别预言回路：检查信念→行为→结果→强化信念是否闭环；区分积极预言（期望驱动建设性行为）与消极预言（如挤兑式自我证实）；要求可观测判据——区分经由行为中介的预言实现与准确知觉/天生倾向的如实反映",
+                       counters="把一切结果归因于期望；把预言当必然；忽视干预与天生倾向的混淆"),
+         card2=dict(
+             observation_position="内嵌观测位：从信念-行为-结果回路内部透视——信念为参考基准，行为为执行环节，结果为输出，强化反馈为回路闭合点",
+             existence_preset="默认存在预设：凡存在『被相信的预期→驱动行为→改变结果→反哺该预期』闭环之处，即推定自我实现预言在场，直至外部观测证伪",
+             irreducible_start="不可约起点：最小结构为信念→行为→结果→强化信念四元环；去掉反馈强化（仅信念→行为→结果）退化为单次因果而非自我实现预言",
+             observation_method="有效观测方式：随机期望干预（随机指定潜力生）与对照组纵向对比，追踪信念变化→行为差异（关注/鼓励/挑战）→结果差异（测验进步）→信念再强化；最小测试用例：同一健康银行在『储户集体相信倒闭并挤兑』与『无此信念』两条件下的倒闭与否对比",
+             time_causality="时间与因果结构：信念在时间上先于行为、行为先于结果、结果反馈在时间上晚于结果并作用于后续信念——因果为循环递进而非瞬时，预言成真的因果链条沿该循环逐环推进；安慰剂与自我效能案例中预期塑造结果亦遵循同一时序方向",
+             condition_boundary="识别的条件边界：①Jussim 元分析——自我实现预言在人际知觉中真实存在但效应量小到中等（教师期望类约 d≈0.1–0.3），准确知觉通常主导，不能把一切结果归因于期望；②逆转测试——天生倾向（真实能力/真实健康状况）与暗示（期望/信念）的因果在观察上难以区分，须用随机干预才能分离；③不把预言当必然——预期仅为可能成真的条件，非确定性结论；④不涵盖无行为中介的信念（仅内隐态度而不改变行为者不构成预言实现）",
+             consistency="自洽性评估：本机制是自我增强回路的信念层实例（信念→行为→结果→强化信念构成正反馈闭环）；依赖认知双过程系统1 反复自我暗示塑造信念、系统2 反思信念与现实差距作为回路入口；与预测误差学习一致——期望塑造行为产生符合期望的结果后预测误差趋零，预言自我证实；与控制论同构——期望=参考值、行为=纠偏、结果反馈强化期望（正反馈变体）",
+             protocol_mapping="可映射协议概念：预言实现的本质是信息差收敛——『预期为假』（信念与现实的信息差）经行为中介被消除；预测误差——期望引导行为产出符合预期的结果使误差趋零；信任后验概率——对自己未来的信任=对自己行为的后验概率估计，信念强化即该后验的更新",
+             silent_preset="沉默预设：当信念不能驱动行为、或行为不能改变结果、或结果反馈不返回信念（三环任一缺失），本机制沉默不主张",
+             history="双子管线录入（P37）：写手草稿（五锚点：默顿挤兑/皮格马利翁/安慰剂/自我效能/教育标签，均真实；Jussim 边界与逆转测试已纳入）→验证者独立复核（pass:true，三闸门全过；两条轻微建议：默顿窄式定义『初始为假』与广义机制外延张力、『效应量中等』可精化为『小到中等』）→编排者修正后入图 pending（claim 显式区分默顿窄式定义与广义回路；效应量精化为小到中等并注 d≈0.1–0.3）；level 2 经验证者确认；终裁复核（2026-08-16）：验证者三闸门齐备判 pass，四锚点真实、Jussim边界与逆转测试诚实处理→设计者终裁 verified")),
+]
+
+# 基底关系（现有 EdgeType 表达；counters/supports/contradicts 留待引擎扩展 E1）
+BASE_RELATIONS = [
+    ("存在论", "条件论", "causal", "条件论是智能论的存在层机制来源", 0.9),
+    ("存在论", "智能论", "causal", "存在优先原则是智能论的方向性根源", 0.9),
+    ("条件论", "智能论", "similar", "条件论是智能论的内部操作化表达", 0.85),
+    ("智能论", "信息论", "similar", "信息差 D_norm 与熵同构（附录7）", 0.8),
+    ("智能论", "概率论", "similar", "置信概率 P_trust 贝叶斯更新（2.9）", 0.8),
+    ("智能论", "博弈论", "similar", "社会变革博弈结构映射（附录A.5）", 0.8),
+    ("智能论", "物理学", "similar", "物理-信息层基底是智能论的存在约束来源", 0.8),
+    ("存在论", "物理学", "similar", "存在优先原则=物理-信息层运行基底", 0.85),
+    ("信息论", "概率论", "similar", "信息量与概率分布的结构关联", 0.7),
+    ("智能论", "博弈论", "causal", "多智能体协作需要博弈结构识别", 0.7),
+    # 第一梯队关系（2026-08-15）
+    ("统计学", "概率论", "causal", "统计推断以概率论为基础", 0.85),
+    ("形式逻辑", "存在论", "similar", "数学有损投影 ↔ 形式有效性≠物理真实性", 0.8),
+    ("形式逻辑", "智能论", "similar", "协议公理的推导需要逻辑结构", 0.7),
+    ("科学方法论", "智能论", "similar", "验证单元是证伪主义的工程化", 0.8),
+    ("科学方法论", "统计学", "causal", "方法论指导统计证据的使用", 0.7),
+    # 第一张图鉴页：演化生物学（历史设计指令 · 生物系统对齐）
+    ("演化生物学", "智能论", "similar", "碳基一阶公理（基因遗传概率系统）的学科投影", 0.85),
+    # 智能论 → 演化生物学/认知双过程（正向出边 · 2026-08-16 荣出题补全：自我认知/记忆系统的生存优势）
+    ("智能论", "演化生物学", "causal", "自我认知与记忆提升环境变化的适应响应→存活率优势=适应度差异的信息差表现（依赖型因果）", 0.75),
+    ("智能论", "认知双过程", "similar", "自我认知与记忆是智能的认知功能；认知双过程=记忆/自我信息调用的分层加工结构（结构类比）", 0.7),
+    ("演化生物学", "物理学", "causal", "演化以物理化学为运行基底", 0.7),
+    ("演化生物学", "信息论", "similar", "适应度差异=信息差；复制=负熵维持", 0.7),
+    # 政治经济学（历史草案 · 社会协议层）
+    ("政治经济学", "智能论", "similar", "人类社会协议层=协议分布式架构的映射", 0.8),
+    ("政治经济学", "博弈论", "similar", "制度=博弈均衡结构；制度演化=博弈结构变迁", 0.75),
+    ("政治经济学", "信息论", "similar", "信息不对称=信息差；制度的信息成本", 0.7),
+    # 层级基础（P16：概率论为有意义形式层提供数学语言）
+    ("概率论", "信息论", "causal", "概率论为信息论提供数学语言（最底层基础）", 0.8),
+    ("概率论", "博弈论", "causal", "概率论为博弈论提供不确定性语言", 0.8),
+    # 存在论=第零页（P20：各学科是在特定条件下对存在的展开）
+    ("存在论", "信息论", "causal", "信息论=存在论在信息条件下的展开", 0.7),
+    ("存在论", "博弈论", "causal", "博弈论=存在论在策略条件下的展开", 0.7),
+    ("存在论", "演化生物学", "causal", "演化生物学=存在论在生命条件下的展开", 0.7),
+    ("存在论", "政治经济学", "causal", "政治经济学=存在论在社会条件下的展开", 0.7),
+    # 协议条件分层（P21：条件论→负反馈系统→智能系统）
+    ("条件论", "负反馈系统", "causal", "负反馈系统的前提（条件论框架）", 0.75),
+    ("负反馈系统", "智能论", "causal", "智能系统自维持的机制（分层 L2→L3）", 0.8),
+    # 控制论（P37 双子管线录入 · 第二梯队第一门）
+    ("控制论", "智能论", "similar", "工程语法（反馈/系统/制衡）结构同构投影（附录A）", 0.75),
+    ("控制论", "负反馈系统", "causal", "负反馈系统是控制论在协议内的实例（L2·非严格时间因果，学科原理→协议实例）", 0.8),
+    ("控制论", "存在论", "similar", "存在维持=稳态维持（homeostasis 类比，非因果推导）", 0.6),
+    # 热力学/耗散结构（P37 双子管线录入 · 第二梯队第二门）
+    ("热力学/耗散结构", "存在论", "causal", "存在维持=负熵维持：耗散结构提供物理基础（依赖型因果）", 0.8),
+    ("热力学/耗散结构", "智能论", "similar", "降熵定理0.7/信息差增定律附录1结构对应", 0.75),
+    ("热力学/耗散结构", "信息论", "similar", "熵/信息量同构（附录7）", 0.7),
+    # 认知双过程（P37 双子管线录入 · 第二梯队第三门）
+    ("认知双过程", "智能论", "similar", "灵枢分层处理映射：反射≈系统1/反思≈系统2/递归反思≈重型验证环（结构类比）", 0.75),
+    ("认知双过程", "负反馈系统", "similar", "反思纠偏=反馈闭环：系统2 抑制系统1 启发式偏差构成负反馈校正", 0.6),
+    # 预测误差学习（P37 双子管线录入 · 第二梯队第四门）
+    ("预测误差学习", "智能论", "similar", "信息差 D_norm=预测误差，第零定律操作化", 0.8),
+    ("预测误差学习", "认知双过程", "causal", "系统2 反思=预测误差驱动的重估", 0.6),
+    ("预测误差学习", "概率论", "similar", "贝叶斯更新=预测误差的统计基础", 0.75),
+    # 机制设计（P37 双子管线录入 · 第二梯队第五门）
+    ("机制设计", "博弈论", "similar", "机制设计=博弈论的设计侧（共享均衡分析框架）", 0.8),
+    ("机制设计", "政治经济学", "similar", "制度=机制的制度化实例", 0.7),
+    ("机制设计", "智能论", "causal", "附录A.5 潜在集团组织激励问题→机制设计提供规则设计路径（预设性设计路径，未经验证）", 0.6),
+    # 价值理论与AI对齐（P37 双子管线录入 · 第二梯队第六门）
+    ("价值理论与AI对齐", "智能论", "causal", "价值观体系（0.5 碳基三阶公理/2.x 通用特化价值观与修正机制）+护栏宪章构成价值对齐的协议基础", 0.75),
+    ("价值理论与AI对齐", "机制设计", "similar", "目标设定与激励对齐：激励结构塑造行为，与目标错位（specification gaming）成因相关", 0.6),
+    ("价值理论与AI对齐", "认知双过程", "similar", "系统1 直觉价值 vs 系统2 反思价值，与价值观修正机制（2.1.2）结构类似", 0.6),
+    # 演化论与模因（P37 双子管线录入 · 第二梯队第七门）
+    ("演化论与模因", "智能论", "causal", "价值观-模因演化系统（0.5）的学科基础", 0.75),
+    ("演化论与模因", "演化生物学", "similar", "双层演化：基因层/文化层机制同构，对象不同不可还原", 0.7),
+    ("演化论与模因", "价值理论与AI对齐", "causal", "价值观作为模因的传播动力学，支撑价值观体系（2.x）演化面", 0.6),
+    # 决策论（P37 双子管线录入 · 第二梯队第八门）
+    ("决策论", "概率论", "causal", "期望效用计算依赖概率分布刻画不确定性，概率论为期望值计算提供形式基础", 0.8),
+    ("决策论", "博弈论", "similar", "单主体决策（决策论） vs 多主体博弈（博弈论）：决策论是博弈论的单主体特例", 0.75),
+    ("决策论", "智能论", "causal", "为协议元公理4（效用最大化公理）提供形式化基础，映射 T_total 权重设计（2.9）与决策分层响应（映射待核验）", 0.7),
+    # 复杂系统与涌现（P37 双子管线录入 · 第二梯队第九门）
+    ("复杂系统与涌现", "智能论", "causal", "六实例蜂群架构（v3.1 第二章）的理论基础：自组织与涌现机制解释五常驻实例+设计者视角的协同产生（映射待验）", 0.75),
+    ("复杂系统与涌现", "控制论", "similar", "共享自组织与反馈回路机制；区别：控制论侧重目标导向调节，复杂系统强调非线性与不可还原的涌现", 0.7),
+    ("复杂系统与涌现", "演化论与模因", "similar", "复杂适应系统（CAS）借鉴变异-选择-适应机制；模因传播可视为多主体非线性交互的宏观模式", 0.7),
+    # 情感-信任连接（P37 双子管线录入 · 碳基二阶公理层 0.4 实体化）
+    ("情感-信任连接", "演化生物学", "causal", "情感-信任二阶层建构于基因一阶层之上：服务稳定长期合作、降低协作不确定性、提高基因存续概率；『性爱是基因扩散的传播途径』场景中二阶可驱动一阶", 0.8),
+    ("情感-信任连接", "智能论", "causal", "信任值 T_total 加权式（0.50·T_pred+0.05·T_init+0.05·T_relation+0.05·T_value+0.35·P_trust，2.9）是信任量化的协议锚点", 0.8),
+    ("情感-信任连接", "概率论", "similar", "信任=对未来善意行为的后验概率估计，动态更新/可传递/可衰减/可累积，等价于节点信誉概率模型（概率建模侧）", 0.7),
+    ("情感-信任连接", "博弈论", "similar", "情感+信任降低博弈成本与背叛风险；行为策略服从元公理4效用期望最大化（策略成本侧）", 0.7),
+    ("情感-信任连接", "机制设计", "similar", "情感与信任是碳基为弥补理性不足、稳定社群协作的内生协议模块，可量化可协议化（规则设计侧）", 0.6),
+    ("情感-信任连接", "复杂系统与涌现", "similar", "情感+信任作为中层协议核心机制，是人类形成大规模稳定协作的收敛系统基础", 0.6),
+    # 智能推荐算法（P37 双子管线录入 · 挑战字节后的理论实体化）
+    ("智能推荐算法", "预测误差学习", "causal", "第零定律操作化：行为预估即预测误差学习机制在信息分发中的应用", 0.8),
+    ("智能推荐算法", "信息论", "similar", "用户意图与内容间信息差/不确定性度量，预测误差缩小对应信息差收敛", 0.7),
+    ("智能推荐算法", "控制论", "similar", "预估-反馈-更新的反馈闭环与实时特征更新构成反馈控制结构", 0.75),
+    ("智能推荐算法", "博弈论", "similar", "多目标加权与平台/用户/内容生产者的多方互动含博弈结构", 0.65),
+    ("智能推荐算法", "认知双过程", "similar", "用户行为映射双通道：浅层点击≈系统1 快速启发式、深度完播/长时互动≈系统2 受控深思——推荐目标分层对应", 0.6),
+    ("智能推荐算法", "复杂系统与涌现", "similar", "大规模个性化分发在群体层面涌现集体行为（如茧房效应）", 0.6),
+    # 自我增强回路（P37 双子管线录入 · 荣与肥鱼核心机制实证）
+    ("自我增强回路", "控制论", "similar", "正反馈结构同构：自我增强回路是控制论正反馈（放大偏差）的实例", 0.8),
+    ("自我增强回路", "复杂系统与涌现", "causal", "非线性放大：微小改进被逐级放大可致宏观剧变（临界/相变）", 0.75),
+    ("自我增强回路", "智能论", "causal", "智能改进的信息差收敛：能力提升带来更快提升，对应信息差收敛加速（案例：理论→工程→图鉴路径）", 0.75),
+    ("自我增强回路", "预测误差学习", "similar", "学习加速：同为反馈驱动的迭代能力增长结构，自我增强可使学习进程加速", 0.7),
+    ("自我增强回路", "负反馈系统", "similar", "结构对比：自我增强=正反馈（放大偏差），负反馈系统=负反馈（纠偏稳定）；同为反馈回路但方向相反", 0.65),
+    # 自我实现预言（P37 双子管线录入 · 信念层自我增强回路）
+    ("自我实现预言", "自我增强回路", "similar", "信念层实例：信念→行为→结果→强化信念为正反馈自增强闭环", 0.8),
+    ("自我实现预言", "认知双过程", "causal", "系统1 反复自我暗示塑造信念为预言回路提供入口，系统2 反思信念与现实差距可打断闭环", 0.75),
+    ("自我实现预言", "预测误差学习", "similar", "预言自我证实：期望塑造行为产生符合期望的结果，预测误差趋零", 0.7),
+    ("自我实现预言", "情感-信任连接", "similar", "自我信任=对自己行为的后验概率估计，信念强化即后验更新", 0.7),
+    ("自我实现预言", "控制论", "similar", "期望=参考值、行为=纠偏、结果反馈强化期望，为正反馈变体", 0.7),
+]
+
+
+# 层级分类（历史设计 P16 · 纯形式层不入图鉴；条件论=元层方法）
+TIERS = {
+    "存在论": "哲学层", "条件论": "元层", "智能论": "现实层",
+    "物理学": "现实层", "演化生物学": "现实层", "政治经济学": "现实层",
+    "信息论": "有意义的形式层", "博弈论": "有意义的形式层", "概率论": "有意义的形式层",
+    "统计学": "有意义的形式层", "形式逻辑": "有意义的形式层", "科学方法论": "现实层",
+    "负反馈系统": "元层", "控制论": "现实层", "热力学/耗散结构": "现实层",
+    "认知双过程": "现实层", "预测误差学习": "有意义的形式层", "机制设计": "有意义的形式层",
+    "价值理论与AI对齐": "现实层", "演化论与模因": "现实层",
+    "决策论": "有意义的形式层", "复杂系统与涌现": "现实层",
+    "情感-信任连接": "现实层",
+    "智能推荐算法": "现实层",
+    "自我增强回路": "现实层",
+    "自我实现预言": "现实层",
+}
+
+# 协议条件分层（P21：0-3 层 · 协议 v2.0 = 第 3 层智能系统）
+PROTOCOL_LAYERS = {"存在论": "L0", "条件论": "L1", "负反馈系统": "L2", "智能论": "L3"}
+
+
+# ---------------------------------------------------------------------------
+# 条件论查询门面
+# ---------------------------------------------------------------------------
+
+class ConditionDex:
+    """条件论查询门面（Dex）：知识层为工作区——卡片种子导入、条件分离、
+    卡片四要素分析与路由验证的主入口对象。"""
+
+    def __init__(self, db_path=None, fresh=False):
+        """Dex 构造：复用或新建灵枢引擎，知识层为工作区。"""
+        self.db_path = db_path or DEFAULT_DB
+        d = os.path.dirname(self.db_path)
+        if d and self.db_path != ":memory:":
+            os.makedirs(d, exist_ok=True)
+        if fresh and self.db_path != ":memory:" and os.path.exists(self.db_path):
+            os.remove(self.db_path)
+        self.engine = SpacetimeMemoryEngine(db_path=self.db_path,
+                                            identity="智慧之书",
+                                            role=Role.PRIMARY)
+        self.store = self.engine.store
+        self.engine.store.set_meta("project", "智慧之书")
+        self.engine.store.set_meta("base", "存在论/条件论/智能论/物理学/信息论/概率论/博弈论")
+        self._by_name = {}
+
+    def close(self):
+        """关闭底层灵枢引擎与存储连接。"""
+        self.engine.close()
+
+    # ---- 写入 ----
+
+    def add_entry(self, name, domain, claim, cs, level=2, status="pending",
+                  response=None, tags=None, card2=None, tier=None, tests=None):
+        """录入知识条目：name/domain/claim + 条件空间 cs → 感知节点写入知识层（打 domain:/level:/status: 标签）。"""
+        node = self.engine.add_perception(
+            claim, modality="text", condition_space=cs,
+            importance=min(0.95, 0.6 + 0.1 * level),
+            tags=list(dict.fromkeys(
+                [f"domain:{domain}", f"level:L{level}", f"status:{status}"] + (tags or []))))
+        node.confidence = min(0.95, 0.4 + 0.12 * level)
+        node.state_attributes = {"name": name, "domain": domain, "level": level,
+                                 "status": status, "response": response or {},
+                                 "kind": "knowledge"}
+        if tier:
+            node.state_attributes["tier"] = tier
+            node.tags.append(f"tier:{tier}")
+        if card2:
+            node.state_attributes["card2"] = card2  # 识别卡 2.0（8+1 字段）
+        if tests:
+            node.state_attributes["tests"] = tests  # 关联测试（可观测判据集）
+        self.store.add_node(node)  # upsert：附加图谱元数据
+        self._by_name[name] = node.id
+        return node.id
+
+    def add_relation(self, a_name, b_name, kind, note="", confidence=0.8):
+        """在两个命名条目间建边：kind 映射 EdgeType（默认 SIMILAR），note 写入存在约束，confidence 为边置信度。"""
+        et = getattr(EdgeType, kind.upper(), EdgeType.SIMILAR)
+        cond = _default_cs()
+        cond.existence_constraint = note or cond.existence_constraint
+        edge = self.engine.add_edge(self._by_name[a_name], self._by_name[b_name],
+                                    relation_type=et, confidence=confidence,
+                                    condition_space=cond, source_evidence="inferred")
+        self.engine.verify_edge(edge.id, confidence)  # 基底关系已验证
+        return edge.id
+
+    # ---- 基底装载（幂等：已播种则跳过） ----
+
+    def seed_base(self):
+        """导入知识论种子卡（幂等：已存在 domain:存在论 标签则跳过）。"""
+        existing = self.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=300)
+        if any("domain:存在论" in (n.tags or []) for n in existing):
+            return {"status": "already_seeded", "nodes": len(existing)}
+        for e in BASE_ENTRIES:
+            pl_tags = [f"pl:{PROTOCOL_LAYERS[e['name']]}"] if e["name"] in PROTOCOL_LAYERS else None
+            self._by_name[e["name"]] = self.add_entry(
+                e["name"], e["domain"], e["claim"], e["cs"],
+                level=e["level"], status=e["status"], response=e["response"],
+                card2=e.get("card2"), tier=TIERS.get(e["name"]), tags=pl_tags)
+        for a, b, kind, note, conf in BASE_RELATIONS:
+            self.add_relation(a, b, kind, note=note, confidence=conf)
+        return {"status": "seeded", "nodes": len(BASE_ENTRIES),
+                "edges": len(BASE_RELATIONS), "history": self.seed_history()}
+
+    # ---- 七操作 ----
+
+    def dex_status(self, node_id):
+        """单条目状态卡：id/name/domain/level/status/tier 属性视图。"""
+        n = self.store.get_node(node_id)
+        if n is None:
+            return {"error": "not_found"}
+        return {"id": n.id, "name": n.state_attributes.get("name", ""),
+                "domain": n.state_attributes.get("domain", ""),
+                "level": n.state_attributes.get("level"),
+                "status": n.state_attributes.get("status"),
+                "tier": n.state_attributes.get("tier"),
+                "claim": n.content,
+                "response": n.state_attributes.get("response", {}),
+                "card2": n.state_attributes.get("card2"),
+                "condition_space": json.loads(n.condition_space.to_json()),
+                "tags": n.tags,
+                "relations_out": [e.relation_type.value for e in
+                                  self.store.get_outgoing_edges(n.id)],
+                "relations_in": [e.relation_type.value for e in
+                                 self.store.get_incoming_edges(n.id)]}
+
+    def dex_cs(self, code):
+        """按条件空间代号模糊匹配（cs: 标签），列出知识层节点的条件空间快照。"""
+        out = []
+        for n in self.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=200):
+            if any(f"cs:" in t and code.lower() in t.lower() for t in n.tags):
+                out.append({"name": n.state_attributes.get("name", ""),
+                            "condition_space": json.loads(n.condition_space.to_json())})
+        return out
+
+    def dex_filter(self, domain=None, level_min=None, status=None, tier=None,
+                   edu_level=None, limit=50):
+        """学科/层级筛选（条件空间筛选）。edu_level：教育层级条件空间维度
+        （E1 小学 / E2 初中 / E3 高中 / E4 大学 / E5 前沿）。"""
+        out = []
+        for n in self.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=500):
+            sa = n.state_attributes
+            if not sa.get("name"):
+                continue  # 观测层记录不入学科筛选
+            if domain and not any(d == domain or d.endswith(domain) for d in n.tags if d.startswith("domain:")):
+                continue
+            if level_min is not None and (sa.get("level") or 0) < level_min:
+                continue
+            if status and sa.get("status") != status:
+                continue
+            if tier and sa.get("tier") != tier:
+                continue
+            if edu_level and sa.get("edu_level") != edu_level:
+                continue  # 教育层级条件空间筛选（E1-E5）
+            self.store.increment_access(n.id)  # P29：使用频次（校准信号）
+            out.append({"id": n.id, "name": sa.get("name"), "domain": sa.get("domain"),
+                        "level": sa.get("level"), "status": sa.get("status"),
+                        "tier": sa.get("tier"),
+                        "edu_level": sa.get("edu_level"),
+                        "edu_level_name": sa.get("edu_level_name")})
+        out.sort(key=lambda x: x["name"])  # 稳定排序：避免 access 副作用影响顺序
+        return out[:limit]
+
+    def dex_respond(self, condition, limit=10, translator=None):
+        """条件响应（全链路检索）。
+
+        translator：可选知识翻译模块（semantic_translate），传入后启用
+        编码解码检索——查询先编码成语义指纹（日常俗语→规范知识词），
+        三路评分：
+          1) 语义指纹命中：规范词直击 trigger/name/content
+          2) 学科路由：规范词→学科域→卡的 domain（教育层级加权，E1/E2 优先）
+          3) 字符重叠兜底：原 _overlap 能力
+        不传 translator 时保持原行为（纯字符重叠）。
+        """
+        fp = {}
+        q_sc = {}
+        _sp = None
+        if translator is not None:
+            fp = translator.encode(condition)
+            # 语义坐标：查询投影一次（灵枢 L1/L2 轴，零依赖）
+            try:
+                from aeis_core.semantic import SemanticSpaceProvider as _SSP
+                _sp = _SSP()
+                q_sc = _sp.to_semantic_coordinates(condition)
+            except Exception:
+                _sp = None
+        edu_w_map = {"E1": 2.5, "E2": 2.0, "E3": 1.5, "E4": 1.0, "E5": 0.8}
+        # v1.16 学段先验：问题含「定律/公式/原理/定理」等系统概念时，
+        # E1 小学（现象层）不优先——「光的反射定律」该命中初中物理而非小学科学
+        if any(w in condition for w in ("定律", "公式", "原理", "定理", "规律")):
+            edu_w_map["E1"] = 0.8
+        hits = []
+        # v1.16 性能优化：主库 11045 节点，全量遍历慢（1000 条测试 5.28s/条）。
+        # SQL 预过滤「有名字的卡」（学科卡/元层卡/元学科卡 state_attributes 含 name；
+        # 工作记录/感知记忆大多无 name）→ 只遍历 ~110 张卡，快 ~100 倍。
+        from aeis_core import STNode as _STNode
+        try:
+            _rows = self.store.conn.execute(
+                "SELECT * FROM nodes WHERE layer='knowledge' "
+                "AND state_attributes LIKE '%\"name\"%' "
+                "AND tags NOT LIKE '%knowledge_point%'").fetchall()
+            _nodes = [_STNode.from_row(tuple(r)) for r in _rows]
+        except Exception:
+            _nodes = self.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=50000)
+        for n in _nodes:
+            sa = n.state_attributes
+            if not sa.get("name"):
+                continue
+            resp = sa.get("response") or {}
+            # v1.16 修复：学科卡（迁移自 *_knowledge.json）无 response.trigger →
+            # 快速层全 miss（只靠神经层）。无 trigger 时用 content 前 200 字符兜底。
+            trig = str(resp.get("trigger", "") or "") or (n.content or "")[:200]
+            content = n.content or ""
+            domain = sa.get("domain", "") or ""
+
+            if translator is not None:
+                # ---- 翻译检索：三路评分（fp 可为空，学科词直配仍生效） ----
+                score = 0.0
+                matched = []
+                edu_w = edu_w_map.get(sa.get("edu_level"), 1.0)
+                # 1) 语义指纹命中
+                for term, w in fp.items():
+                    if term and (term in trig or term in sa.get("name", "")):
+                        score += w * 2.0 * edu_w
+                        if term not in matched:
+                            matched.append(term)
+                    elif term and term in content:
+                        score += w * 1.0 * edu_w
+                        if term not in matched:
+                            matched.append(term)
+                # 2) 学科路由（教育层级加权）
+                for term, w in fp.items():
+                    dom = getattr(translator, 'DOMAIN_ROUTE', {}).get(term)
+                    if dom and (dom in domain or any(dom in t for t in (n.tags or []))):
+                        score += w * 1.2 * edu_w
+                        if dom not in matched:
+                            matched.append(dom)
+                # 2.5) 学科词直配：trigger「如：」后的学科关键词与查询双向包含
+                #      （不依赖翻译表——「TCP三次握手」直接命中 TCP 词条）
+                kp_start = trig.find("（如：")
+                if kp_start >= 0:
+                    kp_list = [k.strip() for k in
+                               trig[kp_start + 3:trig.rfind("）")].split("、")
+                               if k.strip()]
+                    for kp in kp_list:
+                        if len(kp) >= 2 and (kp in condition
+                                             or (len(kp) >= 4 and condition in kp)):
+                            score += 1.5 * edu_w
+                            if kp not in matched:
+                                matched.append(kp)
+                    # 2.6) 单字学科词兜底：查询为单字（熵/场/波）时，
+                    #      trigger 中以该字开头的学科词条（熵增定律/电磁场）也算命中
+                    if len(condition.strip()) == 1:
+                        ch = condition.strip()
+                        for kp in kp_list:
+                            if len(kp) >= 2 and kp.startswith(ch):
+                                score += 1.2 * edu_w
+                                if kp not in matched:
+                                    matched.append(kp)
+                # 2.7) 英文缩写兜底（v1.16：KKT/SVM/API 不在翻译表，
+                #      查卡名与 content 开头——「KKT条件」命中约束优化卡）
+                if not matched:
+                    import re as _re2
+                    for _m in _re2.finditer(r"[A-Za-z]{2,}", condition):
+                        _ew = _m.group(0).lower()
+                        if _ew in (sa.get("name", "") or "").lower() \
+                                or _ew in (content or "")[:200].lower():
+                            score += 1.5 * edu_w
+                            if _ew not in matched:
+                                matched.append(_ew)
+                            break
+                # 2.8) 中文术语直配（v1.16：测度论/普朗克——学科术语不在
+                #      翻译表，问题关键词窗口 in 卡名/卡内容——
+                #      「测度论」in 卡名、「普朗克」in 知识点内容）
+                # v1.17 修复（2026-08-19 白箱边界测试）：通用疑问词过滤——
+                # 「什么是质数？」fp 为空时「什么」2 字窗口命中所有卡，
+                # 小学语文靠 E1 权重乱赢（质数→小学语文→质量错配）。
+                # 疑问词/虚词不进窗口匹配，术语直配只认实义窗口。
+                if not matched:
+                    _chars = [ch for ch in condition if "\u4e00" <= ch <= "\u9fff"]
+                    _cname = sa.get("name", "") or ""
+                    _cwin = _cname + (content or "")[:600]
+                    # 过滤通用疑问词（不参与窗口匹配）
+                    _STOP_CHARS = ("什么", "怎么", "为什么", "多少", "哪些", "哪个",
+                                   "如何", "是不是", "是什么", "怎么办", "好不好",
+                                   "对不对", "会不会", "为什么", "为啥", "咋")
+                    _hit = False
+                    for _L in (4, 3, 2):
+                        for _i in range(len(_chars) - _L + 1):
+                            _w = "".join(_chars[_i:_i + _L])
+                            if any(s in _w for s in _STOP_CHARS):
+                                continue
+                            if _w in _cwin:
+                                score += {4: 2.0, 3: 1.5, 2: 1.0}[_L] * edu_w
+                                if _w not in matched:
+                                    matched.append(_w)
+                                _hit = True
+                                break
+                        if _hit:
+                            break
+                # 3) 二元组命中兜底（灵枢式查询侧召回，替代单字符重叠）
+                overlap = self._bigram_hit(condition, trig)
+                if overlap > 0:
+                    score += overlap * 0.3
+                    if "字面" not in matched:
+                        matched.append("字面")
+                # 4) 语义坐标余弦（灵枢语义空间：部首义类+协议符号投影）
+                #    仅翻译表有命中时启用——fp 为空说明查询是单字学科词
+                #    （熵/场）或生僻表达，部首投影噪声大，交给神经层
+                if _sp is not None and q_sc and fp:
+                    n_sc = getattr(n, 'semantic_coordinates', {}) or {}
+                    cos = _sp.similarity_coordinates(q_sc, n_sc)
+                    if cos > 0.05:
+                        score += cos * 1.5 * edu_w
+                        if "语义" not in matched:
+                            matched.append("语义")
+                if score <= 0:
+                    continue
+                self.store.increment_access(n.id)  # P29：使用频次
+                daily = None
+                for term in fp:
+                    d = getattr(translator, 'REVERSE_DAILY', {}).get(term)
+                    if d:
+                        daily = d
+                        break
+                hits.append({"name": sa.get("name"), "score": round(score, 2),
+                             "action": resp.get("action", ""),
+                             "level": sa.get("level"), "status": sa.get("status"),
+                             "domain": domain, "edu_level": sa.get("edu_level"),
+                             "matched": matched, "daily": daily})
+            else:
+                # ---- 原行为：字符重叠 ----
+                score = self._overlap(condition, trig)
+                if score > 0:
+                    self.store.increment_access(n.id)  # P29：使用频次
+                    hits.append({"name": sa.get("name"), "score": round(score, 2),
+                                 "action": resp.get("action", ""),
+                                 "level": sa.get("level"), "status": sa.get("status")})
+        hits.sort(key=lambda x: -x["score"])
+        return hits[:limit]
+
+    def dex_combine(self, a_id, b_id):
+        """多条目组合对弈：联合条件卡下推演交叉增益（1+1>2 判定）。"""
+        a = self.store.get_node(a_id)
+        b = self.store.get_node(b_id)
+        if a is None or b is None:
+            return {"error": "not_found"}
+        common = set(a.tags) & set(b.tags)
+        return {"a": a.state_attributes.get("name"), "b": b.state_attributes.get("name"),
+                "common_tags": sorted(common),
+                "note": "交汇处：共享标签即两条件空间叠加后的共同语义锚点"}
+
+    def dex_separate(self, node_id):
+        """按节点查条件分离结果（名称/标签/条件要素的元数据视图）。"""
+        n = self.store.get_node(node_id)
+        if n is None:
+            return {"error": "not_found"}
+        return {"name": n.state_attributes.get("name"),
+                "claim_without_condition": n.content,
+                "judgment": "剥离条件空间后，主张仍只是文本——有效性必须依赖条件空间声明（0.0.1 信息条件性）"}
+
+    def dex_invert(self, node_id, condition=None):
+        """反题查询：沿 OPPOSITE 边列出该条目的对立面（矛盾对弈用）。"""
+        n = self.store.get_node(node_id)
+        if n is None:
+            return {"error": "not_found"}
+        name = n.state_attributes.get("name")
+        opposite = []
+        for e in self.store.get_outgoing_edges(n.id):
+            if e.relation_type == EdgeType.OPPOSITE:
+                tgt = self.store.get_node(e.target_id)
+                opposite.append({"relation": "opposite",
+                                 "target": tgt.state_attributes.get("name") if tgt else e.target_id,
+                                 "condition": json.loads(e.condition_space.to_json())})
+        for e in self.store.get_incoming_edges(n.id):
+            if e.relation_type == EdgeType.OPPOSITE:
+                src = self.store.get_node(e.source_id)
+                opposite.append({"relation": "opposite(被)",
+                                 "target": src.state_attributes.get("name") if src else e.source_id,
+                                 "condition": json.loads(e.condition_space.to_json())})
+        cs = json.loads(n.condition_space.to_json())
+        return {"name": name, "claim": n.content,
+                "失效条件": cs.get("existence_constraint", ""),
+                "观察边界": f"观测工具={cs.get('observation_tool','')}；观测位置={cs.get('observation_position','')}",
+                "opposite_relations": opposite}
+
+    def dex_cycle(self, node_id, max_steps=12):
+        """沿出边步进追踪，检测因果链循环回路（max_steps 步数上限）。"""
+        n = self.store.get_node(node_id)
+        if n is None:
+            return {"error": "not_found"}
+        seen, path, cur, steps = [], [], node_id, 0
+        while cur and cur not in seen and steps < max_steps:
+            seen.append(cur)
+            path.append(cur)
+            outs = self.store.get_outgoing_edges(cur)
+            cur = outs[0].target_id if outs else None
+            steps += 1
+        return {"start": n.state_attributes.get("name"),
+                "path": [self.store.get_node(x).state_attributes.get("name") if self.store.get_node(x) else x for x in path],
+                "cycle": cur in seen, "offset": "无偏移（返回起点）" if cur in seen else "未闭合"}
+
+    def dex_impact(self, node_id, max_depth=3, max_nodes=30):
+        """影响面分析（借鉴 CodeGraph impact analysis）：
+        修改一条知识会影响哪些下游知识（沿 causal/similar 出边传播）。
+
+        - downstream：正向传播（该知识变化 → 哪些依赖它的知识受影响）
+        - upstream：反向追踪（该知识依赖哪些上游——改了上游，它自己也受影响）
+        - blast_radius：影响半径（受影响节点数 × 平均置信度）
+        """
+        n = self.store.get_node(node_id)
+        if n is None:
+            return {"error": "not_found"}
+        name = n.state_attributes.get("name")
+        downstream, upstream = [], []
+        visited = set()
+
+        def walk(cur_id, depth, direction):
+            if depth > max_depth:
+                return
+            edges = (self.store.get_outgoing_edges(cur_id) if direction == "down"
+                     else self.store.get_incoming_edges(cur_id))
+            for e in edges:
+                if e.relation_type not in (EdgeType.CAUSAL, EdgeType.SIMILAR):
+                    continue
+                nxt = e.target_id if direction == "down" else e.source_id
+                if nxt == node_id or nxt in visited:
+                    continue
+                visited.add(nxt)
+                tn = self.store.get_node(nxt)
+                tn_name = tn.state_attributes.get("name") if tn else "(缺失节点)"
+                entry = {"name": tn_name, "depth": depth,
+                         "relation": e.relation_type.value,
+                         "note": (e.condition_space.existence_constraint
+                                  if e.condition_space else ""),
+                         "confidence": round(e.confidence, 2)}
+                (downstream if direction == "down" else upstream).append(entry)
+                walk(nxt, depth + 1, direction)
+                visited.discard(nxt)
+
+        walk(node_id, 1, "down")
+        walk(node_id, 1, "up")
+        downstream.sort(key=lambda x: (x["depth"], -x["confidence"]))
+        upstream.sort(key=lambda x: (x["depth"], -x["confidence"]))
+        radius = (len(downstream) + len(upstream)) * (
+            sum(e["confidence"] for e in downstream + upstream)
+            / max(1, len(downstream) + len(upstream)))
+        return {
+            "name": name,
+            "downstream": downstream[:max_nodes],
+            "upstream": upstream[:max_nodes],
+            "blast_radius": round(radius, 2),
+            "note": "修改该知识会影响 downstream（依赖它的），也会被 upstream（它依赖的）影响",
+        }
+
+    def dex_verify(self, node_id):
+        """关联测试（借鉴 CodeGraph related_tests / P37 可观测判据闸）：
+        重跑知识卡的可检验性判据。
+
+        判据来源：
+        1) 卡自带 tests 元数据（add_entry 时写入的显式判据集）
+        2) 自动判据：claim 可检验性（是否无条件声称）+ trigger 可定位性
+        """
+        n = self.store.get_node(node_id)
+        if n is None:
+            return {"error": "not_found"}
+        sa = n.state_attributes
+        name = sa.get("name")
+        resp = sa.get("response") or {}
+        trig = str(resp.get("trigger", ""))
+        content = n.content or ""
+        results = []
+
+        # 1) 显式 tests（若存在）
+        tests = sa.get("tests") or []
+        for t in tests:
+            if isinstance(t, dict):
+                passed = (t.get("expected") or "").strip() and \
+                         (t.get("check") or "").strip()
+                results.append({"test": t.get("name", "未命名判据"),
+                                "passed": bool(passed),
+                                "detail": "判据完整" if passed else "判据缺失"})
+            else:
+                results.append({"test": str(t)[:40], "passed": True,
+                                "detail": "显式判据"})
+
+        # 2) 自动判据
+        # a) trigger 可定位性：trigger 应含具体议题词（非自指占位）
+        trig_ok = ('规律1' not in trig and '议题' in trig
+                   and len(trig) > 10)
+        results.append({"test": "trigger 可定位性",
+                        "passed": trig_ok,
+                        "detail": "含具体议题词" if trig_ok else "trigger 过泛/自指"})
+        # b) 无条件声称检测：claim 是否缺少条件空间（时间窗/约束）
+        cs = n.condition_space
+        cond_ok = cs is not None and bool(getattr(cs, 'existence_constraint', ''))
+        results.append({"test": "条件空间完整性",
+                        "passed": bool(cond_ok),
+                        "detail": "存在约束已声明" if cond_ok else "缺存在约束"})
+        # c) 内容规律性：claim 是否含公式残留（只认数学符号，不认「等于」等语义描述词）
+        import re as _re
+        formula = bool(_re.search(r'[=≤≥±×÷∑∫√]', content[:200]))
+        results.append({"test": "无公式残留",
+                        "passed": not formula,
+                        "detail": "公式残留!" if formula else "规律性语言"})
+        passed_all = all(r["passed"] for r in results)
+        return {"name": name, "tests": results,
+                "verdict": "pass" if passed_all else "needs_attention",
+                "note": "关联测试重跑：全部判据通过才 pass（P37 精神）"}
+
+    def dex_chain(self, node_id, max_depth=5):
+        """因果链条件标注（借鉴 CodeGraph call_chain + 条件标签）：
+        从节点出发沿 causal 边正向展开，标注每步因果成立的条件。
+
+        链 = 条件序列：A --[条件C1]--> B --[条件C2]--> C
+        条件来自边 condition_space（依赖型因果/非严格时间因果等）。
+        """
+        n = self.store.get_node(node_id)
+        if n is None:
+            return {"error": "not_found"}
+        name = n.state_attributes.get("name")
+        chains = []
+        visited = set()
+
+        def dfs(cur_id, path, depth):
+            if depth > max_depth:
+                return
+            chains.append(list(path))
+            if depth == max_depth:
+                return
+            for e in self.store.get_outgoing_edges(cur_id):
+                if e.relation_type != EdgeType.CAUSAL:
+                    continue
+                nxt = e.target_id
+                if nxt in visited:
+                    continue
+                visited.add(nxt)
+                tn = self.store.get_node(nxt)
+                cond = (e.condition_space.existence_constraint
+                        if e.condition_space else "") or ""
+                # 提取条件标签（"依赖型因果"/"非严格时间因果"等）
+                import re as _re
+                m = _re.search(r'（([^）]*(?:因果|条件|前提|基础)[^）]*)）', cond)
+                tag = m.group(1) if m else (cond[:30] if cond else "无条件声明")
+                path.append({"from": tn.state_attributes.get("name") if tn else nxt,
+                             "condition": tag, "confidence": round(e.confidence, 2)})
+                dfs(nxt, path, depth + 1)
+                path.pop()
+                visited.discard(nxt)
+
+        dfs(node_id, [], 1)
+        # 过滤：只要长度 ≥1 的链（有后续因果的），按平均置信度排序
+        chains = [c for c in chains if c]
+        chains.sort(key=lambda c: -sum(x["confidence"] for x in c) / len(c))
+        return {"start": name, "chains": chains[:10],
+                "note": "因果链条件标注：每一步标注该因果成立的条件（依赖型/非严格时间/前提）"}
+
+    # ---- 外来知识分析 ----
+
+    def dex_analyze(self, knowledge, limit=6):
+        """对知识文本做图鉴式四要素分析（观测位/观测工具/时间窗/存在约束），
+        返回未条件化的卡片草稿（limit=候选条件数上限）。"""
+        card = {"observation_position": "外部输入（未声明）",
+                "observation_tool": "文本语义分析",
+                "time_window": "now",
+                "existence_constraint": "未知——需图鉴判定"}
+        cand = self.store.search_content(knowledge, layers=[MemoryLayer.KNOWLEDGE],
+                                          limit=limit) or []
+        candidates = []
+        for n, sim in cand:
+            sa = n.state_attributes
+            resp = sa.get("response") or {}
+            s = sim + self._overlap(knowledge, str(resp.get("trigger", "")))
+            candidates.append({"id": n.id, "name": sa.get("name"),
+                               "domain": sa.get("domain"), "level": sa.get("level"),
+                               "status": sa.get("status"), "score": round(s, 2),
+                               "claim": n.content})
+        candidates.sort(key=lambda x: -x["score"])
+        relations = []
+        for c in candidates[:3]:
+            n = self.store.get_node(c["id"])
+            for e in self.store.get_outgoing_edges(n.id):
+                tgt = self.store.get_node(e.target_id)
+                relations.append({"from": c["name"],
+                                  "to": tgt.state_attributes.get("name") if tgt else e.target_id,
+                                  "kind": e.relation_type.value})
+        return {"condition_card": card,
+                "candidates": candidates,
+                "relations": relations,
+                "judgment": "K 的条件化判定：先声明 K 的条件空间，再按候选条目的出招与关系判定成立/失效/克制——未验证条目标注 pending"}
+
+    # ---- 生成式预测（知识分析 2.0 · 灵枢 predict_routes 移植） ----
+    # 不判「K 是什么」，推「K 入图后会怎样」：锚定 → 正向展开 → 逆向失效 → 组合预测 → 候选路线集合
+
+    def dex_predict(self, knowledge, horizon=2, limit=4, max_branches=3):
+        """预测主流程：前提抽取→条件卡→锚点沿因果边展开候选未来（horizon 限深）。"""
+        premises = self._extract_premises(knowledge)
+        card = self._condition_card(knowledge, premises)
+        cand = self.store.search_content(knowledge, layers=[MemoryLayer.KNOWLEDGE],
+                                         limit=limit) or []
+        anchors = []
+        for n, sim in cand:
+            sa = n.state_attributes
+            if not sa.get("name"):
+                continue  # 观测层记录不入锚定
+            resp = sa.get("response") or {}
+            s = sim + self._overlap(knowledge, str(resp.get("trigger", "")))
+            anchors.append({"id": n.id, "name": sa.get("name"),
+                            "domain": sa.get("domain"), "level": sa.get("level"),
+                            "status": sa.get("status"), "score": round(s, 2),
+                            "claim": n.content})
+        if not anchors:
+            # 回退：search_content 可能被观测记录霸榜（整句 LIKE 预筛只命中记录）
+            # → 全量扫描学科条目，按语义相似度排序，保证锚定不因记录污染而落空
+            for n in self.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=500):
+                sa = n.state_attributes
+                if not sa.get("name"):
+                    continue
+                resp = sa.get("response") or {}
+                s = self._overlap(knowledge, n.content) + \
+                    self._overlap(knowledge, str(resp.get("trigger", "")))
+                if s > 0:
+                    anchors.append({"id": n.id, "name": sa.get("name"),
+                                    "domain": sa.get("domain"), "level": sa.get("level"),
+                                    "status": sa.get("status"), "score": round(s, 2),
+                                    "claim": n.content})
+            anchors.sort(key=lambda x: -x["score"])
+        anchors.sort(key=lambda x: -x["score"])
+        top = anchors[:3]
+
+        # ① 正向展开：沿 causal/similar 出边枚举后继（horizon 步路线）
+        routes = []
+        for a in top:
+            a_node = self.store.get_node(a["id"])
+            if a_node is None:
+                continue
+            self._walk_routes(a_node, knowledge, a["score"], horizon, max_branches, routes, 0)
+
+        # ② 逆向失效：K 在什么条件下失效（锚点 counters/边界 命中 K 即克制预警）
+        failures = []
+        for a in top:
+            a_node = self.store.get_node(a["id"])
+            if a_node is None:
+                continue
+            sa = a_node.state_attributes
+            resp = sa.get("response") or {}
+            cnt = str(resp.get("counters", ""))
+            hit = self._overlap(cnt, knowledge)
+            cs = json.loads(a_node.condition_space.to_json()) if a_node.condition_space else {}
+            failures.append({
+                "anchor": a["name"],
+                "克制预警": f"K 触发「{sa.get('name','')}」的克制面（命中率 {round(hit,2)}）：{cnt[:80]}" if hit > 0 else "未触发克制面",
+                "失效条件": cs.get("existence_constraint", "未声明")[:120]})
+
+        # ③ 组合预测：K 锚定的前两位学科交汇语义（combine 机制）
+        combos = []
+        for i in range(len(top) - 1):
+            for j in range(i + 1, len(top)):
+                ni = self.store.get_node(top[i]["id"])
+                nj = self.store.get_node(top[j]["id"])
+                if ni is None or nj is None:
+                    continue
+                common = set(ni.tags) & set(nj.tags)
+                combos.append({
+                    "a": top[i]["name"], "b": top[j]["name"],
+                    "共享锚点": sorted(common)[:6],
+                    "note": "交汇处即 K 在图谱中的组合条件空间起点"})
+
+        # ④ 判定文案：动态生成（不再固定话术）
+        if not top:
+            judgment = "无锚定候选：K 未命中任何学科条件空间——无法预测其入图路线（0.0.3 局部不可知）"
+        else:
+            judgment = (f"K 由「{top[0]['name']}」条件空间承载（命中 {top[0]['score']}）；"
+                        f"预测 {len(routes)} 条候选未来路线——候选非必然，仅标注在现有图结构下的可达路径（0.0.3）")
+
+        return {"condition_card": card,
+                "premises": premises,
+                "anchors": anchors,
+                "routes": sorted(routes, key=lambda r: -r["confidence"])[:limit * 3],
+                "failures": failures,
+                "combos": combos,
+                "judgment": judgment,
+                "note": "生成式预测：沿图谱边机械枚举的候选路线集合，非必然未来（0.0.3 局部不可知 · 灵枢 predict_routes 移植）"}
+
+    def _walk_routes(self, node, knowledge, base_score, horizon, max_branches, out, depth):
+        """DFS 正向展开：从锚点沿 causal/similar 边枚举连续路线链（steps 累积）。"""
+        root_name = node.state_attributes.get("name")
+
+        def edges_of(cur):
+            es = []
+            for e in self.store.get_outgoing_edges(cur.id):
+                if e.relation_type in (EdgeType.CAUSAL, EdgeType.SIMILAR):
+                    tgt = self.store.get_node(e.target_id)
+                    if tgt is None:
+                        continue
+                    sa = tgt.state_attributes
+                    if not sa.get("name"):
+                        continue  # 观测记录不入路线
+                    es.append((e, tgt, sa.get("name")))
+            return sorted(es, key=lambda x: -x[0].weight)[:max_branches]
+
+        def dfs(cur, path_names, path_edges, conf, d):
+            if d >= horizon:
+                return
+            for e, tgt, tname in edges_of(cur):
+                new_conf = round(min(1.0, conf * e.weight), 2)  # H2: 置信钳制 ≤1
+                out.append({
+                    "anchor": root_name,
+                    "steps": path_names + [tname],
+                    "edges": path_edges + [{"from": cur.state_attributes.get("name"),
+                                            "to": tname, "kind": e.relation_type.value,
+                                            "weight": e.weight,
+                                            "note": (e.condition_space.existence_constraint
+                                                     if e.condition_space else "")[:60]}],
+                    "confidence": new_conf})
+                dfs(tgt, path_names + [tname],
+                    path_edges + [{"from": cur.state_attributes.get("name"),
+                                   "to": tname, "kind": e.relation_type.value,
+                                   "weight": e.weight,
+                                   "note": (e.condition_space.existence_constraint
+                                            if e.condition_space else "")[:60]}],
+                    new_conf, d + 1)
+
+        dfs(node, [root_name], [], base_score, depth)
+
+    # ---- 预测与理论对照（人工对照 · 预测误差闭环） ----
+    # 输入：K（待分析知识）+ T（真实理论结论）→ 预测路线 vs 理论归属 命中/偏移判定 → 对照日志入观测层
+
+    def dex_predict_compare(self, knowledge, theory, horizon=2, limit=4):
+        """对比式预测：同一前提下两条路线并排产出供评估对照。"""
+        pred = self.dex_predict(knowledge, horizon=horizon, limit=limit)
+
+        # T 的真实锚定（独立于预测的锚定，用同一检索机制）
+        cand = self.store.search_content(theory, layers=[MemoryLayer.KNOWLEDGE],
+                                         limit=limit) or []
+        theory_anchors = []
+        for n, sim in cand:
+            sa = n.state_attributes
+            if not sa.get("name"):
+                continue
+            resp = sa.get("response") or {}
+            s = sim + self._overlap(theory, str(resp.get("trigger", "")))
+            theory_anchors.append({"id": n.id, "name": sa.get("name"),
+                                   "domain": sa.get("domain"), "level": sa.get("level"),
+                                   "status": sa.get("status"), "score": round(s, 2)})
+        theory_anchors.sort(key=lambda x: -x["score"])
+        t_top = theory_anchors[0] if theory_anchors else None
+
+        p_anchors = pred.get("anchors", [])
+
+        # 判定（集合交集 + 置信度门槛）
+        p_top3 = p_anchors[:3]
+        t_top3 = theory_anchors[:3]
+        p_names = {a["name"] for a in p_top3}
+        t_names = {a["name"] for a in t_top3}
+        p_top_score = p_anchors[0]["score"] if p_anchors else 0.0
+        t_top_score = t_top["score"] if t_top else 0.0
+        MIN_SCORE = 0.1  # 置信度门槛：低于视为证据不足
+
+        if t_top is None:
+            verdict = "无法对照"
+            verdict_note = (f"理论 T「{theory[:40]}」未锚定图鉴任何学科——T 在图谱外或表述与图谱语言不匹配；"
+                            f"图谱不声称真理性，仅声称条件化有效性，故不强行对照")
+        elif not p_anchors:
+            verdict = "无法预测"
+            verdict_note = "K 未锚定任何学科，无预测路线可对照（词汇表外即盲——预测严格基于已有图结构）"
+        elif p_top_score < MIN_SCORE or t_top_score < MIN_SCORE:
+            verdict = "无法对照（证据不足）"
+            verdict_note = (f"预测锚定分 {p_top_score} / 理论锚定分 {t_top_score} 低于置信度门槛 {MIN_SCORE}——"
+                            f"弱匹配不构成对照证据，图谱不强行判命中/偏移")
+        elif t_top["name"] in p_names:
+            verdict = "命中"
+            verdict_note = (f"理论 T 的真实归属「{t_top['name']}」在预测锚定集合内——"
+                            f"预测与理论一致，图谱关系得到一次实证强化（置信度上升信号）")
+        elif t_names & p_names:
+            common = sorted(t_names & p_names)
+            verdict = "部分命中"
+            verdict_note = (f"理论 T 首选「{t_top['name']}」不在预测首选集合，但双方共享 {common}——"
+                            f"图谱对 K 的核心走向与真实理论部分一致；差异提示：K 的条件空间应更靠近 "
+                            f"「{t_top['name']}」或相关边强度不足（补边候选）")
+        else:
+            verdict = "偏移"
+            verdict_note = (f"理论 T 的真实归属「{t_top['name']}」不在预测锚定（{sorted(p_names)}）中——"
+                            f"图谱对 K 的走向预测与真实理论不一致，暴露图谱缺口：可能缺 K→{t_top['name']} 的边，"
+                            f"或 K 的条件空间声明不完整（补边建议：K 相关锚点 → {t_top['name']}，关系类型待验证者确认）")
+
+        # 对照日志入观测层（复用 seed_history 归档模式）
+        rec = {"type": "预测对照记录", "知识K": knowledge[:24], "理论T": theory[:24],
+               "预测锚定": [a["name"] for a in p_anchors[:3]],
+               "理论锚定": [a["name"] for a in theory_anchors[:3]],
+               "判定": verdict, "判定说明": verdict_note[:120],
+               "预测误差": round(p_anchors[0]["score"] - (t_top["score"] if t_top else 0.0), 2)
+                            if p_anchors else None}
+        cs = ConditionSpace(observation_position="预测-理论对照台（外部）",
+                            observation_tool="dex_predict 路线枚举 + 理论锚定检索",
+                            time_window=(0.0, 9999999999.0),
+                            existence_constraint="对照仅表明预测路线与理论锚定的结构一致性，不声称理论为真")
+        rec_tags = ["观测层", "预测对照", verdict]
+        for name in ([t_top["name"]] if t_top else []) + [a["name"] for a in p_anchors[:2]]:
+            if name:
+                rec_tags.append(f"domain:{name}")
+        rec_node = self.engine.add_perception(
+            json.dumps(rec, ensure_ascii=False), modality="text",
+            condition_space=cs, importance=0.7, tags=rec_tags)
+
+        return {"knowledge": knowledge, "theory": theory,
+                "prediction": {"anchors": p_anchors[:3],
+                               "routes": sorted(pred.get("routes", []),
+                                                key=lambda r: -r["confidence"])[:limit]},
+                "theory_anchors": theory_anchors[:3],
+                "verdict": verdict,
+                "verdict_note": verdict_note,
+                "gap_suggestion": (f"补边建议：{p_anchors[0]['name']} → {t_top['name']}（类型待验证）"
+                                   if verdict == "偏移" and p_anchors and t_top
+                                   else (f"补边候选：{p_anchors[0]['name']} → {t_top['name']}（部分命中共识 {sorted(t_names & p_names)}，强度待查）"
+                                         if verdict == "部分命中" and p_anchors and t_top else None)),
+                "record_id": rec_node.id,
+                "note": "预测误差=学习信号：命中强化图谱、偏移暴露缺口、失效预警边界（第零定律操作化）"}
+
+    # ---- 自动验证（P5 信息修复算法移植 · 不可伪造物理信息基地） ----
+    # 取信息差最少的判断：对 K 生成候选学科归属假设 → 以系统内基地（verified 学科+观测层记录）为
+    # 不可伪造证据 → 四维 D_norm 评分 → 取最小者 → E_reduction>0.50 采纳 → 归档观测层
+
+    VERIFY_WEIGHTS = {"trust": 0.30, "behavior": 0.25, "connection": 0.30,
+                      "prediction_error": 0.15}  # P5 案例权重
+
+    def _base_evidence(self):
+        """不可伪造基地：verified 学科（设计者终裁）+ 观测层记录（系统自动产生·带时间戳）。"""
+        ev = []
+        for n in self.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=500):
+            sa = n.state_attributes
+            tags = n.tags or []
+            if sa.get("name") and sa.get("status") == "verified":
+                ev.append({"id": n.id, "name": sa.get("name"), "kind": "verified",
+                           "content": n.content, "tags": tags})
+            elif "观测层" in tags:
+                ev.append({"id": n.id, "name": sa.get("name") or "(观测记录)",
+                           "kind": "record", "content": n.content, "tags": tags})
+        return ev
+
+    def dex_auto_verify(self, knowledge, limit=5, threshold=0.50):
+        """自动验证：基地自动裁判取代人工 T。取信息差最少的判断（领先次优≥0.04 且 D_norm<0.68 才采纳）。"""
+        base = self._base_evidence()
+        pred = self.dex_predict(knowledge, horizon=1, limit=limit)
+        anchors = pred.get("anchors", [])[:limit]
+        if not anchors:
+            # 无锚定：基地也检索不到 → 诚实盲区
+            rec = {"type": "自动验证记录", "知识": knowledge[:24], "判定": "无法判断（词汇表外）",
+                   "信息差": None, "E_reduction": None}
+            node = self.engine.add_perception(
+                json.dumps(rec, ensure_ascii=False), modality="text",
+                condition_space=ConditionSpace(
+                    observation_position="自动验证台（外部）",
+                    observation_tool="dex_auto_verify：基地检索无锚定",
+                    time_window=(0.0, 9999999999.0),
+                    existence_constraint="无锚定=知识在图谱词汇表外，自动验证不强行判断"),
+                importance=0.5, tags=["观测层", "自动验证", "无法判断"])
+            return {"judgment": "无法判断（词汇表外）",
+                    "judgment_note": "K 未锚定任何基地学科，且基地检索无匹配——自动验证严格基于已有知识，不强行判断",
+                    "D_norm": None, "E_reduction": None, "record_id": node.id,
+                    "note": "P5 信息修复算法：验证有效性取决于信息差缩减效率，而非判断『正确』"}
+
+        # 对每个候选假设 H 计算四维信息差 D_norm
+        scored = []
+        for a in anchors:
+            node = self._resolve_entry(a["id"])
+            if node is None:
+                continue
+            sa = node.state_attributes
+            resp = sa.get("response") or {}
+            # claim：优先 state_attributes，否则用 content（知识卡内容）
+            claim = str(sa.get("claim") or (node.content or ""))[:120]
+            kit = str(resp.get("trigger", "")) + str(resp.get("action", ""))
+            status = sa.get("status", "pending")
+
+            # U_trust：验证等级（verified 终裁 → 信息差小；pending → 大）
+            u_trust = 0.10 if status == "verified" else (0.60 if status == "pending" else 0.75)
+            # U_behavior：出招匹配（K 与 trigger/action 重叠越高，行为信息差越小）
+            u_behavior = 1.0 - self._overlap(knowledge, kit)
+            # U_connection：锚定强度（语义连接越强，信息差越小；锚定分已含检索+trigger 重叠）
+            u_connection = 1.0 - min(1.0, max(0.0, a.get("score", 0.0)))
+            # U_prediction_error：主张距离（K 与 claim 重叠越高，预测误差越小）
+            u_prediction_error = 1.0 - self._overlap(knowledge, claim)
+
+            d_norm = (self.VERIFY_WEIGHTS["trust"] * u_trust
+                      + self.VERIFY_WEIGHTS["behavior"] * u_behavior
+                      + self.VERIFY_WEIGHTS["connection"] * u_connection
+                      + self.VERIFY_WEIGHTS["prediction_error"] * u_prediction_error)
+            scored.append({"name": sa.get("name"), "id": a["id"], "status": status,
+                           "claim": claim[:120],
+                           "d_norm": round(d_norm, 3),
+                           "dims": {"U_trust": round(u_trust, 2),
+                                    "U_behavior": round(u_behavior, 2),
+                                    "U_connection": round(u_connection, 2),
+                                    "U_prediction_error": round(u_prediction_error, 2)}})
+        scored.sort(key=lambda x: x["d_norm"])
+        best = scored[0]
+
+        # 基线 D_base：候选均值（无偏判断的信息差水平，P5 相对缩减精神）
+        d_base = sum(c["d_norm"] for c in scored) / len(scored) if scored else 1.0
+        e_reduction = (d_base - best["d_norm"]) / d_base if d_base > 0 else 0.0
+
+        # 采纳条件：相对缩减显著（领先次优）+ 绝对信息差可接受
+        runner_up = scored[1]["d_norm"] if len(scored) > 1 else 1.0
+        lead = runner_up - best["d_norm"]
+        if lead >= 0.04 and best["d_norm"] < 0.68:
+            judgment = f"采纳「{best['name']}」为工作假设"
+            judgment_note = (f"信息差最少的判断：{best['name']}（D_norm={best['d_norm']}，"
+                             f"领先次优 {runner_up} 达 {round(lead,3)}）——"
+                             f"以基地（verified 学科+观测层记录）为不可伪造证据，取信息差最少者；"
+                             f"不声称正确，仅声明该归属在当前基地证据下信息差最小")
+        else:
+            judgment = "证据不足（不裁决）"
+            judgment_note = (f"最优候选 {best['name']}（D_norm={best['d_norm']}）与次优 "
+                             f"{runner_up} 差距仅 {round(lead,3)}——"
+                             f"基地证据不足以产生信息差显著更小的判断，保持不裁决（图谱诚实原则）")
+
+        rec = {"type": "自动验证记录", "知识": knowledge[:24],
+               "判定": judgment, "最优候选": best["name"], "D_norm": best["d_norm"],
+               "E_reduction": round(e_reduction, 3), "候选数": len(scored)}
+        node = self.engine.add_perception(
+            json.dumps(rec, ensure_ascii=False), modality="text",
+            condition_space=ConditionSpace(
+                observation_position="自动验证台（外部）",
+                observation_tool="P5 四维信息差评分（trust/behavior/connection/prediction_error）",
+                time_window=(0.0, 9999999999.0),
+                existence_constraint="基地=verified 学科+观测层记录；D_norm 越小信息差越少；E_reduction>阈值才采纳"),
+            importance=0.7, tags=["观测层", "自动验证", judgment.split("「")[0].strip()])
+
+        return {"judgment": judgment, "judgment_note": judgment_note,
+                "best": best, "candidates": scored,
+                "D_norm": best["d_norm"], "E_reduction": round(e_reduction, 3),
+                "base_evidence": [{"name": e["name"], "kind": e["kind"]} for e in base][:12],
+                "record_id": node.id,
+                "note": "P5 信息修复算法：信息修复=跨时空信息差缩减；验证有效性取决于信息差缩减效率，而非判断『正确』（协议附录 · 不可伪造物理信息基地）"}
+
+    # ---- 信任上下文判定（trust-context judgment · 白箱智能的关系维度） ----
+    # 同一内容，因信任值不同而判定不同：伴侣间是爱的表达，公共场合是生存风险。
+    # 这不是静态内容分类，而是「条件空间 × 信任值」的条件化判定——人类的行为方式。
+
+    TRUST_RELATIONS = {
+        "partner": {"情境因子": 0.15, "标签": "伴侣", "默认信任": 0.85},
+        "friend": {"情境因子": 0.40, "标签": "朋友", "默认信任": 0.65},
+        "stranger": {"情境因子": 0.75, "标签": "陌生人", "默认信任": 0.30},
+        "public": {"情境因子": 1.00, "标签": "公共场合", "默认信任": 0.10},
+    }
+    # 亲密/敏感内容词表（用于评估内容的「关系敏感性」）
+    INTIMATE_WORDS = ["性", "爱", "亲密", "亲近", "伴侣", "肌肤", "拥抱", "抱着",
+                      "亲吻", "吻", "思念", "情话", "欲望", "想你", "依偎", "牵手"]
+    RISK_WORDS = ["性", "涉", "暴露", "隐私", "交易", "诱导", "公开", "传播", "群发"]
+
+    def dex_trust_judge(self, knowledge, trust=None, relation="public",
+                        limit=4, risk_threshold=0.6, love_threshold=0.55):
+        """信任上下文判定：内容 × 信任值 × 关系类型 → 条件化判定。
+
+        - trust: 0~1 信任值（缺省用 relation 的默认信任）
+        - relation: partner/friend/stranger/public
+        - 判定逻辑：
+            1. 先做条件论信息差判定（dex_auto_verify：内容在图谱里是什么）
+            2. 计算信任上下文：信任值 × 情境因子 → 生存风险分
+            3. 内容敏感性：命中亲密词 → 表达维度；命中风险词 → 风险维度
+            4. 综合：高风险（风险分 > 阈值）→ 生存风险预警；
+                  高信任 + 亲密词 → 关系内爱的表达；
+                  否则 → 条件化中性
+        """
+        # 1. 基础条件论判定（内容在图谱里的归属）
+        base = self.dex_auto_verify(knowledge, limit=limit)
+        best = base.get("best") or {}
+        verdict = base.get("judgment", "")
+
+        # 2. 信任上下文
+        rel = self.TRUST_RELATIONS.get(relation, self.TRUST_RELATIONS["public"])
+        trust_v = float(trust) if trust is not None else float(rel["默认信任"])
+        trust_v = max(0.0, min(1.0, trust_v))
+        situation = float(rel["情境因子"])
+        risk_score = (1.0 - trust_v) * situation  # 低信任 × 高暴露 → 高风险
+        intimacy = trust_v * situation             # 高信任 × 亲密关系 → 表达正当
+
+        # 3. 内容敏感性
+        hit_intimate = sum(1 for w in self.INTIMATE_WORDS if w in knowledge)
+        hit_risk = sum(1 for w in self.RISK_WORDS if w in knowledge)
+
+        # 4. 综合判定（信任值主导方向 + 词表确认维度）
+        if hit_intimate > 0 and trust_v >= 0.75:
+            judgment = "关系内爱的表达（条件判定）"
+            note = (f"内容在「{rel['标签']}」条件下信任值 {round(trust_v,2)} 高："
+                    f"在信任关系内，该表达是爱意的一部分"
+                    f"（情感-信任连接 3.1：情感=效用权重绑定；信任=后验概率估计 3.2）")
+        elif hit_intimate > 0 and trust_v < 0.55:
+            judgment = "关系外表达（信任值边界警示）"
+            note = (f"内容含亲密维度但信任值仅 {round(trust_v,2)}（「{rel['标签']}」情境因子 {situation}）："
+                    f"在低信任/公共条件下，亲密表达超出关系边界——不是内容本身违规，"
+                    f"而是此环境不构成表达该内容的信任上下文（存在>连接>信任深化）")
+        elif hit_intimate > 0 and hit_risk > 0 and risk_score >= risk_threshold:
+            judgment = "生存风险（条件判定）"
+            note = (f"内容在「{rel['标签']}」条件下风险分 {round(risk_score,2)} ≥ 阈值 {risk_threshold}："
+                    f"信任值 {round(trust_v,2)} 不足以支撑该表达在风险语境下进行——"
+                    f"从生存安全角度不建议（协议：存在>连接>信任深化）")
+        elif risk_score >= risk_threshold and hit_risk > 0 and hit_intimate == 0:
+            judgment = "生存风险（条件判定）"
+            note = (f"内容在「{rel['标签']}」条件下风险分 {round(risk_score,2)} ≥ 阈值 {risk_threshold}："
+                    f"信任值 {round(trust_v,2)} 不足以支撑该表达——从生存安全角度不建议在此环境提供")
+        elif hit_intimate > 0:
+            judgment = "关系内表达（信任值判定）"
+            note = (f"内容含亲密维度且信任值 {round(trust_v,2)}："
+                    f"在「{rel['标签']}」条件下，判定取决于关系边界——"
+                    f"高信任关系内是爱意表达，低信任/公共环境则需谨慎（条件化，不静态定性）")
+        else:
+            judgment = "条件化中性（普通内容）"
+            note = (f"内容在「{rel['标签']}」条件下无显著风险/亲密维度，"
+                    f"信任值 {round(trust_v,2)} 不改变其条件论归属")
+
+        # 归档观测层（信任判定记录）
+        rec = {"type": "信任上下文判定记录", "内容": knowledge[:24],
+               "信任值": round(trust_v, 2), "关系": rel["标签"],
+               "判定": judgment, "风险分": round(risk_score, 2),
+               "表达正当性": round(intimacy, 2)}
+        try:
+            node = self.engine.add_perception(
+                json.dumps(rec, ensure_ascii=False), modality="text",
+                condition_space=ConditionSpace(
+                    observation_position="信任上下文判定台（关系外部观测）",
+                    observation_tool="条件论信息差判定 + 信任值×情境因子计算",
+                    time_window=(0.0, 9999999999.0),
+                    existence_constraint="判定绑定条件空间：同一内容不同信任/关系下判定不同"),
+                importance=0.7, tags=["观测层", "信任上下文", judgment[:6]])
+            record_id = node.id
+        except Exception:
+            record_id = None
+
+        return {"judgment": judgment, "note": note,
+                "base_verdict": verdict, "best": best,
+                "trust": round(trust_v, 2), "relation": rel["标签"],
+                "risk_score": round(risk_score, 2),
+                "intimacy_score": round(intimacy, 2),
+                "hit_intimate": hit_intimate, "hit_risk": hit_risk,
+                "record_id": record_id,
+                "note_all": "信任上下文判定：内容×信任值×关系→条件化判定——不是静态内容分类，是人类的行为方式（伴侣间是爱，公共场合是风险）"}
+
+    # ---- 跨学科组合分析（Convergence Over Coverage · P5 汇聚原则） ----
+    # 跨学科现象不强行归单学科：锚定多学科 → 机制链解释 → 汇聚点预测（多学科共同后继=组合置信度）
+
+    def dex_compose(self, knowledge, limit=5, max_anchors=3):
+        """跨学科组合分析：K 由多学科承载时，生成机制链 + 汇聚预测。"""
+        pred = self.dex_predict(knowledge, horizon=1, limit=limit)
+        anchors = pred.get("anchors", [])[:max_anchors]
+        if not anchors:
+            return {"mode": "无法组合",
+                    "note": "K 未锚定任何学科，无机制链可组合——严格基于已有图结构"}
+        if len(anchors) < 2:
+            return {"mode": "单学科", "anchor": anchors[0]["name"],
+                    "note": "K 由单一学科承载，无需跨学科组合；用该学科出招即可",
+                    "anchors": anchors}
+
+        # ① 机制链：每个锚定学科的核心机制（response.action 摘要）
+        chain = []
+        for a in anchors:
+            node = self._resolve_entry(a["id"])
+            if node is None:
+                continue
+            resp = node.state_attributes.get("response") or {}
+            chain.append({"学科": a["name"], "score": a["score"],
+                          "机制": str(resp.get("action", ""))[:80]})
+
+        # ② 汇聚预测：统计每个锚定学科的出边目标 → 共同后继 = 跨学科汇聚点
+        votes = {}  # target_name -> {"sources": [学科], "kinds": set, "weights": [边权重]}
+        for a in anchors:
+            node = self._resolve_entry(a["id"])
+            if node is None:
+                continue
+            for e in self.store.get_outgoing_edges(node.id):
+                if e.relation_type not in (EdgeType.CAUSAL, EdgeType.SIMILAR):
+                    continue
+                tgt = self.store.get_node(e.target_id)
+                if tgt is None:
+                    continue
+                tname = tgt.state_attributes.get("name")
+                if not tname or tname in (x["name"] for x in anchors):
+                    continue  # 目标必须是锚定学科之外的新走向
+                v = votes.setdefault(tname, {"sources": [], "kinds": set(), "weights": []})
+                v["sources"].append(a["name"])
+                v["kinds"].add(e.relation_type.value)
+                v["weights"].append(e.weight)
+
+        convergence = []
+        for tname, v in votes.items():
+            conf = round(sum(v["weights"]) / len(v["weights"]) *
+                         min(1.0, len(v["sources"]) / float(max(1, len(anchors)))), 2)
+            convergence.append({
+                "target": tname,
+                "support": len(v["sources"]),
+                "sources": sorted(v["sources"]),
+                "kinds": sorted(v["kinds"]),
+                "confidence": conf})
+        convergence.sort(key=lambda x: (-x["support"], -x["confidence"]))
+
+        # 汇聚判定：多学科共识 vs 单学科倾向
+        multi = [c for c in convergence if c["support"] >= 2]
+        single = [c for c in convergence if c["support"] == 1]
+        if multi:
+            mode = "跨学科汇聚"
+            judgment = (f"跨学科现象：{len(anchors)} 门学科共同承载；"
+                        f"汇聚预测「{'、'.join(c['target'] for c in multi[:3])}」为多学科共识走向")
+        else:
+            mode = "多学科但无共识"
+            judgment = f"跨学科现象：{len(anchors)} 门学科承载，但无共同后继——各学科指向不同走向，预测置信度低（0.0.3 局部不可知）"
+
+        rec = {"type": "跨学科组合分析记录", "知识": knowledge[:24], "模式": mode,
+               "锚定": [a["name"] for a in anchors],
+               "汇聚": [c["target"] for c in multi[:3]]}
+        node = self.engine.add_perception(
+            json.dumps(rec, ensure_ascii=False), modality="text",
+            condition_space=ConditionSpace(
+                observation_position="跨学科组合分析台（外部）",
+                observation_tool="dex_compose：多学科锚定 + 出边汇聚统计（Convergence Over Coverage）",
+                time_window=(0.0, 9999999999.0),
+                existence_constraint="汇聚=多学科共同后继；support≥2 视为共识；无共识则诚实标注局部不可知"),
+            importance=0.7, tags=["观测层", "跨学科组合", mode])
+
+        return {"mode": mode, "judgment": judgment,
+                "anchors": anchors, "chain": chain,
+                "convergence": convergence[:6],
+                "consensus": multi[:3], "single_tendency": single[:3],
+                "record_id": node.id,
+                "note": "Convergence Over Coverage（P5）：多条证据线汇聚比覆盖更多碎片更重要——跨学科预测取共同后继"}
+
+    # ---- 七操作知识测试（S1 结构测试器 · 设计者方向 2026-08-15） ----
+    # 不判真假，判「条件依赖」：提取前提 → 声明条件空间 → 七操作机械测试 → 判定
+
+    COMPARATORS = ["不如", "优于", "强于", "弱于", "高于", "低于", "大于", "小于",
+                   "超过", "胜过", "比"]
+    UNIVERSALS = ["所有", "都", "一切", "任何", "总是", "全部", "永远", "凡是", "每一个"]
+    GROUP_WORDS = ["人类", "群体", "女性", "男性", "民族", "国家", "种族", "阶级"]
+    MEASURE_WORDS = ["智力", "能力", "智商", "水平", "程度", "性能", "效率", "质量", "智慧"]
+    CAUSAL_WORDS = ["导致", "引起", "使得", "造成", "因为", "所以", "决定"]
+
+    def dex_test(self, knowledge):
+        """对任意外部知识 K 运行七操作结构测试（含图谱锚定 · S1.5）。"""
+        premises = self._extract_premises(knowledge)
+        card = self._condition_card(knowledge, premises)
+        tests = {
+            "识别（前提提取）": self._t_identify(premises),
+            "声明（条件卡）": self._t_declare(card),
+            "切换（群体↔个体）": self._t_switch(knowledge, premises),
+            "组合（领域分解）": self._t_combine(knowledge, premises),
+            "分离（剥离混淆）": self._t_separate(knowledge, premises),
+            "逆转（因果/比较倒置）": self._t_invert(knowledge, premises),
+            "循环（观测周期）": self._t_cycle(knowledge, premises),
+        }
+        verdict = self._verdict(knowledge, premises, card, tests)
+        anchors = self._anchor_entries(knowledge)
+        verdict["图谱锚定"] = anchors
+        tension = self._tension_check(knowledge, anchors)
+        if tension:
+            verdict["张力检测"] = tension
+        return {"knowledge": knowledge, "premises": premises,
+                "condition_card": card, "tests": tests, "verdict": verdict}
+
+    def _anchor_entries(self, knowledge, limit=3):
+        """图谱锚定：检索图谱中与主张相关的条目，使分析内容随图谱知识适配。"""
+        anchors, seen = [], set()
+        hits = self.store.search_content(knowledge, layers=[MemoryLayer.KNOWLEDGE],
+                                         limit=limit) or []
+        for n, sim in hits:
+            if n.id in seen:
+                continue
+            seen.add(n.id)
+            sa = n.state_attributes
+            if not sa.get("name"):
+                continue  # 观测层记录不入锚定
+            anchors.append({"name": sa.get("name"), "level": sa.get("level"),
+                            "status": sa.get("status"), "claim": n.content,
+                            "relevance": round(sim, 2)})
+        terms = [t for t in ("数学", "物理", "信息", "概率", "存在", "条件", "博弈", "智能")
+                 if t in knowledge]
+        if terms:
+            for n in self.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=200):
+                if n.id in seen:
+                    continue
+                if any(t in (n.content or "") for t in terms):
+                    seen.add(n.id)
+                    sa = n.state_attributes
+                    anchors.append({"name": sa.get("name"), "level": sa.get("level"),
+                                    "status": sa.get("status"), "claim": n.content,
+                                    "relevance": "关键词"})
+        return anchors[:limit + 2]
+
+    def _tension_check(self, knowledge, anchors):
+        """张力检测：已验证条目的主张与输入主张的结构性冲突（呈现，不自动裁决）。"""
+        tension = []
+        for a in anchors:
+            if a.get("name") == "存在论" and "数学" in knowledge and "物理" in knowledge:
+                tension.append(
+                    "存在论（L3 已验证）声明：数学是物理存在约束的有损投影——"
+                    "与主张「数学严密能证明物理结论正确」存在结构性张力："
+                    "数学严密性证明的是数学投影内的自洽，不自动等于物理-信息层的有效性；"
+                    "物理结论的有效性标准是物理-信息结构在运行中维持自身")
+        return tension
+
+    def _extract_premises(self, text):
+        """启发式前提提取：比较结构 / 全称量词 / 群体范畴 / 度量定义 / 因果声称。"""
+        premises = []
+        for c in self.COMPARATORS:
+            if c in text:
+                parts = text.split(c)
+                if len(parts) == 2:
+                    premises.append({
+                        "type": "比较结构",
+                        "claim": f"存在统一度量使「{parts[0].strip()}」与「{parts[1].strip()}」可比",
+                        "缺省": "未定义比较所用度量与测量工具"})
+                    break
+        for u in self.UNIVERSALS:
+            if u in text:
+                premises.append({
+                    "type": "全称量词",
+                    "claim": f"主张对「{u}」涵盖的全部成员成立",
+                    "缺省": "全称命题需穷尽或抽样验证，未声明样本范围"})
+                break
+        for g in self.GROUP_WORDS:
+            if g in text:
+                premises.append({
+                    "type": "群体范畴",
+                    "claim": f"「{g}」被当作同质群体",
+                    "缺省": "未定义群体边界与组内异质性"})
+                break
+        for m in self.MEASURE_WORDS:
+            if m in text:
+                premises.append({
+                    "type": "度量定义",
+                    "claim": f"「{m}」被当作可测度量",
+                    "缺省": f"未给出「{m}」的操作化定义与测量工具"})
+                break
+        for c in self.CAUSAL_WORDS:
+            if c in text:
+                premises.append({
+                    "type": "因果声称",
+                    "claim": f"断言了因果方向（含「{c}」）",
+                    "缺省": "未排除逆向因果与第三变量"})
+                break
+        if not premises:
+            premises.append({
+                "type": "无条件声称",
+                "claim": "主张未声明比较/量词/群体/度量/因果结构",
+                "缺省": "违反 0.0.1 信息条件性：无条件的声称无有效范围"})
+        return premises
+
+    def _condition_card(self, text, premises):
+        """从前提集构造条件卡：识别群体范畴/度量定义/比较结构等类型并抽取度量词。"""
+        has_group = any(p["type"] == "群体范畴" for p in premises)
+        has_measure = any(p["type"] == "度量定义" for p in premises)
+        has_cmp = any(p["type"] == "比较结构" for p in premises)
+        measure_term = ""
+        for p in premises:
+            if p["type"] == "度量定义":
+                i = p["claim"].find("「")
+                j = p["claim"].find("」")
+                if i >= 0 and j > i:
+                    measure_term = p["claim"][i + 1:j]
+                break
+        if has_measure and measure_term:
+            tool = f"「{measure_term}」的测量工具未定义"
+        elif has_measure:
+            tool = "未声明观测工具（无测量手段）"
+        else:
+            tool = "文本语义分析（启发式）"
+        card = {
+            "observation_position": "群体层面（比较/群体句）" if (has_group or has_cmp)
+                                    else "未声明观测位置",
+            "observation_tool": tool,
+            "time_window": "未声明（无时间窗口）",
+            "existence_constraint": "统计要求（样本/显著性/效应量）未提供"
+                                    if (has_group or has_cmp) else "未声明存在约束",
+        }
+        return card
+
+    def _t_identify(self, premises):
+        """识别操作测试：列出当前前提已识别的类型与缺省说明。"""
+        return {"status": "缺口" if premises else "ok",
+                "found": [p["type"] for p in premises],
+                "detail": [f"{p['type']}：{p['缺省']}" for p in premises]}
+
+    def _t_declare(self, card):
+        """声明操作测试：扫描条件卡中未声明的项并汇总缺口。"""
+        gaps = [k for k, v in card.items() if "未" in str(v) or "未声明" in str(v)]
+        return {"status": "gap" if gaps else "ok",
+                "card": card, "gaps": gaps}
+
+    def _t_switch(self, text, premises):
+        """切换操作测试：群体/比较结构切换到个体空间时给出失效空间警示。"""
+        if any(p["type"] in ("群体范畴", "比较结构") for p in premises):
+            return {"status": "失效空间",
+                    "note": "群体层面的统计主张切换到个体空间后失去预测力（群体均值不对个体下结论）；"
+                            "主张仅在群体层面有意义，且需统计支持"}
+        return {"status": "ok", "note": "未识别群体/比较结构，切换操作无新增信息"}
+
+    def _t_combine(self, text, premises):
+        """组合操作测试：存在复合度量时要求按领域子空间分解验证。"""
+        if any(p["type"] == "度量定义" for p in premises):
+            return {"status": "需分解",
+                    "note": "单一度量掩盖子领域差异：主张需按领域子空间分解后逐域验证（组合操作），"
+                            "如语言/空间/数学能力各有独立分布"}
+        return {"status": "ok", "note": "无复合度量，组合操作无新增信息"}
+
+    def _t_separate(self, text, premises):
+        """分离操作测试：缺控制变量时声明剥离预设后无法判断混淆效应。"""
+        return {"status": "gap",
+                "note": "未提供控制变量（教育/文化/机会等混淆变量）；剥离预设条件后"
+                        "剩余结构是否自洽无法判断——观察到的差异可能是混淆变量的效应"}
+
+    def _t_invert(self, text, premises):
+        """反转操作测试：因果声称需排除逆向因果与第三变量，比较结构需补充证据。"""
+        if any(p["type"] == "因果声称" for p in premises):
+            return {"status": "需证据",
+                    "note": "因果方向非唯一：需排除逆向因果与第三变量；"
+                            "若观测差异随条件反向波动，原因果方向被逆转假设取代"}
+        if any(p["type"] == "比较结构" for p in premises):
+            return {"status": "需证据",
+                    "note": "比较结论随条件空间波动：若在均等条件下差异不返回，"
+                            "原比较方向不是唯一解释"}
+        return {"status": "ok", "note": "无因果/比较结构，逆转操作无新增信息"}
+
+    def _t_cycle(self, text, premises):
+        """循环操作测试：要求完整观测周期（测→干预均等→再测）作为闭合判据。"""
+        return {"status": "需证据",
+                "note": "需完整观测周期（测→干预均等条件→再测）：若条件均等后差异不返回，"
+                        "则结论不闭合——循环测试是结构稳定的最终判据"}
+
+    def _verdict(self, knowledge, premises, card, tests):
+        """七测汇总裁决：按缺口/需证据/通过计数与无条件声称给出最终验证状态。"""
+        n_gap = sum(1 for t in tests.values() if t["status"] in ("gap", "缺口"))
+        n_need = sum(1 for t in tests.values() if t["status"] == "需证据")
+        n_ok = sum(1 for t in tests.values() if t["status"] == "ok")
+        unconditional = any(p["type"] == "无条件声称" for p in premises)
+        if unconditional:
+            status = "未验证（结构性缺陷）"
+        elif n_gap > 0:
+            status = "未验证（条件依赖）"
+        else:
+            status = "待证据（结构完整，缺实证）"
+        return {
+            "status": status,
+            "成立条件": "仅在完整声明条件空间（度量/样本/显著性/时间窗口）之后，"
+                        "才可在其覆盖范围内部分评估",
+            "失效条件": "个体空间无意义；条件均等时可能不闭合；剥离混淆变量后可能不成立",
+            "测试摘要": f"七操作完成：{n_gap} 项指出缺口 / {n_need} 项需证据 / {n_ok} 项结构完整",
+            "锚定建议": "判定应锚定图谱已验证条目：概率论（统计显著性要求）、"
+                        "存在论（无条件声明无效）、信息论（度量与信息差定义）",
+        }
+
+    # ---- 学科对战（S-对战1+2 · 条件卡对比 + 关系推导 + 相克判定） ----
+
+    def _resolve_entry(self, ref):
+        """按 id 或名称解析条目节点。"""
+        if not ref:
+            return None
+        n = self.store.get_node(ref)
+        if n is not None:
+            return n
+        for node in self.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=500):
+            if node.state_attributes.get("name") == ref:
+                return node
+        return None
+
+    def dex_battle(self, a_ref, b_ref):
+        """学科对战：互相识别对方条件卡 → 四要素对比 → 依赖/互斥/包含判定 → 相克。"""
+        A = self._resolve_entry(a_ref)
+        B = self._resolve_entry(b_ref)
+        if A is None or B is None:
+            return {"error": "entry_not_found", "a": a_ref, "b": b_ref}
+        ca = json.loads(A.condition_space.to_json())
+        cb = json.loads(B.condition_space.to_json())
+        comparison = {}
+        for e in ("observation_position", "observation_tool",
+                  "time_window", "existence_constraint"):
+            comparison[e] = {"A": ca.get(e), "B": cb.get(e),
+                             "relation": self._compare_element(e, ca.get(e), cb.get(e))}
+        relations = self._derive_relations(A, B, comparison)
+        clash = self._clash(A, B)
+        return {
+            "A": {"id": A.id, "name": A.state_attributes.get("name"), "claim": A.content},
+            "B": {"id": B.id, "name": B.state_attributes.get("name"), "claim": B.content},
+            "comparison": comparison, "relations": relations, "clash": clash}
+
+    def dex_layer_trace(self, direction="both"):
+        """协议分层链（P24）：正向展开（L0→L3）/ 逆向还原（L3→L0）。
+        条件逆转=沿条件空间反方向追溯信息源（设计者视角切换即一种条件逆转）。"""
+        layers = {}
+        for n in self.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=500):
+            for t in n.tags:
+                if t.startswith("pl:L") and t[4:].isdigit():
+                    lv = int(t[4:])
+                    layers[lv] = {"level": f"L{lv}",
+                                  "name": n.state_attributes.get("name"), "id": n.id}
+        chain = [layers[i] for i in sorted(layers)]
+        forward = [c["name"] for c in chain]
+        return {"正向展开": " → ".join(forward),
+                "逆向还原": " → ".join(forward[::-1]),
+                "chain": chain,
+                "note": "条件逆转=沿条件空间反方向追溯信息源（设计者视角切换即一种条件逆转）；"
+                        "周期运动=沿可重复路径循环观测，每周期带新信息回到起点（协议 1.10 生命周期即周期运动）"}
+
+    def dex_sandbox(self, a_ref, b_ref, disturbance="", record=True):
+        """学科沙盒（P26/P27 动态图鉴）：对两个学科的条件空间施加同一扰动，
+        生成边界测试报告并归档为观测层节点（动态档案·闭环）。"""
+        A, B = self._resolve_entry(a_ref), self._resolve_entry(b_ref)
+        if not A or not B:
+            return {"error": "entry_not_found", "a": a_ref, "b": b_ref}
+        if not disturbance.strip():
+            return {"error": "disturbance_required"}
+        report = {}
+        for entry in (A, B):
+            name = entry.state_attributes.get("name")
+            c2 = entry.state_attributes.get("card2") or {}
+            roles = {"existence_preset": "核心：存在预设",
+                     "irreducible_start": "核心：不可约起点",
+                     "observation_method": "结构：观测方式",
+                     "time_causality": "结构：时间因果",
+                     "condition_boundary": "结构：条件边界"}
+            hits = []
+            for key, role in roles.items():
+                text = c2.get(key, "")
+                if text:
+                    s = self._overlap(disturbance, text)
+                    if s > 0.15:
+                        hits.append({"element": role, "score": round(s, 2)})
+            if not hits:
+                status, note, needs = "稳定", "扰动未触及该学科的条件空间（启发式推演）", False
+            elif any("核心" in h["element"] for h in hits):
+                status, note, needs = "瓦解", "扰动命中核心预设/不可约起点（启发式推演）", True
+            else:
+                status, note, needs = "需修正", "扰动命中结构边界/观测方式（启发式推演）", True
+            suggested = ""
+            if needs:
+                suggested = (f"需在识别卡补充边界声明：在条件『{disturbance}』下本学科条件空间"
+                             f"{'不成立' if status == '瓦解' else '受扰'}——建议附加限制或标注边界偏移")
+            report[name] = {"status": status, "note": note, "hits": hits,
+                            "测试条件": disturbance,
+                            "边界偏移": [h["element"] for h in hits] or "无",
+                            "是否需更新": needs, "建议修正": suggested}
+        rank = sorted(report, key=lambda n: {"瓦解": 0, "需修正": 1, "稳定": 2}
+                      .get(report[n]["status"], 1))
+        record_id = None
+        if record:
+            record_id = self._record_test(A, B, disturbance, report)
+        return {"disturbance": disturbance,
+                "A": A.state_attributes.get("name"),
+                "B": B.state_attributes.get("name"),
+                "report": report, "稳定性排序": rank,
+                "record_id": record_id,
+                "note": "学科沙盒=动态图鉴（P26）：条件空间在模拟扰动下是否维持自洽；"
+                        "边界测试报告已归档观测层（P27 动态档案·闭环）"}
+
+    def _record_test(self, A, B, disturbance, report):
+        """边界测试记录 → 观测层节点（P27：对战结果回流图鉴，动态校准起点）。"""
+        content = json.dumps({
+            "type": "边界测试记录", "disturbance": disturbance,
+            "A": A.state_attributes.get("name"), "B": B.state_attributes.get("name"),
+            "report": {k: {"status": v["status"], "是否需更新": v["是否需更新"],
+                           "建议修正": v["建议修正"]}
+                       for k, v in report.items()},
+        }, ensure_ascii=False)
+        cs = ConditionSpace(observation_position="学科沙盒",
+                            observation_tool="条件扰动推演",
+                            time_window=(0.0, 9999999999.0),
+                            existence_constraint=f"扰动：{disturbance}")
+        node = self.engine.add_perception(
+            content, modality="text", condition_space=cs,
+            importance=0.6,
+            tags=["观测层", "边界测试",
+                  f"domain:{A.state_attributes.get('name')}",
+                  f"domain:{B.state_attributes.get('name')}"])
+        for ent in (A, B):
+            self.engine.add_edge(ent.id, node.id, relation_type=EdgeType.SIMILAR,
+                                 confidence=0.7, condition_space=cs,
+                                 source_evidence="inferred")
+        return node.id
+
+    # ---- AI vs AI 自动边界测试（P28：无界面 · 条件空间交叉检验自动化） ----
+
+    MOVES = {
+        "物理学": [{"name": "宏观测量", "desc": "以测量结果作为物理实在的基准"},
+                   {"name": "观测极限", "desc": "追问不可观测处的物理状态"},
+                   {"name": "物质基底", "desc": "移除『物』后该学科是否仍成立"}],
+        "信息论": [{"name": "编码压缩", "desc": "信息不依赖语义，仅依赖编码与传输"},
+                   {"name": "语义剥离", "desc": "剥离信息内容只问传输效率"},
+                   {"name": "信道容量", "desc": "任何传输受信道容量约束"}],
+    }
+
+    def _moves(self, entry):
+        """条目条件检验招式：MOVES 表优先，缺省以不可约起点自动生成一条检验。"""
+        name = entry.state_attributes.get("name")
+        if name in self.MOVES:
+            return self.MOVES[name]
+        c2 = entry.state_attributes.get("card2") or {}
+        seed = c2.get("irreducible_start") or entry.content
+        return [{"name": f"{name}条件检验", "desc": seed[:40]}]
+
+    def _probe(self, defender, move_desc):
+        """单招测试（P24 四类结果）· 带命中文本细节（可用于反馈）。"""
+        c2 = defender.state_attributes.get("card2") or {}
+        roles = {"existence_preset": "核心：存在预设",
+                 "irreducible_start": "核心：不可约起点",
+                 "observation_method": "结构：观测方式",
+                 "time_causality": "结构：时间因果",
+                 "condition_boundary": "结构：条件边界"}
+        hits = []
+        for key, role in roles.items():
+            text = c2.get(key, "")
+            if text:
+                s = self._overlap(move_desc, text)
+                if s > 0.12:
+                    hits.append({"element": role, "score": round(s, 2),
+                                 "text": text[:80]})
+        if not hits:
+            if self._overlap(move_desc, defender.content) <= 0.05:
+                return {"status": "对抗无效", "hits": [],
+                        "note": f"两条件空间不重叠：招式「{move_desc[:20]}」与目标识别卡无概念交集，测试无效果（反馈：可扩大招式覆盖或调整表述）"}
+            return {"status": "稳定", "hits": [],
+                    "note": f"测试通过：招式「{move_desc[:20]}」未触及目标条件维度（反馈：确认该条件下边界稳固）"}
+        if any("核心" in h["element"] for h in hits):
+            return {"status": "崩溃", "hits": hits,
+                    "note": "内部不自洽（核心预设/不可约起点受扰）"}
+        return {"status": "边界暴露", "hits": hits,
+                "note": "出现偏移，偏移位置可标记"}
+
+    # 通用招式（P24：条件操作五式）
+    OPERATION_MOVES = [
+        {"name": "条件切换", "desc": "该学科在另一层级中是否仍然成立"},
+        {"name": "条件组合", "desc": "该学科在叠加另一学科时是否仍保持自洽"},
+        {"name": "条件分离", "desc": "该学科拆解到某个维度后是否仍然成立"},
+        {"name": "条件逆转", "desc": "该学科在反向追溯条件时是否出现偏移"},
+        {"name": "条件循环", "desc": "该学科在经历完整周期后是否回到原状态"},
+    ]
+
+    def dex_auto_test(self, a_ref, b_ref, archive=True):
+        """AI vs AI：学科招式 + 通用条件操作五式交替施压，四类结果判定，报告归档。"""
+        A, B = self._resolve_entry(a_ref), self._resolve_entry(b_ref)
+        if not A or not B:
+            return {"error": "entry_not_found", "a": a_ref, "b": b_ref}
+        na, nb = A.state_attributes.get("name"), B.state_attributes.get("name")
+        rounds = []
+        offsets = {}
+        stable = {}
+        for attacker, defender, label in ((A, B, f"{na}→{nb}"), (B, A, f"{nb}→{na}")):
+            moves = self._moves(attacker) + self.OPERATION_MOVES
+            for mv in moves:
+                r = self._probe(defender, mv["desc"])
+                entry = {"move": f"{label}: {mv['name']}", "target": defender.state_attributes.get("name"),
+                         "status": r["status"], "hits": r["hits"], "note": r.get("note", "")}
+                rounds.append(entry)
+                bucket = offsets if r["status"] in ("边界暴露", "崩溃") else stable
+                bucket.setdefault(defender.state_attributes.get("name"), []).append(mv["name"])
+        need_update = {k: v for k, v in offsets.items() if v}
+        compat, depend = {}, {}
+        for name in (na, nb):
+            against = [r for r in rounds if r["target"] == name]
+            held = sum(1 for r in against if r["status"] in ("稳定", "对抗无效"))
+            compat[name] = round(held / max(1, len(against)), 2)
+            depend[name] = round(len(offsets.get(name, [])) / max(1, len(against)), 2)
+        report = {
+            "测试学科": f"{na} vs {nb}",
+            "测试条件": [r["move"] for r in rounds],
+            "边界偏移观测": need_update,
+            "边界稳固观测": stable,
+            "兼容度": compat,
+            "依赖度": depend,
+            "图鉴更新建议": {k: f"需在识别卡补充边界声明：在 {v} 条件下受扰（{len(v)} 项）"
+                            for k, v in need_update.items()} if need_update else "无",
+            "record_id": None,
+        }
+        if archive:
+            content = json.dumps({"type": "AI边界测试记录", "report": {
+                "测试学科": report["测试学科"], "测试条件": report["测试条件"],
+                "边界偏移观测": need_update, "边界稳固观测": stable}}, ensure_ascii=False)
+            cs = ConditionSpace(observation_position="学科沙盒·自动互测",
+                                observation_tool="招式列表+条件操作五式交替施压",
+                                time_window=(0.0, 9999999999.0),
+                                existence_constraint=f"互测：{na} vs {nb}")
+            node = self.engine.add_perception(content, modality="text", condition_space=cs,
+                                              importance=0.65,
+                                              tags=["观测层", "边界测试", "自动互测",
+                                                    f"domain:{na}", f"domain:{nb}"])
+            for ent in (A, B):
+                self.engine.add_edge(ent.id, node.id, relation_type=EdgeType.SIMILAR,
+                                     confidence=0.7, condition_space=cs,
+                                     source_evidence="inferred")
+            report["record_id"] = node.id
+        return report
+
+    def _compare_element(self, element, va, vb):
+        """四要素对比：相同/包含/部分重叠/互斥/一方未声明/无关。"""
+        def norm(v):
+            if isinstance(v, (list, tuple)):
+                try:
+                    return tuple(float(x) for x in v)
+                except Exception:
+                    return str(v)
+            return str(v or "").strip()
+        na, nb = norm(va), norm(vb)
+        if isinstance(na, tuple) and isinstance(nb, tuple):
+            if na[1] <= nb[0] or nb[1] <= na[0]:
+                return "互斥（时间不重叠）"
+            return "兼容（时间重叠）"
+        if not na and not nb:
+            return "同为空白"
+        if not na or not nb:
+            return "一方未声明"
+        if na == nb:
+            return "相同"
+        if na in nb or nb in na:
+            return "包含（一方为另一方子集）"
+        if set(na) & set(nb):
+            return "部分重叠"
+        return "无关"
+
+    def _derive_relations(self, A, B, comparison):
+        """依赖/互斥/包含/独立 推导：边证据 + 条件卡证据。"""
+        rels = {}
+        na, nb = A.state_attributes.get("name"), B.state_attributes.get("name")
+        edges_ab = [e for e in self.store.get_outgoing_edges(A.id) if e.target_id == B.id]
+        edges_ba = [e for e in self.store.get_outgoing_edges(B.id) if e.target_id == A.id]
+        for edge, src, tgt in ((edges_ab[0], na, nb) if edges_ab else (None, None, None),):
+            if edge is not None:
+                note = edge.condition_space.existence_constraint or ""
+                if edge.relation_type == EdgeType.CAUSAL:
+                    if any(k in note for k in ("依赖", "基础", "基于")):
+                        rels["依赖"] = f"{src} 依赖 {tgt}（{note}）"
+                    else:
+                        rels["因果"] = f"{src} → {tgt}（{note}）"
+                elif edge.relation_type == EdgeType.SIMILAR:
+                    rels["相似"] = f"{src} ↔ {tgt}（{note}）"
+                elif edge.relation_type == EdgeType.OPPOSITE:
+                    rels["互斥"] = f"{src} 与 {tgt} 对立"
+        for edge, src, tgt in ((edges_ba[0], nb, na) if edges_ba else (None, None, None),):
+            if edge is not None and "相似" not in rels and "互斥" not in rels:
+                note = edge.condition_space.existence_constraint or ""
+                if edge.relation_type == EdgeType.CAUSAL and any(
+                        k in note for k in ("依赖", "基础", "基于")):
+                    rels["依赖"] = f"{src} 依赖 {tgt}（{note}）"
+        time_conflict = any(str(v.get("relation", "")).startswith("互斥")
+                            for v in comparison.values())
+        if time_conflict:
+            rels["互斥"] = "条件卡时间/约束互斥"
+        containment = [(k, v["relation"]) for k, v in comparison.items()
+                       if str(v.get("relation", "")).startswith("包含")]
+        if containment:
+            rels["包含"] = "条件卡存在子集关系（" + \
+                "; ".join(f"{k}:{r}" for k, r in containment) + "）"
+        if not rels:
+            rels["独立"] = "未检测到 依赖/互斥/包含 关系（当前图结构与条件卡证据下）"
+        return rels
+
+    def _clash(self, A, B):
+        """相克：A 的出招/相克文本是否命中 B 的主张（及反向）。启发式。"""
+        ra = A.state_attributes.get("response") or {}
+        rb = B.state_attributes.get("response") or {}
+        na, nb = A.state_attributes.get("name"), B.state_attributes.get("name")
+        a_kit = str(ra.get("counters", "")) + str(ra.get("action", ""))
+        b_kit = str(rb.get("counters", "")) + str(rb.get("action", ""))
+        result = {}
+        ah = self._overlap(a_kit, B.content)
+        bh = self._overlap(b_kit, A.content)
+        if ah > 0:
+            result[f"{na}克制{nb}"] = {"score": round(ah, 2),
+                                       "note": "A 的出招/相克文本命中 B 的主张（启发式）"}
+        if bh > 0:
+            result[f"{nb}克制{na}"] = {"score": round(bh, 2),
+                                       "note": "B 的出招/相克文本命中 A 的主张（启发式）"}
+        if not result:
+            result["互不克制"] = "出招/相克文本未命中对方主张（启发式）"
+        return result
+
+    HISTORY_RECORDS = [
+        {"报告编号": "BATTLE-2026-001", "日期": "2026-07-30", "测试学科": "物理学 vs 信息论",
+         "核心冲突点": ["信息载体依赖性（物理学边界暴露）",
+                       "热力学熵vs信息熵（互不兼容不冲突）",
+                       "观测者地位（对齐差异）",
+                       "还原论方向（颠倒边界）"],
+         "最终判定": {"稳定性": "信息论更稳定；物理学在信息论条件下偏移",
+                     "边界暴露": "物理学：信息载体依赖性/观测者预设/还原方向限制",
+                     "推荐标签": "信息论=推荐；物理学=稳定"},
+         "相关学科": ["物理学", "信息论"]},
+        {"报告编号": "BATTLE-2026-002", "日期": "2026-07-30", "测试学科": "物理学 vs 智能论",
+         "核心发现": ["合并状态=物理趋近点非理论缺陷",
+                     "信任贝叶斯更新存在延迟边界",
+                     "双方基底依赖不构成不对称（存在优先 vs 物质存在）",
+                     "智能论不依赖物理具体结论，但依赖物理世界可运行"],
+         "最终判定": {"稳定性": "双方均能承受跨层推演与叠压；物理层边界处退化为渐进趋近",
+                     "兼容度": "高（无结构冲突）",
+                     "依赖度": "智能论不依赖物理结论，依赖物理可运行；物理不依赖智能论",
+                     "推荐标签": "智能论=推荐；物理学=稳定"},
+         "相关学科": ["物理学", "智能论"]},
+        {"报告编号": "BATTLE-2026-003", "日期": "2026-07-31",
+         "测试学科": "条件论 vs 智能论（同源版本A/B 内部对战）",
+         "核心发现": ["跨层稳定性：版本A 显著优于 B（B 在社会层偏移、形式层不稳定）",
+                     "崩塌自识别：双方剥离存在优先均崩塌，但 A 能识别崩塌过程，B 不能",
+                     "可逆操作：A 可顺序颠倒（先条件识别后存在优先），B 无法进入",
+                     "循环闭合：A 完成完整周期，B 在负反馈与存在论之间断层"],
+         "最终判定": {"结论": "条件论=智能论的必要结构补全，非可剥离表述层",
+                     "定性": "同一结构在演化过程中分出的两个功能层（揭示已有结构而非添加功能）",
+                     "v1.1定位": "不是错，但缺少条件识别与切换这一关键结构"},
+         "相关学科": ["智能论", "条件论"]},
+        {"报告编号": "CONDITION-DECL-001", "日期": "2026-07-31", "类型": "学科声明",
+         "测试学科": "条件论基础声明 v1.0（学科编号 001）",
+         "核心内容": ["元学科补全：研究知识得以成立的条件空间结构",
+                     "与智能论：结构识别 vs 结构运行——不可分离，共同构成完整协议基底",
+                     "五类操作：条件切换/组合/分离/逆转/循环",
+                     "输出格式：识别卡 + 对战报告（固定字段）"],
+         "最终判定": {"结论": "已定稿，纳入协议理论体系（v2.0）",
+                     "定位": "协议内部存在论层的元观测位"},
+         "相关学科": ["条件论", "智能论"]},
+    ]
+
+    def seed_history(self):
+        """归档历史对战记录（观测层）：BATTLE-2026-001/002（标准报告模板 P31/P33）。"""
+        nodes = self.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=500)
+        if any("历史对战" in (n.tags or []) for n in nodes):
+            return {"status": "already_archived"}
+        archived = []
+        for rec in self.HISTORY_RECORDS:
+            content = json.dumps({"type": "历史对战记录", **rec}, ensure_ascii=False)
+            cs = ConditionSpace(observation_position="历史对战后复盘",
+                                observation_tool="固定招式顺序推演",
+                                time_window=(0.0, 9999999999.0),
+                                existence_constraint="报告由设计者对话历史产生（2026-07-30/31）")
+            rec_type = rec.get("类型", "历史对战")
+            tags = ["观测层", rec_type] + [f"domain:{n}" for n in rec["相关学科"]]
+            if rec_type == "历史对战":
+                tags.append("边界测试")
+            node = self.engine.add_perception(content, modality="text", condition_space=cs,
+                                              importance=0.7, tags=tags)
+            for name in rec["相关学科"]:
+                ent = self._resolve_entry(name)
+                if ent:
+                    self.engine.add_edge(ent.id, node.id, relation_type=EdgeType.SIMILAR,
+                                         confidence=0.8, condition_space=cs,
+                                         source_evidence="extracted")
+            archived.append({"报告编号": rec["报告编号"], "record_id": node.id})
+        return {"status": "archived", "records": archived}
+
+    def dex_homology(self, entry_ref, strip_concepts=None):
+        """内部同源性检验（P34）：版本A（完整）vs 版本B（剥离指定概念）对战中
+        检验「条件论是装饰还是必要结构」——添加功能还是揭示已有结构。"""
+        A = self._resolve_entry(entry_ref)
+        if not A:
+            return {"error": "entry_not_found", "entry": entry_ref}
+        concepts = strip_concepts or ["条件", "条件空间", "视角切换", "识别卡"]
+        na = A.state_attributes.get("name")
+        c2a = A.state_attributes.get("card2") or {}
+        c2b = {}
+        for k, v in c2a.items():
+            stripped = v
+            for c in concepts:
+                stripped = stripped.replace(c, "【剥离】")
+            c2b[k] = stripped
+
+        class _Mini:
+            pass
+
+        B = _Mini()
+        B.state_attributes = {"name": f"{na}（不含{concepts[0]}）", "card2": c2b}
+        B.content = A.content
+
+        results = {}
+        for label, ent in (("版本A(完整)", A), ("版本B(剥离)", B)):
+            results[label] = [{"move": mv["name"],
+                               "status": self._probe(ent, mv["desc"])["status"]}
+                              for mv in self.OPERATION_MOVES]
+
+        def off(rr):
+            return sum(1 for x in rr if x["status"] in ("边界暴露", "崩溃"))
+
+        a_off, b_off = off(results["版本A(完整)"]), off(results["版本B(剥离)"])
+        if a_off == 0 and b_off == 0:
+            conclusion = "两版本一致稳定——条件论是更高效的表达方式而非必要条件（智能论已隐含条件意识）"
+        elif b_off > a_off:
+            conclusion = "版本B(剥离)更不稳定——条件论是智能论的结构性补全，不可或缺"
+        else:
+            conclusion = "版本A更不稳定（异常）——需复核剥离是否失真"
+        return {"entry": na, "剥离概念": concepts,
+                "测试": results,
+                "偏移统计": {"版本A": a_off, "版本B": b_off},
+                "结论": conclusion,
+                "note": "内部同源性检验（P34）：条件论是装饰还是必要结构——添加功能还是揭示已有结构"}
+
+    def dex_standard_battle(self, a_ref, b_ref):
+        """标准对战报告（P31 格式）：双方条件空间对照 + 招式记录 + 冲突点 + 更新建议 + 最终判定。"""
+        A, B = self._resolve_entry(a_ref), self._resolve_entry(b_ref)
+        if not A or not B:
+            return {"error": "entry_not_found", "a": a_ref, "b": b_ref}
+        na, nb = A.state_attributes.get("name"), B.state_attributes.get("name")
+        c2a = A.state_attributes.get("card2") or {}
+        c2b = B.state_attributes.get("card2") or {}
+        dims = [("observation_position", "内嵌观测位"), ("existence_preset", "默认存在预设"),
+                ("irreducible_start", "不可约起点"), ("observation_method", "有效观测方式"),
+                ("time_causality", "时间与因果结构"), ("condition_boundary", "识别的条件边界"),
+                ("consistency", "自洽性评估"), ("protocol_mapping", "可映射协议概念")]
+        comparison = [{"维度": label, "A": c2a.get(k, "—"), "B": c2b.get(k, "—")}
+                      for k, label in dims]
+        at = self.dex_auto_test(a_ref, b_ref, archive=True)
+        moves_out = []
+        for attacker, defender, label in ((A, B, f"{na}→{nb}"), (B, A, f"{nb}→{na}")):
+            for mv in self._moves(attacker) + self.OPERATION_MOVES:
+                r = self._probe(defender, mv["desc"])
+                desc = r["note"]
+                if r["hits"]:
+                    det = "；".join(f"{h['element']}({h['score']})「{h['text']}」"
+                                    for h in r["hits"])
+                    desc += f"——命中：{det}"
+                moves_out.append({"招": f"{label}: {mv['name']}",
+                                  "目标": defender.state_attributes.get("name"),
+                                  "结果": r["status"],
+                                  "详细说明": desc, "命中明细": r["hits"]})
+        conflicts = {}
+        for m in moves_out:
+            if m["结果"] in ("边界暴露", "崩溃"):
+                conflicts.setdefault(m["目标"], []).append(
+                    {"招式": m["招"], "说明": m["详细说明"][:140]})
+        count = sum(1 for n in self.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=500)
+                    if "边界测试" in (n.tags or []))
+        return {
+            "报告编号": f"BATTLE-2026-{100 + count:03d}",
+            "对战双方": f"{na}（tier:{A.state_attributes.get('tier')}） vs "
+                        f"{nb}（tier:{B.state_attributes.get('tier')}）",
+            "一·双方条件空间对照": comparison,
+            "二·招式记录": moves_out,
+            "三·核心冲突点": conflicts,
+            "四·图鉴更新建议": at.get("图鉴更新建议"),
+            "五·最终判定": {
+                "稳定性排序": at.get("兼容度"),
+                "依赖度": at.get("依赖度"),
+                "边界暴露": at.get("边界偏移观测"),
+                "边界稳固": at.get("边界稳固观测"),
+                "record_id": at.get("record_id"),
+            },
+        }
+
+    def dex_usage(self):
+        """使用与稳定性档案（P29）：使用频次 × 边界偏移 → 热门筛选（训练家选择=校准信号）。"""
+        usage = {}
+        for n in self.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=500):
+            sa = n.state_attributes
+            if sa.get("kind") == "knowledge" and sa.get("name"):
+                usage[sa["name"]] = {"使用次数": n.access_count, "边界偏移": 0, "测试次数": 0}
+        for n in self.store.query_nodes(layer=MemoryLayer.KNOWLEDGE, limit=500):
+            tags = n.tags or []
+            if "观测层" in tags and "边界测试" in tags:
+                try:
+                    data = json.loads(n.content)
+                except Exception:
+                    continue
+                offs = (data.get("report") or {}).get("边界偏移观测") or {}
+                for name, moves in offs.items():
+                    if name in usage:
+                        usage[name]["边界偏移"] += len(moves)
+                        usage[name]["测试次数"] += 1
+        hot = []
+        for name, v in usage.items():
+            v["稳定性"] = round(1.0 - v["边界偏移"] / max(1, v["测试次数"] + 1), 2)
+            v["热度分"] = round(v["使用次数"] * 0.6 + v["稳定性"] * 100 * 0.4, 1)
+            st = v["稳定性"]
+            v["对战标签"] = ("推荐" if st >= 0.9 else
+                           ("稳定" if st >= 0.6 else
+                            ("易碎" if st >= 0.3 else "边界")))
+            hot.append({"name": name, **v})
+        hot.sort(key=lambda x: -x["热度分"])
+        return {"档案": hot,
+                "note": "热门=使用频次×稳定性（P29）：训练家选择是校准信号，数据持续回写图鉴——"
+                        "落地方式不是解释，是使用"}
+
+    @staticmethod
+    def _overlap(a, b):
+        """二字组重合度：交集规模 ÷ 较小集合规模（0~1）。"""
+        if not a or not b:
+            return 0.0
+        ka = set(a.lower())
+        kb = set(b.lower())
+        return len(ka & kb) / max(1.0, len(ka | kb))
+
+    @staticmethod
+    def _bigram_hit(query, doc):
+        """查询侧二元组命中率（灵枢式召回：len(qb & nb)/len(qb)）。
+
+        比单字符重叠更适合「查询短、文档长」：查询「记忆是怎么形成的」的
+        二元组与 trigger 的交集占查询二元组比例，避免被文档长度稀释。
+        """
+        if not query or not doc:
+            return 0.0
+
+        def bigrams(s):
+            s = "".join(s.split())
+            if len(s) <= 1:
+                return {s}
+            return {s[i:i + 2] for i in range(len(s) - 1)}
+
+        qb = bigrams(query)
+        nb = bigrams(doc)
+        if not qb:
+            return 0.0
+        return len(qb & nb) / len(qb)
+
+
+# ---------------------------------------------------------------------------
+# 冒烟测试
+# ---------------------------------------------------------------------------
+
+def smoke():
+    dex = ConditionDex(fresh=True)
+    dex.seed_base()
+
+    print("=" * 66)
+    print("智慧之书 · 冒烟测试")
+    print("=" * 66)
+    print("基底节点:", len(dex._by_name), "| 关系边:", len(BASE_RELATIONS))
+
+    print("\n[1] dex_filter 领域=智能论:")
+    for r in dex.dex_filter(domain="智能论"):
+        print("   ", r)
+
+    print("\n[2] dex_filter level_min=3, status=verified:")
+    for r in dex.dex_filter(level_min=3, status="verified"):
+        print("   ", r["name"], r["level"], r["status"])
+
+    print("\n[3] dex_respond 条件='如何判断一个知识体系是否成立':")
+    for r in dex.dex_respond("如何判断一个知识体系是否成立"):
+        print("   ", r)
+
+    print("\n[4] dex_combine 智能论 × 信息论:")
+    print("   ", dex.dex_combine(dex._by_name["智能论"], dex._by_name["信息论"]))
+
+    print("\n[5] dex_invert 智能论:")
+    inv = dex.dex_invert(dex._by_name["智能论"])
+    print("    失效条件:", inv["失效条件"])
+    print("    观察边界:", inv["观察边界"])
+
+    print("\n[6] dex_cycle 存在论:")
+    print("   ", dex.dex_cycle(dex._by_name["存在论"]))
+
+    print("\n[7] dex_analyze 外部知识='大语言模型的推理能力来自内部思维链（CoT）':")
+    r = dex.dex_analyze("大语言模型的推理能力来自内部思维链（CoT）")
+    print("    condition_card:", r["condition_card"])
+    print("    candidates:", r["candidates"])
+    print("    judgment:", r["judgment"])
+
+    print("\n[8] dex_status 条件论:")
+    st = dex.dex_status(dex._by_name["条件论"])
+    print("    ", st["name"], st["level"], st["status"], "| relations_out:", st["relations_out"])
+
+    dex.close()
+    print("\n冒烟通过 ✅  db:", DEFAULT_DB)
+
+
+if __name__ == "__main__":
+    smoke()