CIE-Unified

commit

bcde56d

parent

6f7caa7

author

im_wower

date

2026-04-01 09:55:46 +0800 CST

integration phase1: Branch B runtime核心复制 (12/12 tests pass)

1@@ -0,0 +1 @@
2+__pycache__/

1@@ -0,0 +1,7 @@
2+"""CIE — Cognitive Inference Engine"""
3+from .graph import Graph, Node, Edge
4+from .state import CIEState, AttentionPool
5+from .dynamics import Dynamics
6+from .runtime import CIERuntime
7+
8+__all__ = ['Graph', 'Node', 'Edge', 'CIEState', 'AttentionPool', 'Dynamics', 'CIERuntime']

  1@@ -0,0 +1,372 @@
  2+"""
  3+CIE Dynamics — 动力学引擎
  4+
  5+图上扩散、衰减、归巢、沉积——所有高层行为从底层流动规则自然导出。
  6+代码里只写流动规则，不写标签。
  7+"""
  8+
  9+import math
 10+import random
 11+from .graph import Graph
 12+from .state import CIEState
 13+
 14+
 15+class Dynamics:
 16+    """
 17+    动力学引擎——驱动 (φ, μ, J) 的演化。
 18+    
 19+    参数设计遵循"少参数、强解释性"原则。
 20+    """
 21+
 22+    def __init__(self, graph: Graph, state: CIEState):
 23+        self.graph = graph
 24+        self.state = state
 25+
 26+        # ── 系统级参数（约束层） ──
 27+        self.alpha_0 = 0.01       # 基础衰减率
 28+        self.beta_decay = 1.5     # 衰减指数（置信度越高衰减越慢）
 29+        self.diffusion_rate = 0.1 # 图上扩散速率 μ
 30+        self.asym_lambda = 0.05   # 非对称项系数 λ_dir
 31+        self.homing_lambda1 = 0.1 # 短程归巢力（→能力核）
 32+        self.homing_lambda2 = 0.02  # 长程归巢力（→锚点核）
 33+        self.anchor_epsilon = 0.005  # 锚点核阈值
 34+        self.sediment_threshold = 10  # 经验沉积阈值（激活次数）
 35+        self.skill_belt_threshold = 30  # 技能带固化阈值
 36+        self.merge_threshold = 40   # 能力核合并阈值
 37+        self.phi_damping = 0.02     # φ 全局阻尼——半杯水，不发散
 38+
 39+    # ── 图上扩散 ──
 40+
 41+    def diffuse_phi(self):
 42+        """
 43+        φ_new(v) = φ(v) + μ · (L_G φ)(v) + λ_dir · (W_fwd·φ - W_bwd·φ)(v) - damping·φ(v)
 44+        
 45+        L_G 是图拉普拉斯。没有维度，没有向量。
 46+        非对称项是旋度来源。
 47+        阻尼项防止 φ 无界增长——半杯水原则。
 48+        Laplacian 按度归一化，防止高权重边放大信号。
 49+        """
 50+        phi = self.state.phi
 51+        new_phi = {}
 52+        for node_id in self.graph.nodes:
 53+            lap = self.graph.laplacian_at(node_id, phi)
 54+            asym = self.graph.asymmetry_at(node_id, phi)
 55+            # 按节点度归一化，防止高权重累积放大
 56+            degree = len(self.graph.neighbors_all(node_id))
 57+            norm = max(degree, 1)
 58+            phi_v = phi.get(node_id, 0.0)
 59+            new_phi[node_id] = (
 60+                phi_v
 61+                + self.diffusion_rate * (lap / norm)
 62+                + self.asym_lambda * (asym / norm)
 63+                - self.phi_damping * phi_v  # 全局阻尼
 64+            )
 65+        self.state.phi.update(new_phi)
 66+        # Soft clamp: prevent phi divergence
 67+        max_phi = max((abs(v) for v in self.state.phi.values()), default=1.0)
 68+        if max_phi > 10.0:
 69+            scale = 10.0 / max_phi
 70+            for k in self.state.phi:
 71+                self.state.phi[k] *= scale
 72+
 73+    # ── 激活传播 ──
 74+
 75+    def propagate_mu(self):
 76+        """
 77+        激活沿图上的边传播：μ 从高激活节点流向邻居。
 78+        同时更新边流 J。
 79+        """
 80+        mu = self.state.mu
 81+        new_mu = dict(mu)  # copy
 82+        
 83+        for node_id in list(self.state.active_region):
 84+            mu_v = mu.get(node_id, 0.0)
 85+            if mu_v < 1e-10:
 86+                continue
 87+            
 88+            neighbors = self.graph.neighbors_fwd(node_id)
 89+            if not neighbors:
 90+                continue
 91+            
 92+            # 按边权重比例传播一部分激活
 93+            total_weight = sum(
 94+                self.graph.get_edge_weight(node_id, nb) for nb in neighbors
 95+            )
 96+            if total_weight < 1e-10:
 97+                continue
 98+
 99+            spread_ratio = 0.3  # 每步传播 30% 的激活
