liquid-loop 0.9.0__tar.gz → 0.9.2__tar.gz

{liquid_loop-0.9.0 → liquid_loop-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liquid-loop
-Version: 0.9.0
+Version: 0.9.2
 Summary: Self-Organizing Cognitive Memory for AI Agents — Liquid Loop theory implementation
 Author: fishbook0001
 Maintainer: fishbook0001
@@ -227,6 +227,30 @@ print(health["CCI"], health["consensus_crystals"])
 
 ---
 
+## 固态 A2A 通道（任意 MCP 客户端接入）
+
+把共享液环后端（地址由环境变量 `LIQUID_LOOP_BASE` 决定，默认 `http://127.0.0.1:8790`）封装成一个
+**stdio JSON-RPC 的 MCP server**，让任意支持 Model Context Protocol 的客户端（本例以 TRAE SOLO CN 演示）
+**原生读写同一份共享记忆**——这就是多 agent 间的固化（solidified）A2A 通道。
+
+> 后端说明：桥接只做协议翻译，**不内置 8790 服务**；后端由你自己部署（运行你自己的液环 SSE 服务，
+> 把地址通过 `LIQUID_LOOP_BASE` 传给桥接）。成核 / 共识 / 审计链全部由后端按液环理论执行。
+
+```bash
+# 在你的 MCP 客户端注册该 server（以 TRAE 为例；其 code CLI 路径随安装而异，请替换为你的路径）
+export PY=python3                                    # 任意 Python 3.10+ 解释器
+export SVR=examples/trae_mesh_mcp/mcp_server.py      # 本仓库内路径
+export LIQUID_LOOP_BASE=http://127.0.0.1:8790        # 改成你的后端地址
+"<path-to-your-trae-code-cli>" \
+  --add-mcp '{"servers":{"liquidloop-mesh":{"command":"'"$PY"'","args":["'"$SVR"'"]}}}'
+```
+
+桥接暴露 `liquidloop_remember` / `liquidloop_recall` / `liquidloop_metrics` 三个工具（写入**必须声明 `agent_id`**）。
+压测脚本与运维说明见 [`examples/trae_mesh_mcp/README.md`](examples/trae_mesh_mcp/README.md)
+（直连 + 经桥双路并发，零丢写 / 共识幂等 / 崩溃恢复三关全 PASS；所有路径走环境变量，适配不同部署拓扑）。
+
+---
+
 ## 定位：Self-Regulating Memory State Evolution
 
 > **North-Star 公理（一切代码与论文围绕它校验）：**

{liquid_loop-0.9.0 → liquid_loop-0.9.2}/README.md

@@ -188,6 +188,30 @@ print(health["CCI"], health["consensus_crystals"])
 
 ---
 
+## 固态 A2A 通道（任意 MCP 客户端接入）
+
+把共享液环后端（地址由环境变量 `LIQUID_LOOP_BASE` 决定，默认 `http://127.0.0.1:8790`）封装成一个
+**stdio JSON-RPC 的 MCP server**，让任意支持 Model Context Protocol 的客户端（本例以 TRAE SOLO CN 演示）
+**原生读写同一份共享记忆**——这就是多 agent 间的固化（solidified）A2A 通道。
+
+> 后端说明：桥接只做协议翻译，**不内置 8790 服务**；后端由你自己部署（运行你自己的液环 SSE 服务，
+> 把地址通过 `LIQUID_LOOP_BASE` 传给桥接）。成核 / 共识 / 审计链全部由后端按液环理论执行。
+
+```bash
+# 在你的 MCP 客户端注册该 server（以 TRAE 为例；其 code CLI 路径随安装而异，请替换为你的路径）
+export PY=python3                                    # 任意 Python 3.10+ 解释器
+export SVR=examples/trae_mesh_mcp/mcp_server.py      # 本仓库内路径
+export LIQUID_LOOP_BASE=http://127.0.0.1:8790        # 改成你的后端地址
+"<path-to-your-trae-code-cli>" \
+  --add-mcp '{"servers":{"liquidloop-mesh":{"command":"'"$PY"'","args":["'"$SVR"'"]}}}'
+```
+
+桥接暴露 `liquidloop_remember` / `liquidloop_recall` / `liquidloop_metrics` 三个工具（写入**必须声明 `agent_id`**）。
+压测脚本与运维说明见 [`examples/trae_mesh_mcp/README.md`](examples/trae_mesh_mcp/README.md)
+（直连 + 经桥双路并发，零丢写 / 共识幂等 / 崩溃恢复三关全 PASS；所有路径走环境变量，适配不同部署拓扑）。
+
+---
+
 ## 定位：Self-Regulating Memory State Evolution
 
 > **North-Star 公理（一切代码与论文围绕它校验）：**

{liquid_loop-0.9.0 → liquid_loop-0.9.2}/liquid_loop/__init__.py

@@ -1,5 +1,5 @@
-"""Liquid Loop — Workspace Cognitive Runtime v0.9.0 (反证轨 + 时间动力学, CPE-fused, SEAL dual-opt, dual-track multi-agent, MESH v2 integration)"""
-__version__ = "0.9.0"
+"""Liquid Loop — Workspace Cognitive Runtime v0.9.2 (Layer-1 修复: 结构化投影层 + 冲突惩罚持久化 + 有效迭代 τ)"""
+__version__ = "0.9.2"
 
 from .workspace import (
     WorkspaceState, Anchor, Evidence, Memory, Conflict,

{liquid_loop-0.9.0 → liquid_loop-0.9.2}/liquid_loop/storage.py

@@ -65,6 +65,9 @@ def save(state: WorkspaceState, workspace_root: Path):
     data = asdict(state)
     # overlap_cache 仅为运行时熵计算缓存，键为 tuple，不可 JSON 序列化，且不具持久价值
     data.pop("overlap_cache", None)
+    # canon_fn 是运行时注入的可替换投影层（可能为不可序列化的函数），不持久化；
+    # 需用时由调用方重新注入。不 pop 会导致 json.dump 对函数崩溃（P0 隐患）。
+    data.pop("canon_fn", None)
     tmp = path.with_suffix(".tmp")
     with open(tmp, "w", encoding="utf-8") as f:
         json.dump(data, f, indent=2, ensure_ascii=False)
@@ -104,4 +107,5 @@ def _from_dict(data: dict) -> WorkspaceState:
         self_refine_probes=data.get("self_refine_probes", []),
         self_refine_results=data.get("self_refine_results", []),
         self_refine_repair_count=data.get("self_refine_repair_count", 0),
+        _iteration=data.get("_iteration", 0),  # Layer-1 修复：τ=有效迭代计数必须持久化，否则重启后归零→强化门控恒真→时间衰减失效
     )

{liquid_loop-0.9.0 → liquid_loop-0.9.2}/liquid_loop/workspace.py

@@ -89,6 +89,7 @@ class Anchor:
     value_score: float = 1.0
     anchor_strength: float = 1.0
     seal_adjust: float = 0.0  # SEAL 自评层增量；_recalc 合成进 stability，不被覆盖（解 v0.6.3 假落地）
+    conflict_penalty: float = 1.0  # 冲突惩罚累积乘子（Layer-1 修复：持久化，recalc/step/load 后保留）
 
     def decay_value(self, factor: float = 0.95, evidence_count: int = 0) -> float:
         if not self.created_at:
@@ -158,6 +159,7 @@ class Evidence:
     agent_id: str = ""  # 多智能体共用：写入者标识（共用机制，缺省=legacy/单实例）
     relation: str = "support"  # 反证轨：evidence 与 memory 的关系 "support"(一致) | "contradiction"(冲突) | ""(legacy 视为 support)
     target_memory_id: str = ""  # relation=contradiction 时，可选显式指向被反驳的 memory（缺省=同锚点最近结晶）
+    added_iter: int = 0  # 证据写入时的有效状态更新序号（τ=Effective Iteration）；强化门控据此判"自上次 step 以来是否有新 support 抵达"
 
 
 @dataclass
@@ -173,7 +175,8 @@ class Memory:
     stability: float = 1.0  # 反证轨稳定性：一致增稳、冲突降稳（0~1）
     support_count: int = 0  # 支持该 memory 的证据数
     contradiction_count: int = 0  # 反驳该 memory 的证据数
-    last_reinforced: str = ""  # 最近一次被 support 证据强化的时间戳（时间动力学用）
+    last_reinforced: str = ""  # 最近一次被 support 证据强化的时间戳（审计展示用）
+    last_reinforced_iter: int = 0  # 最近一次被 support 强化的迭代序号（τ=Effective Iteration，非墙钟；强化门控以此为准）
 
 
 @dataclass
@@ -238,6 +241,8 @@ class WorkspaceState:
     cpe_erosion_warnings: list[dict] = field(default_factory=list)  # 能力侵蚀告警
     cpe_regularization_count: int = 0                               # 累计正则化干预次数
     overlap_cache: dict = field(default_factory=dict)  # 缓存关键词重叠度
+    _iteration: int = 0  # 有效状态更新次数（τ = Effective Iteration）；时间动力学以之为时间变量而非墙钟
+    canon_fn: object = None  # 可替换 Projection Layer（Layer-1 修复）：注入后冲突检测复用此投影，None=旧关键词重叠回退
 
     # ── API 层：add_anchor / add_evidence（让 README 示例能跑通）──
 
@@ -285,6 +290,7 @@ class WorkspaceState:
             id=uid(), anchor_id=target.id, content=content,
             quality=quality, timestamp=now(), agent_id=agent_id,
             relation=relation, target_memory_id=target_memory_id,
+            added_iter=self._iteration,
         )
         self.evidences.append(e)
         target.evidence_ids.append(e.id)