100+            spread_amount = mu_v * spread_ratio
101+
102+            for nb in neighbors:
103+                w = self.graph.get_edge_weight(node_id, nb)
104+                flow = spread_amount * (w / total_weight)
105+                new_mu[nb] = new_mu.get(nb, 0.0) + flow
106+                # 更新边流 J
107+                self.state.J[(node_id, nb)] = (
108+                    self.state.J.get((node_id, nb), 0.0) * 0.9 + flow
109+                )
110+                # 记录经验命中
111+                self.state.experience_hits[nb] = (
112+                    self.state.experience_hits.get(nb, 0) + 1
113+                )
114+                self.state.active_region.add(nb)
115+
116+            new_mu[node_id] = mu_v - spread_amount
117+
118+        self.state.mu.update(new_mu)
119+        # 清理极低激活
120+        dead = [n for n, v in self.state.mu.items() if v < 1e-10]
121+        for n in dead:
122+            self.state.mu[n] = 0.0
123+            self.state.active_region.discard(n)
124+
125+    # ── 行动释放 ──
126+
127+    def action_release(self, node_id: str) -> float:
128+        """
129+        u = o · c · φ(ε)
130+        纯乘法，无阈值。
131+        o: 能见度（|L_G φ| 的局部值）
132+        c: 置信度
133+        φ(ε): 残差势场
134+        """
135+        phi = self.state.phi
136+        # o = |L_G φ|(v) 归一化
137+        lap = abs(self.graph.laplacian_at(node_id, phi))
138+        o = min(lap, 10.0) / 10.0  # 归一化到 [0,1]
139+
140+        # c = Dirichlet 置信度
141+        c = self.state.get_confidence(node_id)
142+
143+        # φ(ε) = 势场值本身作为残差量度
144+        epsilon = abs(phi.get(node_id, 0.0))
145+
146+        return o * c * epsilon
147+
148+    # ── 自适应衰减 ──
149+
150+    def adaptive_decay(self):
151+        """
152+        α(x) = α₀ · (1 - c(x))^β · (1 / κ(x))
153+        
154+        锚点核不需要显式定义，它自己浮出来：
155+        锚点核 = { x : α(x) < ε }
156+        """
157+        new_anchors = set()
158+        decay_rates = []
159+        
160+        for node_id in list(self.graph.nodes):
161+            c = self.state.get_confidence(node_id)
162+            kappa = self.graph.convergence(node_id)
163+            
164+            # 自适应衰减率
165+            alpha = self.alpha_0 * ((1.0 - c) ** self.beta_decay) * (1.0 / kappa)
166+            
167+            # 衰减 φ
168+            old_phi = self.state.phi.get(node_id, 0.0)
169+            if abs(old_phi) > 1e-10:
170+                self.state.phi[node_id] = old_phi * (1.0 - alpha)
171+
172+            # 衰减 μ（更快）
173+            old_mu = self.state.mu.get(node_id, 0.0)
174+            if old_mu > 1e-10:
175+                decayed = old_mu * alpha * 3.0  # μ 衰减更快
176+                self.state.mu[node_id] = max(0.0, old_mu - decayed)
177+                if decayed > 1e-6:
178+                    self.state.attention.release(node_id, decayed)
179+                    self.state.decay_events.append({
180+                        'step': self.state.step_count,
181+                        'node': node_id,
182+                        'type': 'mu_decay',
183+                        'amount': decayed,
184+                        'alpha': alpha,
185+                    })
186+
187+            # 记录衰减率用于动态阈值
188+            decay_rates.append((node_id, alpha))
189+
190+        # 动态锚点阈值：取衰减率最低的 10%（最多50个）
191+        if decay_rates:
192+            decay_rates.sort(key=lambda x: x[1])
193+            cutoff = max(1, min(len(decay_rates) // 10, 50))
194+            threshold = decay_rates[min(cutoff, len(decay_rates)-1)][1] * 1.1
195+            threshold = max(threshold, 1e-6)  # 防止零阈值
196+            new_anchors = {nid for nid, a in decay_rates if a <= threshold}
197+
198+        self.state.anchor_nodes = new_anchors
199+
200+    # ── 三级归巢 ──
201+
202+    def homing(self):
203+        """
204+        dx_A/dt = F_task + λ₁·(能力核 - x_A) + λ₂·(锚点核 - x_A)
205+        
206+        无任务时 F_task = 0，激活核先被最近的能力核捕获，
207+        最终在锚点核引力场里稳定。
208+        """
209+        if not self.state.active_region:
210+            return
211+
212+        # 找最近的能力核
213+        ability_center_phi = {}
214+        for core_id, nodes in self.state.ability_cores.items():
215+            if nodes:
216+                ability_center_phi[core_id] = (
217+                    sum(self.state.phi.get(n, 0.0) for n in nodes) / len(nodes)
218+                )
219+
220+        # 锚点核中心
221+        anchor_center_phi = 0.0
222+        if self.state.anchor_nodes:
223+            anchor_center_phi = (
224+                sum(self.state.phi.get(n, 0.0) for n in self.state.anchor_nodes)
225+                / len(self.state.anchor_nodes)
226+            )
227+
228+        for node_id in list(self.state.active_region):
229+            phi_v = self.state.phi.get(node_id, 0.0)
230+            
231+            # 短程归巢——拉向最近的能力核
232+            pull1 = 0.0
233+            nearest_core = None
234+            min_dist = float('inf')
235+            for core_id, center in ability_center_phi.items():
236+                dist = abs(center - phi_v)
237+                if dist < min_dist:
238+                    min_dist = dist
239+                    nearest_core = core_id
240+                    pull1 = self.homing_lambda1 * (center - phi_v)
241+
242+            # 长程归巢——拉向锚点核
243+            pull2 = self.homing_lambda2 * (anchor_center_phi - phi_v)
244+
245+            # 更新 phi
246+            self.state.phi[node_id] = phi_v + pull1 + pull2
247+
248+            # 归巢也微弱影响 mu：向能力核方向的节点获得微量激活
249+            if nearest_core and nearest_core in self.state.ability_cores:
250+                for cn in list(self.state.ability_cores[nearest_core])[:3]:
251+                    if cn != node_id:
252+                        self.state.mu[cn] = self.state.mu.get(cn, 0.0) + abs(pull1) * 0.01
253+
254+            if nearest_core:
255+                self.state.bound_ability_core = nearest_core
256+
257+    # ── 经验沉积 ──
258+
259+    def sediment(self):
260+        """
261+        沉积路径：记忆层 → 经验层 → 技能带 → 能力核
262+        
263+        使用 experience_hits 检测，但引入"最近沉积步数"避免饱和：
264+        只有当 hits 在最近 window 步内增长了才记录新的 trace。
265+        """
266+        window = 50  # 滑动窗口：最近50步内的新增才算
267+        last_sed_hits = getattr(self, "_last_sed_hits", {})
268+        
269+        for node_id, hits in list(self.state.experience_hits.items()):
270+            # 检查该节点上次沉积时的 hits
271+            prev_hits = last_sed_hits.get(node_id, 0)
272+            recent_growth = hits - prev_hits
273+            
274+            # 记忆层 → 经验层
275+            if hits >= self.sediment_threshold:
276+                if 'experience' not in self.state.experience_regions:
277+                    self.state.experience_regions['experience'] = set()
278+                if node_id not in self.state.experience_regions['experience']:
279+                    self.state.experience_regions['experience'].add(node_id)
280+                    self.state.sedimentation_trace.append({
281+                        'step': self.state.step_count,
282+                        'node': node_id,
283+                        'transition': 'memory -> experience',
284+                        'hits': hits,
285+                    })
286+                    last_sed_hits[node_id] = hits
287+
288+            # 经验层 → 技能带候选（需要持续增长）
289+            if hits >= self.skill_belt_threshold:
290+                old_score = self.state.skill_belt_candidates.get(node_id, 0.0)
291+                new_score = hits / self.merge_threshold
292+                if new_score > old_score + 0.05:  # 需要显著增长
293+                    self.state.skill_belt_candidates[node_id] = new_score
294+                    if old_score == 0.0:
295+                        self.state.sedimentation_trace.append({
296+                            'step': self.state.step_count,
297+                            'node': node_id,
298+                            'transition': 'experience -> skill_belt',
299+                            'hits': hits,
300+                        })
301+                    last_sed_hits[node_id] = hits
302+
303+            # 技能带 → 能力核（需要持续增长，且最近有新激活）
304+            if hits >= self.merge_threshold and recent_growth >= self.sediment_threshold:
305+                merged = False
306+                for core_id, core_nodes in self.state.ability_cores.items():
307+                    for cn in list(core_nodes):
308+                        if (self.graph.get_edge_weight(node_id, cn) > 0 or
309+                            self.graph.get_edge_weight(cn, node_id) > 0):
310+                            core_nodes.add(node_id)
311+                            self.state.merge_events.append({
312+                                'step': self.state.step_count,
313+                                'node': node_id,
314+                                'core': core_id,
315+                                'transition': 'skill_belt -> ability_core',
316+                            })
317+                            merged = True
318+                            break
319+                    if merged:
320+                        break
321+
322+                if not merged:
323+                    core_id = f'core_{len(self.state.ability_cores)}'
324+                    self.state.ability_cores[core_id] = {node_id}
325+                    self.state.merge_events.append({
326+                        'step': self.state.step_count,
327+                        'node': node_id,
328+                        'core': core_id,
329+                        'transition': 'new_ability_core',
330+                    })
331+                last_sed_hits[node_id] = hits
332+        
333+        if not hasattr(self, '_last_sed_hits'):
334+            self._last_sed_hits = {}
335+        self._last_sed_hits.update(last_sed_hits)
336+
337+    # ── 边流衰减 ──
338+
339+    def decay_edges(self):
340+        """边流 J 自然衰减"""
341+        dead_edges = []
342+        for edge_key, flow in self.state.J.items():
343+            new_flow = flow * (1.0 - self.alpha_0 * 0.5)
344+            if abs(new_flow) < 1e-10:
345+                dead_edges.append(edge_key)
346+            else:
347+                self.state.J[edge_key] = new_flow
348+        for k in dead_edges:
349+            del self.state.J[k]
350+
351+    # ── 完整的一步 ──
352+
353+    def step(self):
354+        """
355+        一个完整的动力学步骤：
356+        1. 图上扩散
357+        2. 激活传播
358+        3. 自适应衰减
359+        4. 归巢
360+        5. 沉积检测
361+        6. 边流衰减
362+        7. 更新输出模式
363+        """
364+        self.diffuse_phi()
365+        self.propagate_mu()
366+        self.adaptive_decay()
367+        # 置信度自然衰减——遗忘是可塑性的必要条件
368+        self.state.decay_all_confidence(rate=0.002)
369+        self.homing()
370+        self.sediment()
371+        self.decay_edges()
372+        self.state.update_output_mode()
373+        self.state.step_count += 1

  1@@ -0,0 +1,243 @@
  2+"""
  3+CIE Graph — 图原生拓扑结构
  4+
  5+图是纯拓扑，无维度。节点和边的连接关系是唯一本体。
  6+权重非对称：W_fwd(u,v) != W_bwd(v,u)，这是旋度/极限环的来源。
  7+"""
  8+
  9+from collections import defaultdict
 10+import math
 11+import random
 12+
 13+
 14+class Node:
 15+    """图上的一个节点——概念、经验片段、动作原语、感知特征。"""
 16+    __slots__ = ('id', 'label', 'meta')
 17+
 18+    def __init__(self, node_id: str, label: str = '', meta: dict = None):
 19+        self.id = node_id
 20+        self.label = label or node_id
 21+        self.meta = meta or {}
 22+
 23+    def __repr__(self):
 24+        return f'Node({self.id!r})'
 25+
 26+    def __hash__(self):
 27+        return hash(self.id)
 28+
 29+    def __eq__(self, other):
 30+        return isinstance(other, Node) and self.id == other.id
 31+
 32+
 33+class Edge:
 34+    """
 35+    有向边。权重非对称是关键——对称矩阵→不动点(知识)，
 36+    非对称矩阵→极限环(技能)。
 37+    """
 38+    __slots__ = ('src', 'dst', 'weight', 'edge_type', 'meta')
 39+
 40+    def __init__(self, src: str, dst: str, weight: float = 1.0,
 41+                 edge_type: str = 'default', meta: dict = None):
 42+        self.src = src
 43+        self.dst = dst
 44+        self.weight = weight
 45+        self.edge_type = edge_type
 46+        self.meta = meta or {}
 47+
 48+    def __repr__(self):
 49+        return f'Edge({self.src}->{self.dst}, w={self.weight:.3f})'
 50+
 51+
 52+class Graph:
 53+    """
 54+    图原生拓扑结构。
 55+    
 56+    - adjacency list 存储
 57+    - 非对称权重：fwd_edges[src][dst] 和 bwd_edges[dst][src] 独立
 58+    - 支持节点/边的增删
 59+    - 提供图拉普拉斯 L_G 计算
 60+    """
 61+
 62+    def __init__(self):
 63+        self.nodes: dict[str, Node] = {}
 64+        # fwd_edges[src][dst] = Edge (正向)
 65+        self.fwd_edges: dict[str, dict[str, Edge]] = defaultdict(dict)
 66+        # bwd_edges[dst][src] = Edge (反向，权重独立)
 67+        self.bwd_edges: dict[str, dict[str, Edge]] = defaultdict(dict)
 68+
 69+    @property
 70+    def node_count(self) -> int:
 71+        return len(self.nodes)
 72+
 73+    @property
 74+    def edge_count(self) -> int:
 75+        return sum(len(d) for d in self.fwd_edges.values())
 76+
 77+    # ── 节点操作 ──
 78+
 79+    def add_node(self, node_id: str, label: str = '', meta: dict = None) -> Node:
 80+        if node_id in self.nodes:
 81+            return self.nodes[node_id]
 82+        node = Node(node_id, label, meta)
 83+        self.nodes[node_id] = node
 84+        return node
 85+
 86+    def has_node(self, node_id: str) -> bool:
 87+        return node_id in self.nodes
 88+
 89+    def get_node(self, node_id: str) -> Node | None:
 90+        return self.nodes.get(node_id)
 91+
 92+    def remove_node(self, node_id: str):
 93+        if node_id not in self.nodes:
 94+            return
 95+        del self.nodes[node_id]
 96+        # 清理相关边
 97+        if node_id in self.fwd_edges:
 98+            for dst in list(self.fwd_edges[node_id]):
 99+                self.bwd_edges[dst].pop(node_id, None)
100+            del self.fwd_edges[node_id]
101+        if node_id in self.bwd_edges:
102+            for src in list(self.bwd_edges[node_id]):
103+                self.fwd_edges[src].pop(node_id, None)
104+            del self.bwd_edges[node_id]
105+
106+    # ── 边操作 ──
107+
108+    def add_edge(self, src: str, dst: str, weight: float = 1.0,
109+                 bwd_weight: float | None = None,
110+                 edge_type: str = 'default', meta: dict = None):
111+        """
112+        添加有向边。bwd_weight 若为 None 则等于 weight（对称）。
113+        非对称权重是产生旋度/极限环的关键。
114+        """
115+        # 自动创建节点
116+        self.add_node(src)
117+        self.add_node(dst)
118+
119+        fwd_edge = Edge(src, dst, weight, edge_type, meta)
120+        self.fwd_edges[src][dst] = fwd_edge
121+
122+        bw = bwd_weight if bwd_weight is not None else weight
123+        bwd_edge = Edge(dst, src, bw, edge_type, meta)
124+        self.bwd_edges[dst][src] = bwd_edge
125+
126+    def get_edge_weight(self, src: str, dst: str) -> float:
127+        """获取 src->dst 的正向权重"""
128+        if src in self.fwd_edges and dst in self.fwd_edges[src]:
129+            return self.fwd_edges[src][dst].weight
130+        return 0.0
131+
132+    def get_bwd_weight(self, dst: str, src: str) -> float:
133+        """获取 dst<-src 的反向权重"""
134+        if dst in self.bwd_edges and src in self.bwd_edges[dst]:
135+            return self.bwd_edges[dst][src].weight
136+        return 0.0
137+
138+    def neighbors_fwd(self, node_id: str) -> list[str]:
139+        """正向邻居"""
140+        return list(self.fwd_edges.get(node_id, {}).keys())
141+
142+    def neighbors_bwd(self, node_id: str) -> list[str]:
143+        """反向邻居（谁指向我）"""
144+        return list(self.bwd_edges.get(node_id, {}).keys())
145+
146+    def neighbors_all(self, node_id: str) -> set[str]:
147+        """所有邻居（不分方向）"""
148+        fwd = set(self.fwd_edges.get(node_id, {}).keys())
149+        bwd = set(self.bwd_edges.get(node_id, {}).keys())
150+        return fwd | bwd
151+
152+    # ── 图拉普拉斯 ──
153+
154+    def laplacian_at(self, node_id: str, phi: dict[str, float]) -> float:
155+        """
156+        计算节点 node_id 处的图拉普拉斯 (L_G φ)(v)。
157+        L_G φ(v) = Σ_u w(u,v) * (φ(u) - φ(v))
158+        只需邻接关系，无维度。
159+        """
160+        if node_id not in self.nodes:
161+            return 0.0
162+
163+        phi_v = phi.get(node_id, 0.0)
164+        result = 0.0
165+
166+        # 正向邻居贡献
167+        for dst, edge in self.fwd_edges.get(node_id, {}).items():
168+            result += edge.weight * (phi.get(dst, 0.0) - phi_v)
169+
170+        # 反向邻居贡献
171+        for src, edge in self.bwd_edges.get(node_id, {}).items():
172+            result += edge.weight * (phi.get(src, 0.0) - phi_v)
173+
174+        return result
175+
176+    def asymmetry_at(self, node_id: str, phi: dict[str, float]) -> float:
177+        """
178+        计算非对称项 (W_fwd·φ - W_bwd·φ)(v)。
179+        这是旋度的来源——如果 fwd 和 bwd 权重一样，此项为零。
180+        """
181+        if node_id not in self.nodes:
182+            return 0.0
183+
184+        result = 0.0
185+        # 对于每条边 (node_id, dst)
186+        for dst, fwd_edge in self.fwd_edges.get(node_id, {}).items():
187+            bwd_w = self.get_bwd_weight(node_id, dst)
188+            result += (fwd_edge.weight - bwd_w) * phi.get(dst, 0.0)
189+
190+        return result
191+
192+    # ── 环流/旋度 ──
193+
194+    def circulation(self, path: list[str]) -> float:
195+        """
196+        计算闭合路径的环流 Σ J(u,v)。
197+        非零环流 = 旋度 ≠ 0 = 技能/极限环。
198+        path 应为闭合的：[a, b, c, a]
199+        """
200+        if len(path) < 2:
201+            return 0.0
202+        total = 0.0
203+        for i in range(len(path) - 1):
204+            total += self.get_edge_weight(path[i], path[i + 1])
205+        return total
206+
207+    # ── 路径汇聚度 κ ──
208+
209+    def convergence(self, node_id: str) -> float:
210+        """
211+        路径汇聚度 κ(v) = 有多少条不同路径经过此节点。
212+        近似为入度+出度的几何均值，避免零值。
213+        """
214+        in_deg = len(self.bwd_edges.get(node_id, {}))
215+        out_deg = len(self.fwd_edges.get(node_id, {}))
216+        return math.sqrt(max(in_deg, 1) * max(out_deg, 1))
217+
218+    # ── 序列化 ──
219+
220+    def to_dict(self) -> dict:
221+        return {
222+            'nodes': {nid: {'label': n.label, 'meta': n.meta}
223+                      for nid, n in self.nodes.items()},
224+            'edges': [
225+                {'src': e.src, 'dst': e.dst, 'weight': e.weight,
226+                 'bwd_weight': self.get_bwd_weight(e.src, e.dst),
227+                 'type': e.edge_type}
228+                for src_edges in self.fwd_edges.values()
229+                for e in src_edges.values()
230+            ]
231+        }
232+
233+    @classmethod
234+    def from_dict(cls, data: dict) -> 'Graph':
235+        g = cls()
236+        for nid, info in data.get('nodes', {}).items():
237+            g.add_node(nid, info.get('label', ''), info.get('meta'))
238+        for e in data.get('edges', []):
239+            g.add_edge(e['src'], e['dst'], e['weight'],
240+                       e.get('bwd_weight'), e.get('type', 'default'))
241+        return g
242+
243+    def __repr__(self):
244+        return f'Graph(nodes={self.node_count}, edges={self.edge_count})'

  1@@ -0,0 +1,307 @@
  2+"""
  3+CIE Runtime — 统一接口（SPEC §5）
  4+
  5+六个方法：ingest, step, emit, commit_feedback, snapshot_state, reset_session
  6+这是 Branch B 的工程稳健 runtime 实现。
  7+"""
  8+
  9+import random
 10+import math
 11+from typing import Optional
 12+from .graph import Graph
 13+from .state import CIEState
 14+from .dynamics import Dynamics
 15+
 16+
 17+class CIERuntime:
 18+    """
 19+    CIE 运行时——图原生认知推理引擎。
 20+    
 21+    Branch B 定位：工程稳健增强 runtime。
 22+    先能跑、先能验证、先能出结果。
 23+    """
 24+
 25+    def __init__(self, seed: int = None):
 26+        self.graph = Graph()
 27+        self.state = CIEState()
 28+        self.dynamics = Dynamics(self.graph, self.state)
 29+        self.rng = random.Random(seed)
 30+
 31+        # ── 输出缓冲 ──
 32+        self._output_buffer: list[dict] = []
 33+        self._last_output: Optional[dict] = None
 34+
 35+        # ── 回灌标记 ──
 36+        self._feedback_pending = False
 37+
 38+    # ──────────────────────────────────────
 39+    # §5.1 ingest — 接收输入，注入图中
 40+    # ──────────────────────────────────────
 41+
 42+    def ingest(self, input_data, context=None, anchors=None):
 43+        """
 44+        接收新的输入、上下文、可选锚点提示，注入图中。
 45+        
 46+        input_data: str 或 list[str]
 47+            - str: 文本，按字符拆分为 bigram 注入
 48+            - list[str]: 已分好的 token 列表
 49+        context: dict, optional
 50+            - 额外上下文信息
 51+        anchors: list[str], optional
 52+            - 锚点提示——谁、在哪、做什么
 53+        
 54+        输出即输入：如果有上一轮输出，自动回灌。
 55+        """
 56+        # ── 输出即输入回灌 ──
 57+        if self._last_output is not None and self._feedback_pending:
 58+            self._feedback_loop(self._last_output)
 59+            self._feedback_pending = False
 60+
 61+        # ── 解析输入为 token 序列 ──
 62+        if isinstance(input_data, str):
 63+            tokens = list(input_data)
 64+        elif isinstance(input_data, (list, tuple)):
 65+            tokens = list(input_data)
 66+        else:
 67+            tokens = [str(input_data)]
 68+
 69+        if not tokens:
 70+            return
 71+
 72+        # ── 并行归位：所有 token 同时注入图 ──
 73+        # "一把种子同时撒在图的不同层级上"
 74+        for token in tokens:
 75+            if not self.graph.has_node(token):
 76+                self.graph.add_node(token, label=token)
 77+                self.state.init_node(token, phi_val=self.rng.gauss(0.0, 0.1))
 78+
 79+            # 注入激活
 80+            inject_amount = 100.0 / max(len(tokens), 1) * 0.5  # 半杯水
 81+            self.state.activate(token, inject_amount)
 82+
 83+        # ── 建立 bigram 边（非对称） ──
 84+        for i in range(len(tokens) - 1):
 85+            src, dst = tokens[i], tokens[i + 1]
 86+            existing_w = self.graph.get_edge_weight(src, dst)
 87+            # 正向强化，反向弱化——产生非对称
 88+            asym = self.rng.gauss(0.0, 0.1)
 89+            self.graph.add_edge(
 90+                src, dst,
 91+                weight=existing_w + 1.0 / (1.0 + existing_w * 0.1) + abs(asym),
 92+                bwd_weight=existing_w + 1.0 / (1.0 + existing_w * 0.1) - abs(asym) * 0.5,
 93+                edge_type='bigram'
 94+            )
 95+
 96+        # ── 锚点注入 ──
 97+        if anchors:
 98+            for anchor in anchors:
 99+                if not self.graph.has_node(anchor):
100+                    self.graph.add_node(anchor, label=anchor)
101+                    self.state.init_node(anchor, phi_val=1.0)
102+                # 锚点高置信度
103+                self.state.update_confidence(anchor, 2, amount=10.0)  # 锚点/独立引用
104+                # 锚点高势场
105+                self.state.phi[anchor] = self.state.phi.get(anchor, 0.0) + 1.0
106+
107+        # ── 标记有输出需要回灌 ──
108+        self._feedback_pending = True
109+
110+    # ──────────────────────────────────────
111+    # §5.2 step — 推进动力学演化
112+    # ──────────────────────────────────────
113+
114+    def step(self, n: int = 1):
115+        """
116+        推进 n 步内部动力学演化。
117+        必须真实改变内部状态。
118+        """
119+        for _ in range(n):
120+            self.dynamics.step()
121+
122+    # ──────────────────────────────────────
123+    # §5.3 emit — 生成输出
124+    # ──────────────────────────────────────
125+
126+    def emit(self) -> dict:
127+        """
128+        生成当前输出。允许完整输出或降级输出。
129+        
130+        输出基于当前激活区域的行动释放值排序。
131+        半杯水也要能流，不等满了再倒。
132+        """
133+        self.state.update_output_mode()
134+
135+        # 计算每个活跃节点的行动释放
136+        releases = {}
137+        for node_id in self.state.active_region:
138+            u = self.dynamics.action_release(node_id)
139+            if u > 1e-10:
140+                releases[node_id] = u
141+
142+        # 按释放值排序
143+        sorted_nodes = sorted(releases.items(), key=lambda x: -x[1])
144+
145+        # 根据输出模式决定输出多少
146+        mode = self.state.output_mode
147+        if mode == 'full':
148+            top_nodes = sorted_nodes[:10]
149+        elif mode == 'degraded':
150+            top_nodes = sorted_nodes[:3]
151+        else:  # minimal
152+            top_nodes = sorted_nodes[:1]
153+
154+        output = {
155+            'mode': mode,
156+            'activated': [
157+                {
158+                    'node': nid,
159+                    'label': self.graph.get_node(nid).label if self.graph.get_node(nid) else nid,
160+                    'release': u,
161+                    'phi': self.state.phi.get(nid, 0.0),
162+                    'mu': self.state.mu.get(nid, 0.0),
163+                    'confidence': self.state.get_confidence(nid),
164+                }
165+                for nid, u in top_nodes
166+            ],
167+            'step': self.state.step_count,
168+            'attention_free': self.state.attention.free,
169+            'active_count': len(self.state.active_region),
170+        }
171+
172+        self._last_output = output
173+        self._output_buffer.append(output)
174+        return output
175+
176+    # ──────────────────────────────────────
177+    # §5.4 commit_feedback — 反馈写回
178+    # ──────────────────────────────────────
179+
180+    def commit_feedback(self, feedback: dict):
181+        """
182+        把反馈写回系统——经验沉积、技能带修正、能力核慢更新。
183+        
184+        feedback: dict
185+            - 'correct': list[str] — 正确的节点，增强置信度
186+            - 'wrong': list[str] — 错误的节点，降低置信度
187+            - 'reward': float — 全局奖励信号
188+        """
189+        effect = {'reinforced': [], 'weakened': [], 'reward': 0.0}
190+
191+        # 正确的节点：增强置信度(cat2=独立引用) + 势场
192+        for node_id in feedback.get('correct', []):
193+            if self.graph.has_node(node_id):
194+                self.state.update_confidence(node_id, 2, amount=2.0)
195+                self.state.phi[node_id] = (
196+                    self.state.phi.get(node_id, 0.0) + 0.5
197+                )
198+                effect['reinforced'].append(node_id)
199+
200+        # 错误的节点：衰减势场 + 削弱置信度
201+        for node_id in feedback.get('wrong', []):
202+            if self.graph.has_node(node_id):
203+                self.state.phi[node_id] = (
204+                    self.state.phi.get(node_id, 0.0) * 0.5
205+                )
206+                self.state.weaken_confidence(node_id, amount=3.0)
207+                effect['weakened'].append(node_id)
208+
209+        # 全局奖励
210+        reward = feedback.get('reward', 0.0)
211+        effect['reward'] = reward
212+        if reward > 0:
213+            # 正奖励强化当前激活区域——按已有最强分量方向增强
214+            for node_id in self.state.active_region:
215+                if node_id in self.state.confidence:
216+                    alphas = self.state.confidence[node_id]
217+                    best_cat = alphas.index(max(alphas))
218+                    self.state.update_confidence(node_id, best_cat, amount=reward)
219+                else:
220+                    self.state.update_confidence(node_id, 0, amount=reward)
221+        elif reward < 0:
222+            # 负奖励衰减当前激活区域（势场+置信度）
223+            for node_id in self.state.active_region:
224+                self.state.phi[node_id] *= max(0.1, 1.0 + reward)
225+                self.state.weaken_confidence(node_id, amount=abs(reward))
226+
227+        self.state.last_feedback_effect = effect
228+
229+    # ──────────────────────────────────────
230+    # §5.5 snapshot_state — 导出摘要
231+    # ──────────────────────────────────────
232+
233+    def snapshot_state(self) -> dict:
234+        """导出可比较的运行时摘要（SPEC §6）。"""
235+        state_snap = self.state.snapshot()
236+        state_snap['graph'] = {
237+            'node_count': self.graph.node_count,
238+            'edge_count': self.graph.edge_count,
239+        }
240+        return state_snap
241+
242+    # ──────────────────────────────────────
243+    # §5.6 reset_session — 清理会话态
244+    # ──────────────────────────────────────
245+
246+    def reset_session(self):
247+        """
248+        清理当前会话态，但不破坏长期结构层数据。
249+        保留：φ（地形）、ability_cores、anchor_nodes
250+        清理：μ（激活）、active_region、attention、output_buffer
251+        """
252+        # 清理激活
253+        for node_id in list(self.state.active_region):
254+            self.state.deactivate(node_id)
255+        self.state.mu = {k: 0.0 for k in self.state.mu}
256+        self.state.active_region.clear()
257+        self.state.attention = type(self.state.attention)(total=100.0)
258+
259+        # 清理边流
260+        self.state.J.clear()
261+
262+        # 清理输出缓冲
263+        self._output_buffer.clear()
264+        self._last_output = None
265+        self._feedback_pending = False
266+
267+        # 保留：phi, confidence, anchor_nodes, ability_cores,
268+        #        experience_hits, experience_regions, skill_belt_candidates
269+
270+        self.state.output_mode = 'minimal'
271+
272+    # ──────────────────────────────────────
273+    # 内部：输出即输入回灌
274+    # ──────────────────────────────────────
275+
276+    def _feedback_loop(self, last_output: dict):
277+        """
278+        输出即输入——上一轮的激活结果直接成为下一轮输入的一部分。
279+        不经过外部中转，闭合自指环路。
280+        """
281+        if not last_output or not last_output.get('activated'):
282+            return
283+
284+        # 把上一轮输出的节点作为弱输入回灌
285+        # 用 mu（激活量）而非 release（行动释放）——mu 是水量，release 是水压
286+        for item in last_output['activated']:
287+            node_id = item['node']
288+            if self.graph.has_node(node_id):
289+                mu_val = item.get('mu', 0.0)
290+                # 回灌量 = 上轮激活的 5%（衰减版）
291+                feedback_amount = mu_val * 0.05
292+                if feedback_amount > 0.001:
293+                    self.state.activate(node_id, feedback_amount)
294+                    # 极微增强 φ（水流过的地方地形被改变）
295+                    self.state.phi[node_id] = (
296+                        self.state.phi.get(node_id, 0.0) + feedback_amount * 0.01
297+                    )
298+
299+
300+    # ──────────────────────────────────────
301+    # 便利方法
302+    # ──────────────────────────────────────
303+
304+    def run(self, input_data, steps: int = 5, context=None, anchors=None) -> dict:
305+        """便利方法：ingest + step + emit 一条龙"""
306+        self.ingest(input_data, context=context, anchors=anchors)
307+        self.step(n=steps)
308+        return self.emit()

  1@@ -0,0 +1,271 @@
  2+"""
  3+CIE State — 三元组状态 (φ, μ, J) + 注意力池
  4+
  5+φ(v) = 节点势场（慢变）— 知识/地形
  6+μ(v) = 激活分布（快变）— 注意力/激活核位置  
  7+J(u,v) = 边流（中速）— 技能/流动偏置
  8+
  9+注意力池总量 100 点守恒。
 10+"""
 11+
 12+from collections import defaultdict
 13+import math
 14+import random
 15+from typing import Optional
 16+
 17+
 18+class AttentionPool:
 19+    """
 20+    注意力池——总量守恒，半杯水原则。
 21+    
 22+    总量 100 点。某区域要喷涌，必须从其他区域借调。
 23+    最优工作区间 40-60%。
 24+    """
 25+
 26+    def __init__(self, total: float = 100.0):
 27+        self.total = total
 28+        self.allocated: dict[str, float] = {}  # region_id -> allocated amount
 29+
 30+    @property
 31+    def used(self) -> float:
 32+        return sum(self.allocated.values())
 33+
 34+    @property
 35+    def free(self) -> float:
 36+        return max(0.0, self.total - self.used)
 37+
 38+    @property
 39+    def utilization(self) -> float:
 40+        return self.used / self.total if self.total > 0 else 0.0
 41+
 42+    def allocate(self, region_id: str, amount: float) -> float:
 43+        """分配注意力，返回实际分配量（可能因容量不足而减少）"""
 44+        actual = min(amount, self.free)
 45+        if actual > 0:
 46+            self.allocated[region_id] = self.allocated.get(region_id, 0.0) + actual
 47+        return actual
 48+
 49+    def release(self, region_id: str, amount: float = None) -> float:
 50+        """释放注意力，返回实际释放量"""
 51+        if region_id not in self.allocated:
 52+            return 0.0
 53+        current = self.allocated[region_id]
 54+        release_amt = min(amount, current) if amount is not None else current
 55+        self.allocated[region_id] = current - release_amt
 56+        if self.allocated[region_id] <= 1e-10:
 57+            del self.allocated[region_id]
 58+        return release_amt
 59+
 60+    def to_dict(self) -> dict:
 61+        return {
 62+            'total': self.total,
 63+            'used': self.used,
 64+            'free': self.free,
 65+            'utilization': self.utilization,
 66+            'allocated': dict(self.allocated)
 67+        }
 68+
 69+
 70+class CIEState:
 71+    """
 72+    CIE 运行时状态——(φ, μ, J) 三元组 + 注意力池。
 73+    
 74+    三核（锚点核、能力核、激活核）存在于同一张图上，
 75+    通过 φ、μ、J 的不同更新速率自然分化。
 76+    """
 77+
 78+    def __init__(self):
 79+        # ── 核心三元组 ──
 80+        self.phi: dict[str, float] = defaultdict(float)   # 节点势场（慢变）
 81+        self.mu: dict[str, float] = defaultdict(float)     # 激活分布（快变）
 82+        self.J: dict[tuple[str, str], float] = defaultdict(float)  # 边流（中速）
 83+
 84+        # ── 注意力池 ──
 85+        self.attention = AttentionPool(total=100.0)
 86+
 87+        # ── 置信度（Dirichlet） ──
 88+        # c[node_id] = list of K floats (Dirichlet alpha parameters)
 89+        self.confidence: dict[str, list[float]] = {}
 90+        self.default_K = 3  # 默认分量数
 91+
 92+        # ── 沉积追踪 ──
 93+        self.sedimentation_trace: list[dict] = []  # 最近N步沉积记录
 94+        self.merge_events: list[dict] = []          # 经验→能力核合并事件
 95+        self.decay_events: list[dict] = []          # 衰减/遗忘事件
 96+
 97+        # ── 三核标记 ──
 98+        # 锚点核：α(x) < ε 的节点集（自动浮出，不手动指定）
 99+        # 能力核：长期稳定的高 κ 区域
100+        # 激活核：当前 μ 值最高的活跃区域
101+        self.anchor_nodes: set[str] = set()
102+        self.ability_cores: dict[str, set[str]] = {}  # core_id -> node set
103+        self.active_region: set[str] = set()
104+        self.bound_ability_core: Optional[str] = None  # 当前归属的能力核
105+
106+        # ── 经验层与技能带 ──
107+        self.experience_hits: dict[str, int] = defaultdict(int)  # 节点被激活次数
108+        self.experience_regions: dict[str, set[str]] = {}        # region_id -> nodes
109+        self.skill_belt_candidates: dict[str, float] = {}        # node -> stability score
110+
111+        # ── 输出模式 ──
112+        self.output_mode: str = 'full'  # full / degraded / minimal
113+
114+        # ── 步计数 ──
115+        self.step_count: int = 0
116+
117+        # ── 反馈效果 ──
118+        self.last_feedback_effect: dict = {}
119+
120+    # ── 置信度操作 ──
121+
122+    def get_confidence(self, node_id: str) -> float:
123+        """
124+        返回节点的置信度 c ∈ [0, 1]。
125+        用 Dirichlet 的集中度衡量：max(alpha) / sum(alpha)。
126+        分类已在 ingest 中区分（cat0=左, cat1=右, cat2=锚点）。
127+        """
128+        if node_id not in self.confidence:
129+            return 0.0
130+        alphas = self.confidence[node_id]
131+        total = sum(alphas)
132+        if total <= 0:
133+            return 0.0
134+        return max(alphas) / total
135+
136+    def init_confidence(self, node_id: str, K: int = None):
137+        """初始化节点的 Dirichlet 先验——均匀的弱先验"""
138+        k = K or self.default_K
139+        self.confidence[node_id] = [1.0] * k  # 均匀先验
140+
141+    def update_confidence(self, node_id: str, category: int, amount: float = 1.0):
142+        """更新 Dirichlet：观察到 category，增加对应 alpha"""
143+        if node_id not in self.confidence:
144+            self.init_confidence(node_id)
145+        alphas = self.confidence[node_id]
146+        if 0 <= category < len(alphas):
147+            alphas[category] += amount
148+
149+    def weaken_confidence(self, node_id: str, amount: float = 1.0):
150+        """
151+        削弱置信度——把 alpha 朝均匀先验回退。
152+        负反馈不是简单减少某个 alpha，而是让分布回归不确定。
153+        """
154+        if node_id not in self.confidence:
155+            return
156+        alphas = self.confidence[node_id]
157+        k = len(alphas)
158+        if k == 0:
159+            return
160+        mean_alpha = sum(alphas) / k
161+        for i in range(k):
162+            # 朝均值回退
163+            alphas[i] = alphas[i] + amount * (mean_alpha - alphas[i]) * 0.3
164+            # 不低于 1.0（先验下限）
165+            alphas[i] = max(1.0, alphas[i])
166+
167+    def decay_all_confidence(self, rate: float = 0.001):
168+        """
169+        全局置信度自然衰减——所有 alpha 缓慢回退向先验。
170+        遗忘不是 bug，是地形可塑性的必要条件。
171+        """
172+        for node_id, alphas in self.confidence.items():
173+            k = len(alphas)
174+            if k == 0:
175+                continue
176+            for i in range(k):
177+                # 缓慢回退向 1.0（先验）
178+                alphas[i] = alphas[i] * (1.0 - rate) + 1.0 * rate
179+
180+    # ── 势场操作 ──
181+
182+    def init_node(self, node_id: str, phi_val: float = 0.0):
183+        """初始化节点势场和置信度"""
184+        self.phi[node_id] = phi_val
185+        self.mu[node_id] = 0.0
186+        if node_id not in self.confidence:
187+            self.init_confidence(node_id)
188+
189+    # ── 激活操作 ──
190+
191+    def activate(self, node_id: str, amount: float):
192+        """注入激活到节点，消耗注意力池"""
193+        actual = self.attention.allocate(node_id, amount)
194+        self.mu[node_id] = self.mu.get(node_id, 0.0) + actual
195+        self.active_region.add(node_id)
196+        self.experience_hits[node_id] = self.experience_hits.get(node_id, 0) + 1
197+        return actual
198+
199+    def deactivate(self, node_id: str):
200+        """去激活节点，释放注意力"""
201+        mu_val = self.mu.get(node_id, 0.0)
202+        if mu_val > 0:
203+            self.attention.release(node_id, mu_val)
204+            self.mu[node_id] = 0.0
205+        self.active_region.discard(node_id)
206+
207+    # ── 输出模式判断 ──
208+
209+    def update_output_mode(self):
210+        """根据注意力利用率决定输出模式"""
211+        util = self.attention.utilization
212+        active_count = len(self.active_region)
213+        if util > 0.3 and active_count >= 3:
214+            self.output_mode = 'full'
215+        elif util > 0.1 or active_count >= 1:
216+            self.output_mode = 'degraded'
217+        else:
218+            self.output_mode = 'minimal'
219+
220+    # ── snapshot ──
221+
222+    def snapshot(self) -> dict:
223+        """
224+        导出可比较的运行时摘要（SPEC §6）。
225+        """
226+        # 计算 drift_score: 激活核偏离能力核/锚点核的程度
227+        drift = 0.0
228+        if self.active_region and self.anchor_nodes:
229+            # 简化：激活区域中不在锚点核附近的比例
230+            overlap = self.active_region & self.anchor_nodes
231+            drift = 1.0 - (len(overlap) / max(len(self.active_region), 1))
232+
233+        # anchor_pull: 锚点核对当前状态的回拉强度
234+        anchor_pull = 0.0
235+        if self.anchor_nodes:
236+            anchor_phi = sum(self.phi.get(n, 0.0) for n in self.anchor_nodes)
237+            active_phi = sum(self.phi.get(n, 0.0) for n in self.active_region) if self.active_region else 0.0
238+            anchor_pull = abs(anchor_phi - active_phi) / max(len(self.anchor_nodes), 1)
239+
240+        return {
241+            'step_count': self.step_count,
242+            'phi_summary': {
243+                'count': len(self.phi),
244+                'mean': sum(self.phi.values()) / max(len(self.phi), 1),
245+                'max': max(self.phi.values()) if self.phi else 0.0,
246+                'min': min(self.phi.values()) if self.phi else 0.0,
247+                'top5': sorted(self.phi.items(), key=lambda x: -x[1])[:5],
248+            },
249+            'mu_summary': {
250+                'count': sum(1 for v in self.mu.values() if v > 0),
251+                'total': sum(self.mu.values()),
252+                'top5': sorted(self.mu.items(), key=lambda x: -x[1])[:5],
253+            },
254+            'J_summary': {
255+                'count': sum(1 for v in self.J.values() if abs(v) > 1e-10),
256+                'total_flow': sum(abs(v) for v in self.J.values()),
257+            },
258+            'active_region': list(self.active_region)[:20],
259+            'bound_ability_core': self.bound_ability_core,
260+            'anchor_pull': anchor_pull,
261+            'drift_score': drift,
262+            'free_capacity': self.attention.free,
263+            'experience_regions': {k: list(v)[:10] for k, v in self.experience_regions.items()},
264+            'skill_belt_candidates': dict(sorted(
265+                self.skill_belt_candidates.items(), key=lambda x: -x[1])[:10]),
266+            'sedimentation_trace': self.sedimentation_trace[-20:],
267+            'merge_events': self.merge_events[-10:],
268+            'decay_events': self.decay_events[-10:],
269+            'output_mode': self.output_mode,
270+            'feedback_effect': self.last_feedback_effect,
271+            'attention': self.attention.to_dict(),
272+        }

  1@@ -0,0 +1,735 @@
  2+"""
  3+CIE Branch-B 综合验证测试
  4+===========================
  5+使用真实课本数据（AsahiLuna/china-text-book-md）
  6+
  7+三大类：
  8+  A. 真实数据验证（小初高课本跑完整 pipeline）
  9+  B. 边界条件（空输入、单字、超长文本、极端参数）
 10+  C. 反例/对抗（垃圾输入、类型错误、连续 reset、反复回灌）
 11+
 12+数据选取：
 13+  - 小学语文一上（简单汉字，短句）
 14+  - 小学数学一上（数字+汉字混合）
 15+  - 初中语文七上（中等复杂度文本）
 16+  - 初中数学七上（公式+文字混合）
 17+  - 高中语文必修上（长文本、文言文）
 18+
 19+SPEC §7 覆盖 + 额外边界/反例。
 20+"""
 21+
 22+import sys
 23+import os
 24+import time
 25+import math
 26+import json
 27+import traceback
 28+
 29+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 30+from cie import CIERuntime
 31+
 32+# ── 数据路径 ──
 33+DATA_DIR = "/Users/george/code/china-text-book-md"
 34+
 35+TEXTBOOKS = {
 36+    "小学语文一上": "小学_语文_统编版_义务教育教科书·语文一年级上册.md",
 37+    "小学数学一上": "小学_数学_人教版_义务教育教科书 · 数学一年级上册.md",
 38+    "初中语文七上": "初中_语文_统编版-人民教育出版社_七年级_义务教育教科书·语文七年级上册.md",
 39+    "初中数学七上": "初中_数学_人教版-人民教育出版社_七年级_义务教育教科书·数学七年级上册.md",
 40+    "高中语文必修上": "高中_语文_统编版-人民教育出版社_普通高中教科书·语文必修 上册.md",
 41+}
 42+
 43+
 44+def load_textbook(name):
 45+    """加载课本，提取纯文本段落（跳过 markdown 标记和乱码）"""
 46+    path = os.path.join(DATA_DIR, TEXTBOOKS[name])
 47+    with open(path, "r", encoding="utf-8") as f:
 48+        raw = f.read()
 49+    
 50+    paragraphs = []
 51+    for line in raw.split("\n"):
 52+        line = line.strip()
 53+        # 跳过 markdown 标记、空行、乱码行
 54+        if not line:
 55+            continue
 56+        if line.startswith("#") or line.startswith("**") or line.startswith("---"):
 57+            continue
 58+        if line.startswith("!["): # images
 59+            continue
 60+        # 过滤掉控制字符过多的行（OCR 乱码）
 61+        ctrl_count = sum(1 for c in line if ord(c) < 32 and c not in '\n\t')
 62+        if ctrl_count > len(line) * 0.3:
 63+            continue
 64+        # 至少 2 个中文字符
 65+        cn_count = sum(1 for c in line if '\u4e00' <= c <= '\u9fff')
 66+        if cn_count >= 2:
 67+            paragraphs.append(line)
 68+    
 69+    return paragraphs
 70+
 71+
 72+# ╔══════════════════════════════════════════════╗
 73+# ║  A. 真实数据验证                              ║
 74+# ╚══════════════════════════════════════════════╝
 75+
 76+def test_A01_xiaoxue_yuwen_pipeline():
 77+    """A01: 小学语文一上——完整 pipeline（ingest→step→emit→feedback→snapshot）"""
 78+    rt = CIERuntime(seed=42)
 79+    paras = load_textbook("小学语文一上")
 80+    assert len(paras) > 10, f"Too few paragraphs: {len(paras)}"
 81+    
 82+    # 喂前 30 段
 83+    for p in paras[:30]:
 84+        rt.ingest(p[:50])  # 截断到50字
 85+        rt.step(n=3)
 86+    
 87+    out = rt.emit()
 88+    snap = rt.snapshot_state()
 89+    
 90+    assert out['active_count'] > 0, "No active nodes after feeding textbook"
 91+    assert snap['phi_summary']['count'] > 20, "Too few phi nodes"
 92+    assert snap['attention']['used'] > 0, "No attention used"
 93+    
 94+    # 反馈
 95+    if out['activated']:
 96+        rt.commit_feedback({'correct': [out['activated'][0]['node']], 'reward': 1.0})
 97+    
 98+    print(f"  PASS: 小学语文 — {snap['phi_summary']['count']} nodes, "
 99+          f"{snap['J_summary']['count']} flows, mode={out['mode']}")
100+
101+
102+def test_A02_xiaoxue_shuxue_mixed():
103+    """A02: 小学数学一上——数字+汉字混合输入"""
104+    rt = CIERuntime(seed=42)
105+    paras = load_textbook("小学数学一上")
106+    
107+    # 数学课本有数字、符号、汉字混合
108+    for p in paras[:20]:
109+        rt.ingest(p[:40])
110+        rt.step(n=3)
111+    
112+    out = rt.emit()
113+    snap = rt.snapshot_state()
114+    
115+    # 验证数字和汉字节点都存在
116+    has_digit = any(c.isdigit() for c in rt.graph.nodes)
117+    has_cn = any('\u4e00' <= c <= '\u9fff' for c in rt.graph.nodes)
118+    assert has_cn, "No Chinese characters in graph"
119+    
120+    print(f"  PASS: 小学数学 — {snap['phi_summary']['count']} nodes, "
121+          f"has_digit={has_digit}, has_cn={has_cn}")
122+
123+
124+def test_A03_chuzhong_yuwen_complexity():
125+    """A03: 初中语文七上——中等复杂度，验证沉积路径"""
126+    rt = CIERuntime(seed=42)
127+    paras = load_textbook("初中语文七上")
128+    
129+    for p in paras[:50]:
130+        rt.ingest(p[:60])
131+        rt.step(n=3)
132+    
133+    snap = rt.snapshot_state()
134+    
135+    # 50段文本应该产生沉积
136+    exp_count = len(snap.get('experience_regions', {}).get('experience', []))
137+    sed_count = len(snap['sedimentation_trace'])
138+    
139+    assert snap['phi_summary']['count'] > 50, "Too few nodes from 50 paragraphs"
140+    print(f"  PASS: 初中语文 — {snap['phi_summary']['count']} nodes, "
141+          f"experience={exp_count}, sed_traces={sed_count}")
142+
143+
144+def test_A04_chuzhong_shuxue_formula():
145+    """A04: 初中数学七上——公式文字混合，验证非对称边"""
146+    rt = CIERuntime(seed=42)
147+    paras = load_textbook("初中数学七上")
148+    
149+    for p in paras[:30]:
150+        rt.ingest(p[:50])
151+        rt.step(n=3)
152+    
153+    # 验证边的非对称性（旋度来源）
154+    asym_count = 0
155+    total_edges = 0
156+    for src_edges in rt.graph.fwd_edges.values():
157+        for dst, edge in src_edges.items():
158+            bwd_w = rt.graph.get_bwd_weight(edge.src, dst)
159+            if abs(edge.weight - bwd_w) > 0.01:
160+                asym_count += 1
161+            total_edges += 1
162+    
163+    asym_ratio = asym_count / max(total_edges, 1)
164+    assert asym_ratio > 0.5, f"Asymmetry too low: {asym_ratio:.2f}"
165+    print(f"  PASS: 初中数学 — {total_edges} edges, asym_ratio={asym_ratio:.2f}")
166+
167+
168+def test_A05_gaozhong_yuwen_long_text():
169+    """A05: 高中语文必修上——长文本，验证注意力不溢出"""
170+    rt = CIERuntime(seed=42)
171+    paras = load_textbook("高中语文必修上")
172+    
173+    for p in paras[:80]:
174+        rt.ingest(p[:80])
175+        rt.step(n=2)
176+    
177+    snap = rt.snapshot_state()
178+    
179+    # 注意力不应溢出
180+    assert snap['attention']['used'] <= snap['attention']['total'] + 0.01, \
181+        f"Attention overflow: {snap['attention']['used']} > {snap['attention']['total']}"
182+    
183+    # phi 不应发散
184+    assert abs(snap['phi_summary']['max']) <= 10.1, \
185+        f"Phi diverged: max={snap['phi_summary']['max']}"
186+    assert abs(snap['phi_summary']['min']) <= 10.1, \
187+        f"Phi diverged: min={snap['phi_summary']['min']}"
188+    
189+    print(f"  PASS: 高中语文 — {snap['phi_summary']['count']} nodes, "
190+          f"phi_range=[{snap['phi_summary']['min']:.2f}, {snap['phi_summary']['max']:.2f}], "
191+          f"attention={snap['attention']['used']:.1f}/{snap['attention']['total']:.0f}")
192+
193+
194+def test_A06_cross_subject_learning():
195+    """A06: 跨学科学习——先语文后数学，验证激活核迁移"""
196+    rt = CIERuntime(seed=42)
197+    
198+    # Phase 1: 语文
199+    yuwen = load_textbook("小学语文一上")
200+    for p in yuwen[:15]:
201+        rt.ingest(p[:40])
202+        rt.step(n=3)
203+    snap_yuwen = rt.snapshot_state()
204+    active_yuwen = set(snap_yuwen['active_region'])
205+    
206+    # Phase 2: 数学（不 reset）
207+    shuxue = load_textbook("小学数学一上")
208+    for p in shuxue[:15]:
209+        rt.ingest(p[:40])
210+        rt.step(n=3)
211+    snap_shuxue = rt.snapshot_state()
212+    active_shuxue = set(snap_shuxue['active_region'])
213+    
214+    # 激活区域应迁移
215+    new_nodes = active_shuxue - active_yuwen
216+    assert len(new_nodes) > 0, "No activation migration on subject switch"
217+    
218+    # 语文的结构应该还在（phi 不为零）
219+    yuwen_nodes_alive = sum(1 for n in active_yuwen 
220+                           if abs(rt.state.phi.get(n, 0.0)) > 0.001)
221+    
222+    print(f"  PASS: 跨学科 — 语文active={len(active_yuwen)}, 数学active={len(active_shuxue)}, "
223+          f"new={len(new_nodes)}, 语文nodes_alive={yuwen_nodes_alive}")
224+
225+
226+def test_A07_session_reset_preserves_long_term():
227+    """A07: session reset 保留长期结构"""
228+    rt = CIERuntime(seed=42)
229+    
230+    paras = load_textbook("初中语文七上")
231+    for p in paras[:30]:
232+        rt.ingest(p[:50])
233+        rt.step(n=3)
234+    
235+    # 记录长期结构
236+    phi_before = dict(rt.state.phi)
237+    cores_before = dict(rt.state.ability_cores)
238+    
239+    # Reset
240+    rt.reset_session()
241+    
242+    # 验证
243+    assert sum(rt.state.mu.values()) == 0, "mu not cleared after reset"
244+    assert len(rt.state.active_region) == 0, "active_region not cleared"
245+    assert rt.state.attention.free == 100.0, "attention not restored"
246+    
247+    # phi 应该保留
248+    phi_preserved = sum(1 for k in phi_before if abs(rt.state.phi.get(k, 0.0)) > 0.001)
249+    assert phi_preserved > 0, "All phi lost after reset"
250+    
251+    print(f"  PASS: reset — phi_preserved={phi_preserved}/{len(phi_before)}, "
252+          f"cores={len(cores_before)}")
253+
254+
255+def test_A08_multi_round_feedback():
256+    """A08: 多轮反馈——正负交替，验证置信度变化"""
257+    rt = CIERuntime(seed=42)
258+    
259+    paras = load_textbook("小学语文一上")
260+    rt.ingest(paras[0][:30])
261+    rt.step(n=5)
262+    out = rt.emit()
263+    
264+    if not out['activated']:
265+        print("  SKIP: no activated nodes")
266+        return
267+    
268+    target = out['activated'][0]['node']
269+    c_initial = rt.state.get_confidence(target)
270+    
271+    # 正反馈
272+    for _ in range(5):
273+        rt.commit_feedback({'correct': [target], 'reward': 1.0})
274+    c_positive = rt.state.get_confidence(target)
275+    
276+    # 负反馈
277+    rt.commit_feedback({'wrong': [target], 'reward': -0.5})
278+    c_after_neg = rt.state.get_confidence(target)
279+    phi_after_neg = rt.state.phi.get(target, 0.0)
280+    
281+    assert c_positive >= c_initial, "Positive feedback didn't increase confidence"
282+    print(f"  PASS: 多轮反馈 — c: {c_initial:.3f} → +fb → {c_positive:.3f} → -fb → {c_after_neg:.3f}")
283+
284+
285+def test_A09_incremental_learning_sedimentation():
286+    """A09: 渐进学习——同一课本反复喂，验证沉积逐步加深"""
287+    rt = CIERuntime(seed=42)
288+    
289+    paras = load_textbook("小学语文一上")[:10]
290+    
291+    sed_history = []
292+    for round_i in range(5):
293+        for p in paras:
294+            rt.ingest(p[:30])
295+            rt.step(n=3)
296+        snap = rt.snapshot_state()
297+        sed_count = len(snap['sedimentation_trace'])
298+        skill_count = len(snap['skill_belt_candidates'])
299+        sed_history.append((sed_count, skill_count))
300+    
301+    # 沉积应该逐步增多
302+    assert sed_history[-1][0] >= sed_history[0][0], \
303+        f"Sedimentation not increasing: {sed_history}"
304+    
305+    print(f"  PASS: 渐进沉积 — rounds: {sed_history}")
306+
307+
308+def test_A10_snapshot_completeness():
309+    """A10: snapshot 输出完整性（SPEC §6 所有字段）"""
310+    rt = CIERuntime(seed=42)
311+    
312+    paras = load_textbook("初中数学七上")
313+    for p in paras[:20]:
314+        rt.ingest(p[:40])
315+        rt.step(n=3)
316+    rt.emit()
317+    rt.commit_feedback({'correct': [], 'reward': 0.5})
318+    
319+    snap = rt.snapshot_state()
320+    
321+    required_fields = [
322+        'phi_summary', 'mu_summary', 'J_summary',
323+        'active_region', 'bound_ability_core', 'anchor_pull',
324+        'drift_score', 'free_capacity', 'experience_regions',
325+        'skill_belt_candidates', 'sedimentation_trace',
326+        'merge_events', 'decay_events', 'output_mode',
327+        'feedback_effect', 'attention',
328+    ]
329+    
330+    missing = [f for f in required_fields if f not in snap]
331+    assert not missing, f"Missing snapshot fields: {missing}"
332+    
333+    print(f"  PASS: snapshot 完整 — {len(required_fields)} fields all present")
334+
335+
336+# ╔══════════════════════════════════════════════╗
337+# ║  B. 边界条件                                  ║
338+# ╚══════════════════════════════════════════════╝
339+
340+def test_B01_empty_input():
341+    """B01: 空输入不崩"""
342+    rt = CIERuntime(seed=42)
343+    rt.ingest("")
344+    rt.step(n=3)
345+    out = rt.emit()
346+    assert out is not None
347+    assert out['mode'] == 'minimal'
348+    print(f"  PASS: 空输入 — mode={out['mode']}, active={out['active_count']}")
349+
350+
351+def test_B02_single_char():
352+    """B02: 单字输入"""
353+    rt = CIERuntime(seed=42)
354+    rt.ingest("我")
355+    rt.step(n=5)
356+    out = rt.emit()
357+    assert rt.graph.node_count >= 1
358+    print(f"  PASS: 单字 — nodes={rt.graph.node_count}, active={out['active_count']}")
359+
360+
361+def test_B03_very_long_input():
362+    """B03: 超长输入（10000字）不崩不溢出"""
363+    rt = CIERuntime(seed=42)
364+    paras = load_textbook("高中语文必修上")
365+    long_text = "".join(p for p in paras[:200])[:10000]
366+    
367+    t0 = time.time()
368+    rt.ingest(long_text)
369+    rt.step(n=3)
370+    out = rt.emit()
371+    elapsed = time.time() - t0
372+    
373+    snap = rt.snapshot_state()
374+    assert snap['attention']['used'] <= snap['attention']['total'] + 0.01
375+    assert abs(snap['phi_summary']['max']) <= 10.1
376+    
377+    print(f"  PASS: 超长输入({len(long_text)}字) — "
378+          f"nodes={snap['phi_summary']['count']}, time={elapsed:.2f}s")
379+
380+
381+def test_B04_repeated_same_input():
382+    """B04: 同一输入反复注入100次，数值不发散"""
383+    rt = CIERuntime(seed=42)
384+    for i in range(100):
385+        rt.ingest("重复")
386+        rt.step(n=1)
387+    
388+    snap = rt.snapshot_state()
389+    assert abs(snap['phi_summary']['max']) <= 10.1, \
390+        f"Phi diverged after 100 repeats: {snap['phi_summary']['max']}"
391+    assert snap['attention']['used'] <= snap['attention']['total'] + 0.01
392+    
393+    print(f"  PASS: 100次重复 — phi_max={snap['phi_summary']['max']:.3f}, "
394+          f"attention={snap['attention']['used']:.1f}")
395+
396+
397+def test_B05_step_zero():
398+    """B05: step(0) 不改变状态"""
399+    rt = CIERuntime(seed=42)
400+    rt.ingest("测试")
401+    snap1 = json.dumps(rt.snapshot_state(), sort_keys=True, default=str)
402+    rt.step(n=0)
403+    snap2 = json.dumps(rt.snapshot_state(), sort_keys=True, default=str)
404+    assert snap1 == snap2, "step(0) changed state"
405+    print("  PASS: step(0) 不改变状态")
406+
407+
408+def test_B06_step_large_n():
409+    """B06: step(1000) 不崩，phi 不发散"""
410+    rt = CIERuntime(seed=42)
411+    rt.ingest("大步长测试")
412+    rt.step(n=1000)
413+    
414+    snap = rt.snapshot_state()
415+    assert abs(snap['phi_summary']['max']) <= 10.1
416+    # 大量 step 后激活应该衰减到很低
417+    total_mu = snap['mu_summary']['total']
418+    print(f"  PASS: step(1000) — phi_max={snap['phi_summary']['max']:.3f}, "
419+          f"mu_total={total_mu:.4f}")
420+
421+
422+def test_B07_attention_exact_boundary():
423+    """B07: 注意力池精确到0"""
424+    rt = CIERuntime(seed=42)
425+    rt.state.attention.total = 10.0  # 很小的池
426+    
427+    # 连续注入直到耗尽
428+    for i in range(20):
429+        rt.ingest(f"字{i}")
430+        rt.step(n=1)
431+    
432+    assert rt.state.attention.free >= 0, \
433+        f"Attention went negative: {rt.state.attention.free}"
434+    print(f"  PASS: 注意力边界 — free={rt.state.attention.free:.4f}, "
435+          f"used={rt.state.attention.used:.4f}")
436+
437+
438+def test_B08_emit_before_ingest():
439+    """B08: 还没 ingest 就 emit"""
440+    rt = CIERuntime(seed=42)
441+    out = rt.emit()
442+    assert out is not None
443+    assert out['mode'] in ('full', 'degraded', 'minimal')
444+    assert len(out['activated']) == 0
445+    print(f"  PASS: emit before ingest — mode={out['mode']}")
446+
447+
448+def test_B09_unicode_special_chars():
449+    """B09: 各种 Unicode 特殊字符"""
450+    rt = CIERuntime(seed=42)
451+    special = "αβγ∑∏∫≈≠∞π²√½⅓㊀㊁㊂🎉🔥"
452+    rt.ingest(special)
453+    rt.step(n=3)
454+    out = rt.emit()
455+    assert rt.graph.node_count >= len(set(special))
456+    print(f"  PASS: Unicode特殊字符 — nodes={rt.graph.node_count}")
457+
458+
459+def test_B10_snapshot_after_reset():
460+    """B10: reset 后 snapshot 不崩"""
461+    rt = CIERuntime(seed=42)
462+    rt.ingest("测试")
463+    rt.step(n=5)
464+    rt.reset_session()
465+    snap = rt.snapshot_state()
466+    assert snap is not None
467+    assert snap['mu_summary']['total'] == 0
468+    print("  PASS: reset后snapshot正常")
469+
470+
471+# ╔══════════════════════════════════════════════╗
472+# ║  C. 反例/对抗                                 ║
473+# ╚══════════════════════════════════════════════╝
474+
475+def test_C01_garbage_bytes():
476+    """C01: 纯乱码/二进制输入"""
477+    rt = CIERuntime(seed=42)
478+    garbage = "".join(chr(i) for i in range(1, 128))
479+    rt.ingest(garbage)
480+    rt.step(n=3)
481+    out = rt.emit()
482+    # 不崩就行
483+    assert out is not None
484+    print(f"  PASS: 乱码输入 — nodes={rt.graph.node_count}, active={out['active_count']}")
485+
486+
487+def test_C02_list_input():
488+    """C02: list 输入（非字符串）"""
489+    rt = CIERuntime(seed=42)
490+    rt.ingest(["你", "好", "世", "界"])
491+    rt.step(n=3)
492+    out = rt.emit()
493+    assert rt.graph.has_node("你")
494+    assert rt.graph.has_node("世")
495+    print(f"  PASS: list输入 — nodes={rt.graph.node_count}")
496+
497+
498+def test_C03_numeric_input():
499+    """C03: 纯数字输入"""
500+    rt = CIERuntime(seed=42)
501+    rt.ingest("3.14159265358979")
502+    rt.step(n=5)
503+    out = rt.emit()
504+    assert rt.graph.has_node("3")
505+    assert rt.graph.has_node(".")
506+    print(f"  PASS: 纯数字 — nodes={rt.graph.node_count}")
507+
508+
509+def test_C04_rapid_reset_cycle():
510+    """C04: 快速反复 reset-ingest 循环"""
511+    rt = CIERuntime(seed=42)
512+    for i in range(50):
513+        rt.ingest(f"循环{i}")
514+        rt.step(n=1)
515+        rt.reset_session()
516+    
517+    # reset 后再正常使用
518+    rt.ingest("恢复正常")
519+    rt.step(n=5)
520+    out = rt.emit()
521+    assert out is not None
522+    assert rt.state.attention.free >= 0
523+    print(f"  PASS: 50次快速reset — active={out['active_count']}, free={rt.state.attention.free:.1f}")
524+
525+
526+def test_C05_feedback_nonexistent_nodes():
527+    """C05: 对不存在的节点做反馈"""
528+    rt = CIERuntime(seed=42)
529+    rt.ingest("测试")
530+    rt.step(n=3)
531+    
532+    # 不存在的节点
533+    rt.commit_feedback({'correct': ['不存在的节点'], 'wrong': ['也不存在']})
534+    # 不应崩
535+    snap = rt.snapshot_state()
536+    assert snap is not None
537+    print("  PASS: 不存在节点的反馈不崩")
538+
539+
540+def test_C06_negative_reward_extreme():
541+    """C06: 极端负奖励"""
542+    rt = CIERuntime(seed=42)
543+    rt.ingest("极端测试")
544+    rt.step(n=5)
545+    
546+    rt.commit_feedback({'reward': -100.0})
547+    rt.step(n=3)
548+    
549+    snap = rt.snapshot_state()
550+    # phi 不应变成 NaN 或 Inf
551+    for v in rt.state.phi.values():
552+        assert math.isfinite(v), f"Phi became non-finite: {v}"
553+    
554+    print(f"  PASS: 极端负奖励 — phi全有限, max={snap['phi_summary']['max']:.3f}")
555+
556+
557+def test_C07_anchor_overload():
558+    """C07: 大量锚点注入"""
559+    rt = CIERuntime(seed=42)
560+    anchors = [f"锚{i}" for i in range(50)]
561+    rt.ingest("测试", anchors=anchors)
562+    rt.step(n=5)
563+    
564+    snap = rt.snapshot_state()
565+    assert snap['attention']['used'] <= snap['attention']['total'] + 0.01
566+    print(f"  PASS: 50个锚点 — nodes={snap['phi_summary']['count']}, "
567+          f"anchors={len(rt.state.anchor_nodes)}")
568+
569+
570+def test_C08_output_to_input_chain():
571+    """C08: 验证回灌链——多轮只靠回灌推动"""
572+    rt = CIERuntime(seed=42)
573+    
574+    # 只注入一次
575+    rt.ingest("种子输入")
576+    rt.step(n=5)
577+    out1 = rt.emit()
578+    
579+    # 后续只靠回灌
580+    outputs = [out1]
581+    for i in range(5):
582+        rt.ingest("")  # 空输入触发回灌
583+        rt.step(n=3)
584+        out = rt.emit()
585+        outputs.append(out)
586+    
587+    # 回灌应该维持一些激活（不会立刻归零）
588+    has_activity = any(o['active_count'] > 0 for o in outputs[1:])
589+    print(f"  PASS: 回灌链 — activities={[o['active_count'] for o in outputs]}")
590+
591+
592+def test_C09_concurrent_subjects_no_contamination():
593+    """C09: 交替喂完全不同的内容，验证结构分离"""
594+    rt = CIERuntime(seed=42)
595+    
596+    # 交替喂语文和数学
597+    yuwen = load_textbook("小学语文一上")[:10]
598+    shuxue = load_textbook("小学数学一上")[:10]
599+    
600+    for i in range(min(len(yuwen), len(shuxue))):
601+        rt.ingest(yuwen[i][:30], anchors=["语文"])
602+        rt.step(n=2)
603+        rt.ingest(shuxue[i][:30], anchors=["数学"])
604+        rt.step(n=2)
605+    
606+    # 两个锚点都应存在且有不同的 phi
607+    phi_yw = rt.state.phi.get("语文", 0.0)
608+    phi_sx = rt.state.phi.get("数学", 0.0)
609+    
610+    assert rt.graph.has_node("语文"), "语文 anchor missing"
611+    assert rt.graph.has_node("数学"), "数学 anchor missing"
612+    
613+    print(f"  PASS: 交替学科 — phi(语文)={phi_yw:.3f}, phi(数学)={phi_sx:.3f}")
614+
615+
616+def test_C10_all_textbooks_stability():
617+    """C10: 所有5本课本依次喂入同一个runtime，验证全局稳定性"""
618+    rt = CIERuntime(seed=42)
619+    
620+    book_stats = {}
621+    for name in TEXTBOOKS:
622+        paras = load_textbook(name)
623+        for p in paras[:20]:
624+            rt.ingest(p[:50])
625+            rt.step(n=2)
626+        
627+        snap = rt.snapshot_state()
628+        book_stats[name] = {
629+            'nodes': snap['phi_summary']['count'],
630+            'phi_max': snap['phi_summary']['max'],
631+            'attention_used': snap['attention']['used'],
632+        }
633+        
634+        # 每本书后检查稳定性
635+        assert abs(snap['phi_summary']['max']) <= 10.1, \
636+            f"Phi diverged after {name}: {snap['phi_summary']['max']}"
637+        assert snap['attention']['used'] <= snap['attention']['total'] + 0.01, \
638+            f"Attention overflow after {name}"
639+        
640+        for v in rt.state.phi.values():
641+            assert math.isfinite(v), f"Non-finite phi after {name}"
642+    
643+    final_snap = rt.snapshot_state()
644+    print(f"  PASS: 全5本课本 — 最终nodes={final_snap['phi_summary']['count']}, "
645+          f"edges={final_snap['graph']['edge_count']}, "
646+          f"experience={len(final_snap.get('experience_regions', {}).get('experience', []))}, "
647+          f"merges={len(final_snap['merge_events'])}")
648+    for name, stats in book_stats.items():
649+        print(f"    {name}: nodes={stats['nodes']}, phi_max={stats['phi_max']:.3f}")
650+
651+
652+# ══════════════════════════════════════════════
653+# 运行器
654+# ══════════════════════════════════════════════
655+
656+def run_all():
657+    groups = [
658+        ("A. 真实数据验证", [
659+            ("A01_小学语文pipeline", test_A01_xiaoxue_yuwen_pipeline),
660+            ("A02_小学数学mixed", test_A02_xiaoxue_shuxue_mixed),
661+            ("A03_初中语文complexity", test_A03_chuzhong_yuwen_complexity),
662+            ("A04_初中数学formula", test_A04_chuzhong_shuxue_formula),
663+            ("A05_高中语文long_text", test_A05_gaozhong_yuwen_long_text),
664+            ("A06_跨学科learning", test_A06_cross_subject_learning),
665+            ("A07_session_reset", test_A07_session_reset_preserves_long_term),
666+            ("A08_多轮feedback", test_A08_multi_round_feedback),
667+            ("A09_渐进沉积", test_A09_incremental_learning_sedimentation),
668+            ("A10_snapshot完整性", test_A10_snapshot_completeness),
669+        ]),
670+        ("B. 边界条件", [
671+            ("B01_空输入", test_B01_empty_input),
672+            ("B02_单字", test_B02_single_char),
673+            ("B03_超长输入", test_B03_very_long_input),
674+            ("B04_重复输入100次", test_B04_repeated_same_input),
675+            ("B05_step(0)", test_B05_step_zero),
676+            ("B06_step(1000)", test_B06_step_large_n),
677+            ("B07_注意力边界", test_B07_attention_exact_boundary),
678+            ("B08_emit_before_ingest", test_B08_emit_before_ingest),
679+            ("B09_unicode特殊字符", test_B09_unicode_special_chars),
680+            ("B10_reset后snapshot", test_B10_snapshot_after_reset),
681+        ]),
682+        ("C. 反例/对抗", [
683+            ("C01_乱码输入", test_C01_garbage_bytes),
684+            ("C02_list输入", test_C02_list_input),
685+            ("C03_纯数字", test_C03_numeric_input),
686+            ("C04_快速reset循环", test_C04_rapid_reset_cycle),
687+            ("C05_不存在节点feedback", test_C05_feedback_nonexistent_nodes),
688+            ("C06_极端负奖励", test_C06_negative_reward_extreme),
689+            ("C07_大量锚点", test_C07_anchor_overload),
690+            ("C08_回灌链", test_C08_output_to_input_chain),
691+            ("C09_交替学科", test_C09_concurrent_subjects_no_contamination),
692+            ("C10_全5本课本稳定性", test_C10_all_textbooks_stability),
693+        ]),
694+    ]
695+    
696+    total_pass = 0
697+    total_fail = 0
698+    total_skip = 0
699+    failures = []
700+    
701+    for group_name, tests in groups:
702+        print(f"\n{'='*60}")
703+        print(f"  {group_name}")
704+        print(f"{'='*60}")
705+        
706+        for test_name, test_fn in tests:
707+            try:
708+                print(f"\n[{test_name}]")
709+                test_fn()
710+                total_pass += 1
711+            except AssertionError as e:
712+                print(f"  FAIL: {e}")
713+                total_fail += 1
714+                failures.append((test_name, str(e)))
715+            except Exception as e:
716+                print(f"  ERROR: {e}")
717+                traceback.print_exc()
718+                total_fail += 1
719+                failures.append((test_name, f"ERROR: {e}"))
720+    
721+    print(f"\n{'='*60}")
722+    print(f"  总计: {total_pass} passed, {total_fail} failed, "
723+          f"{total_pass + total_fail} total")
724+    print(f"{'='*60}")
725+    
726+    if failures:
727+        print("\n失败项:")
728+        for name, reason in failures:
729+            print(f"  ✗ {name}: {reason}")
730+    
731+    return total_fail == 0
732+
733+
734+if __name__ == '__main__':
735+    success = run_all()
736+    sys.exit(0 if success else 1)