@@ -392,51 +398,88 @@ class WorkspaceState:
                 anchor.description = best.content
 
     def _detect_conflicts(self, anchor_id: str):
-        """群内自洽检测：同锚点证据一致性过低 -> 生成 Conflict 记录并降锚点稳定性。
-        
-        阈值从环境变量 LIQUID_CONFLICT_THRESHOLD 读取（默认 0.2）。
-        复用 CPE 泛化防线思路：证据间平均关键词重叠 < threshold 且 >= 3 条 -> 潜在冲突/漂移。
-        保守处理：只标记'需人工确认'，不武断判相反（避免过度工程化误报）。
-
-        性能（v0.9）：原 O(g²) 全量成对扫描。相同 content 的两条证据重叠恒为 1.0，
-        对"内容分歧度"无信息量，故先按 content 去重为 distinct 集，只对 distinct 内容
-        求两两重叠 -> O(d²)（d = distinct content 数 ≤ g）。overlap_cache 复用。
-        语义更纯净：度量"不同论点间的分歧"，重复写入不再稀释冲突信号。
+        """群内自洽检测（Layer-1 修复：复用可替换 Projection Layer，惩罚持久化）。
+
+        旧实现用关键词重叠（Jaccard）近似"语义冲突"——本质是 Lexical Proxy，
+        会导致：① 对真异事实（关键词不重叠）误触发；② 对近重复（关键词高重叠）
+        反而不触发（反相关）；③ 自建一套不可替换的投影启发式（Hidden Projection Layer）。
+
+        修复：若 WorkspaceState.canon_fn 已注入，则冲突判定改用同一 Projection Layer——
+        两条 distinct content 证据，若投影到【同一 CP】但 relation 相反（一 support 一
+        contradiction）-> 真冲突；若投影同 CP 同 relation -> 近重复（不冲突）；
+        若投影不同 CP -> 即使关键词重叠也不算冲突（语义独立）。
+
+        惩罚持久化：锚点稳定性惩罚写入锚点字段 conflict_penalty（累积乘子），
+        _recalc_anchor 在合成 stability 时乘入，因此 load / step 重算后惩罚不丢失
+        （旧实现在 stability 字段上直接 *=0.9，被后续 recalc 覆盖，故不持久）。
+
+        canon_fn 为 None 时回退旧 _keyword_overlap 行为，保证生产向后兼容。
         """
         import os
         conflict_threshold = float(os.environ.get('LIQUID_CONFLICT_THRESHOLD', '0.2'))
-        
+
         group = [e for e in self.evidences if e.anchor_id == anchor_id]
-        if len(group) < 3:
+        if len(group) < 2:
             return
-        # ── O(g²) -> O(d²)：content 去重，相同 content 对的重叠恒为 1.0 不参与分歧度量 ──
         distinct: list = []
         seen: set = set()
         for e in group:
             if e.content and e.content not in seen:
                 seen.add(e.content)
                 distinct.append(e.content)
-        n = len(distinct)
-        if n < 2:
-            return
-        overlaps = []
-        for i in range(n):
-            for j in range(i + 1, n):
-                overlaps.append(_keyword_overlap(distinct[i], distinct[j], self.overlap_cache))
-        if not overlaps:
+
+        # ── 回退路径：未注入 Projection Layer -> 旧关键词重叠行为（向后兼容）──
+        if self.canon_fn is None:
+            if len(distinct) < 2:
+                return
+            overlaps = []
+            for i in range(len(distinct)):
+                for j in range(i + 1, len(distinct)):
+                    overlaps.append(_keyword_overlap(distinct[i], distinct[j], self.overlap_cache))
+            if not overlaps:
+                return
+            avg = sum(overlaps) / len(overlaps)
+            if avg < conflict_threshold:
+                anchor = next((a for a in self.anchors if a.id == anchor_id), None)
+                if any(c.anchor_a == anchor_id for c in self.conflicts):
+                    return
+                self.conflicts.append(Conflict(
+                    anchor_a=anchor_id,
+                    description=f"证据间平均一致度 {avg:.2f}（<{conflict_threshold}），存在潜在冲突/漂移，需人工确认",
+                    severity=round(1.0 - avg, 2),
+                ))
+                if anchor:
+                    anchor.conflict_penalty = max(0.1, anchor.conflict_penalty * 0.9)
             return
-        avg = sum(overlaps) / len(overlaps)
-        if avg < conflict_threshold:
+
+        # ── Layer-1 路径：复用同一可替换 Projection Layer ──
+        # 按 CP 分组 distinct content；同 CP 内若同时有 support 与 contradiction -> 真冲突
+        by_cp: dict = {}
+        rel_by_content: dict = {}
+        for e in group:
+            cp = self.canon_fn(e.content)
+            by_cp.setdefault(cp, []).append(e.content)
+            rel_by_content.setdefault(e.content, set()).add(e.relation or "support")
+        triggered = False
+        for cp, contents in by_cp.items():
+            if len(contents) < 2:
+                continue
+            distinct_rels = set()
+            for c in contents:
+                distinct_rels |= (rel_by_content.get(c) or {"support"})
+            if "support" in distinct_rels and "contradiction" in distinct_rels:
+                triggered = True
+                break
+        if triggered:
             anchor = next((a for a in self.anchors if a.id == anchor_id), None)
-            if any(c.anchor_a == anchor_id for c in self.conflicts):
-                return
-            self.conflicts.append(Conflict(
-                anchor_a=anchor_id,
-                description=f"证据间平均一致度 {avg:.2f}（<{conflict_threshold}），存在潜在冲突/漂移，需人工确认",
-                severity=round(1.0 - avg, 2),
-            ))
+            if not any(c.anchor_a == anchor_id for c in self.conflicts):
+                self.conflicts.append(Conflict(
+                    anchor_a=anchor_id,
+                    description="Projection Layer 检测到同 CP 内存在 support 与 contradiction 异 relation 证据，判定为语义冲突",
+                    severity=conflict_threshold,
+                ))
             if anchor:
-                anchor.stability = max(0.1, anchor.stability * 0.9)
+                anchor.conflict_penalty = max(0.1, anchor.conflict_penalty * 0.9)
 
 
     def _recalc_anchor(self, anchor_id: str):
@@ -449,7 +492,7 @@ class WorkspaceState:
                 # base = 证据权重均值；stability = base + SEAL 自评层（seal_adjust 不被覆盖）
                 base = avg_weight
                 a.base_stability = base
-                a.stability = round(min(1.0, max(0.1, base + a.seal_adjust)), 3)
+                a.stability = round(min(1.0, max(0.1, base * a.conflict_penalty + a.seal_adjust)), 3)
                 evidence_count = len(group)
                 a.decay_value(evidence_count=evidence_count)
                 a.recalc_strength(evidence_count)
@@ -497,6 +540,7 @@ class WorkspaceState:
                                 s / (s + CONTRADICTION_WEIGHT * c + 1))), 3)
             if supports:
                 m.last_reinforced = max(e.timestamp for e in supports)
+                m.last_reinforced_iter = max(e.added_iter for e in supports)
 
     def step(self, dt: int = 1, decay_rate: float = 0.05):
         """显式时间动力学步（v0.8 液态循环核心）：
@@ -508,29 +552,29 @@ class WorkspaceState:
           若本轮有 support 证据 → 稳定性恢复到固有值（强化）；否则按时间衰减（无强化流失）
         - 重算锚点稳定性与审计更新时间
         """
+        prev_iter = self._iteration  # 上次 step 的迭代序号（τ 时间变量，非墙钟）
         # 1. 证据权重时间衰减
         for e in self.evidences:
             if not e.archived:
                 e.weight = max(e.weight * ((1 - decay_rate) ** dt), 0.05)
         # 2. 记忆稳定性：固有(计数驱动) + 时间衰减/强化
         for a in self.anchors:
-            self._update_memory_stability(a.id)
-        last_step = getattr(self, "_last_step_at", "")
-        now_dt = datetime.now(timezone.utc)
+            self._update_memory_stability(a.id)  # 内部以各 support 的 added_iter 最大值更新 last_reinforced_iter
         for m in self.memories:
             intrinsic = m.stability  # _update_memory_stability 已写入固有稳定性
-            # 强化 = 自上次 step 以来有过新 support 证据（last_reinforced 晚于上次 step）
-            reinforced = bool(m.last_reinforced) and (not last_step or m.last_reinforced > last_step)
+            # 强化 = 自上次 step（prev_iter）以来有新 support 证据抵达（last_reinforced_iter >= prev_iter）
+            # 以 τ=Effective Iteration 为时间变量，非墙钟，跨算力可比
+            reinforced = (m.last_reinforced_iter >= prev_iter)
             if reinforced:
                 m.stability = intrinsic  # 被强化：恢复到固有稳定性
             else:
                 # 无新强化：时间衰减，且不超过固有上限
                 m.stability = round(max(0.0, min(intrinsic,
                                     m.stability * ((1 - decay_rate) ** dt))), 3)
-        self._last_step_at = now()
         # 3. 重算锚点稳定性
         for a in self.anchors:
             self._recalc_anchor(a.id)
+        self._iteration += dt  # 推进有效状态更新计数（τ）
         self.updated_at = now()
 
 

{liquid_loop-0.9.0 → liquid_loop-0.9.2}/liquid_loop.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liquid-loop
-Version: 0.9.0
+Version: 0.9.2
 Summary: Self-Organizing Cognitive Memory for AI Agents — Liquid Loop theory implementation
 Author: fishbook0001
 Maintainer: fishbook0001
@@ -227,6 +227,30 @@ print(health["CCI"], health["consensus_crystals"])
 
 ---
 
+## 固态 A2A 通道（任意 MCP 客户端接入）
+
+把共享液环后端（地址由环境变量 `LIQUID_LOOP_BASE` 决定，默认 `http://127.0.0.1:8790`）封装成一个
+**stdio JSON-RPC 的 MCP server**，让任意支持 Model Context Protocol 的客户端（本例以 TRAE SOLO CN 演示）
+**原生读写同一份共享记忆**——这就是多 agent 间的固化（solidified）A2A 通道。
+
+> 后端说明：桥接只做协议翻译，**不内置 8790 服务**；后端由你自己部署（运行你自己的液环 SSE 服务，
+> 把地址通过 `LIQUID_LOOP_BASE` 传给桥接）。成核 / 共识 / 审计链全部由后端按液环理论执行。
+
+```bash
+# 在你的 MCP 客户端注册该 server（以 TRAE 为例；其 code CLI 路径随安装而异，请替换为你的路径）
+export PY=python3                                    # 任意 Python 3.10+ 解释器
+export SVR=examples/trae_mesh_mcp/mcp_server.py      # 本仓库内路径
+export LIQUID_LOOP_BASE=http://127.0.0.1:8790        # 改成你的后端地址
+"<path-to-your-trae-code-cli>" \
+  --add-mcp '{"servers":{"liquidloop-mesh":{"command":"'"$PY"'","args":["'"$SVR"'"]}}}'
+```
+
+桥接暴露 `liquidloop_remember` / `liquidloop_recall` / `liquidloop_metrics` 三个工具（写入**必须声明 `agent_id`**）。
+压测脚本与运维说明见 [`examples/trae_mesh_mcp/README.md`](examples/trae_mesh_mcp/README.md)
+（直连 + 经桥双路并发，零丢写 / 共识幂等 / 崩溃恢复三关全 PASS；所有路径走环境变量，适配不同部署拓扑）。
+
+---
+
 ## 定位：Self-Regulating Memory State Evolution
 
 > **North-Star 公理（一切代码与论文围绕它校验）：**

{liquid_loop-0.9.0 → liquid_loop-0.9.2}/liquid_loop.egg-info/SOURCES.txt

@@ -18,6 +18,7 @@ liquid_loop/mesh/__init__.py
 liquid_loop/mesh/v2.py
 tests/test_consensus_expansion.py
 tests/test_entropy.py
+tests/test_layer1_persistence.py
 tests/test_nucleate_dual_track.py
 tests/test_peek_seal.py
 tests/test_seal_persistence.py

{liquid_loop-0.9.0 → liquid_loop-0.9.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "liquid-loop"
-version = "0.9.0"
+version = "0.9.2"
 description = "Self-Organizing Cognitive Memory for AI Agents — Liquid Loop theory implementation"
 readme = "README.md"
 license = {text = "MIT"}

liquid_loop-0.9.2/tests/test_layer1_persistence.py

@@ -0,0 +1,71 @@
+"""Layer-1 修复回归测试：有效迭代 τ 持久化 + 可替换结构化投影层 + 冲突惩罚持久化。
+
+验证 v0.9.2 引入的修复在 save/load 往返后不丢失状态，且不破坏向后兼容。
+"""
+import pytest
+from pathlib import Path
+
+from liquid_loop.workspace import WorkspaceState
+from liquid_loop.storage import save, load
+
+
+def test_effective_iteration_persists_across_reload(tmp_path: Path):
+    """τ=有效迭代计数必须随 save/load 往返；否则重启后归零→强化门控恒真→时间衰减失效。"""
+    ws = WorkspaceState()
+    a = ws.add_anchor("x")
+    ws.add_evidence(a, "e1 support")
+    ws.add_evidence(a, "e2 support")
+    ws.step(dt=1)
+    ws.step(dt=1)
+    ws.step(dt=1)
+    assert ws._iteration == 3, f"_iteration 应推进到 3，实为 {ws._iteration}"
+
+    save(ws, tmp_path)
+    loaded = load(tmp_path)
+    assert loaded._iteration == 3, f"重载后 _iteration 丢失，实为 {loaded._iteration}"
+
+
+def test_canon_fn_structured_projection_triggers_true_conflict():
+    """canon_fn 注入后按 CP 精确分组：同 CP 内 support+contradiction 异 relation → 真冲突。"""
+    ws = WorkspaceState()
+    # 结构化投影：取首词为 CP（离散键，非向量/embedding——守住 North-Star 禁向量约束）
+    ws.canon_fn = lambda c: c.strip().split()[0]
+    a = ws.add_anchor("claim")
+    ws.add_evidence(a, "苹果很好吃 因为甜", relation="support")
+    ws.add_evidence(a, "苹果很好吃 因为脆", relation="contradiction")  # 同 CP 异 relation
+
+    assert len(ws.conflicts) == 1, f"应检测到 1 条真冲突，实为 {len(ws.conflicts)}"
+    assert "Projection Layer" in ws.conflicts[0].description
+    assert ws.anchors[0].conflict_penalty == 0.9, "冲突后惩罚乘子应降为 0.9"
+    # 惩罚乘入 stability（非直接改 stability，故 recalc 后不丢）
+    assert ws.anchors[0].stability < 1.0
+
+
+def test_conflict_penalty_persists_across_reload(tmp_path: Path):
+    """conflict_penalty 累积乘子必须持久化；旧实现直接改 stability 会被 recalc 覆盖。"""
+    ws = WorkspaceState()
+    ws.canon_fn = lambda c: c.strip().split()[0]
+    a = ws.add_anchor("claim")
+    ws.add_evidence(a, "猫很可爱 因为黏人", relation="support")
+    ws.add_evidence(a, "猫很可爱 因为高冷", relation="contradiction")
+
+    penalty_before = ws.anchors[0].conflict_penalty
+    assert penalty_before == 0.9
+
+    save(ws, tmp_path)
+    loaded = load(tmp_path)
+    assert loaded.anchors[0].conflict_penalty == 0.9, "重载后冲突惩罚丢失"
+    assert len(loaded.conflicts) == 1, "重载后冲突记录丢失"
+    # canon_fn 是运行时注入项，save 前应被 pop，重载后回退 None（向后兼容路径）
+    assert loaded.canon_fn is None, "canon_fn 不应被持久化（运行时注入项）"
+
+
+def test_canon_fn_none_falls_back_to_keyword_overlap():
+    """canon_fn=None → 回退旧关键词重叠行为，保证生产向后兼容（不崩、能检测冲突）。"""
+    ws = WorkspaceState()  # canon_fn 默认 None
+    a = ws.add_anchor("topic")
+    ws.add_evidence(a, "量子计算利用叠加态加速", relation="support")
+    ws.add_evidence(a, "古典吉他音色温暖动人", relation="support")
+    # 两组关键词零重叠 → 平均一致度 < 默认阈值 0.2 → 触发保守冲突标记
+    assert len(ws.conflicts) == 1, "回退路径应仍能检测低重叠潜在冲突"
+    assert "一致度" in ws.conflicts[0].description