liquid-loop 0.6.2__tar.gz → 0.7.0__tar.gz

{liquid_loop-0.6.2 → liquid_loop-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liquid-loop
-Version: 0.6.2
+Version: 0.7.0
 Summary: Self-Organizing Cognitive Memory for AI Agents — Liquid Loop theory implementation
 Author: fishbook0001
 Maintainer: fishbook0001
@@ -147,6 +147,26 @@ liquid-loop snapshot
 
 ---
 
+## MESH 集成（多智能体共识）
+
+液环从 v0.7.0 起内置官方 MESH 集成 `liquid_loop.mesh`，把"多智能体共识协议"落地为可复用代码，作为 agent-mesh 节点的标准接入层。
+
+```python
+from liquid_loop.mesh import validate_evidence, compute_cci, cognitive_health, fetch_state
+
+# agent 写入前契约自检（零向量：content 必须精确字符串，禁 embedding）
+ok, errs = validate_evidence({"agent_id": "vera", "content": "用户偏好简洁输出"})
+
+# 从 8790 拉取记忆状态，算主体间性共识指数 CCI
+items = fetch_state("http://127.0.0.1:8790")
+health = cognitive_health(items)
+print(health["CCI"], health["consensus_crystals"])
+```
+
+零向量哲学：一致性判定走**结构化精确相等 + 审计链哈希**，绝不引入任何 embedding / 相似度。规范详见 `mesh/liquid_loop_mesh_v2_spec.md`。
+
+---
+
 ## 架构对比
 
 ```
@@ -194,6 +214,7 @@ liquid-loop/
 │   ├── workspace.py     # 核心数据模型 + AuditChain + auto_classify + decay
 │   ├── storage.py       # JSON 持久化 + 审计链写入
 │   ├── entropy.py       # 四维熵值计算
+│   ├── mesh/            # MESH v2 多智能体共识协议集成（validate_evidence / compute_cci / ...）
 │   └── cli.py           # Click CLI (11 命令)
 ├── examples/
 │   └── quickstart.py
@@ -220,7 +241,7 @@ pytest -v
 ## 路线图
 
 - [ ] 语义一致性结晶（嵌入相似度替代精确匹配）
-- [ ] 多 Agent 液环耦合
+- [x] 多 Agent 液环耦合（`liquid_loop.mesh` v2 共识协议，2026-07-15 落地）
 - [ ] LX 扩展：世界模型预测纳入液环
 - [ ] LoCoMo / LongMemEval 基准对比
 - [ ] 边缘端部署优化（<50KB）

{liquid_loop-0.6.2 → liquid_loop-0.7.0}/README.md

@@ -108,6 +108,26 @@ liquid-loop snapshot
 
 ---
 
+## MESH 集成（多智能体共识）
+
+液环从 v0.7.0 起内置官方 MESH 集成 `liquid_loop.mesh`，把"多智能体共识协议"落地为可复用代码，作为 agent-mesh 节点的标准接入层。
+
+```python
+from liquid_loop.mesh import validate_evidence, compute_cci, cognitive_health, fetch_state
+
+# agent 写入前契约自检（零向量：content 必须精确字符串，禁 embedding）
+ok, errs = validate_evidence({"agent_id": "vera", "content": "用户偏好简洁输出"})
+
+# 从 8790 拉取记忆状态，算主体间性共识指数 CCI
+items = fetch_state("http://127.0.0.1:8790")
+health = cognitive_health(items)
+print(health["CCI"], health["consensus_crystals"])
+```
+
+零向量哲学：一致性判定走**结构化精确相等 + 审计链哈希**，绝不引入任何 embedding / 相似度。规范详见 `mesh/liquid_loop_mesh_v2_spec.md`。
+
+---
+
 ## 架构对比
 
 ```
@@ -155,6 +175,7 @@ liquid-loop/
 │   ├── workspace.py     # 核心数据模型 + AuditChain + auto_classify + decay
 │   ├── storage.py       # JSON 持久化 + 审计链写入
 │   ├── entropy.py       # 四维熵值计算
+│   ├── mesh/            # MESH v2 多智能体共识协议集成（validate_evidence / compute_cci / ...）
 │   └── cli.py           # Click CLI (11 命令)
 ├── examples/
 │   └── quickstart.py
@@ -181,7 +202,7 @@ pytest -v
 ## 路线图
 
 - [ ] 语义一致性结晶（嵌入相似度替代精确匹配）
-- [ ] 多 Agent 液环耦合
+- [x] 多 Agent 液环耦合（`liquid_loop.mesh` v2 共识协议，2026-07-15 落地）
 - [ ] LX 扩展：世界模型预测纳入液环
 - [ ] LoCoMo / LongMemEval 基准对比
 - [ ] 边缘端部署优化（<50KB）

{liquid_loop-0.6.2 → liquid_loop-0.7.0}/liquid_loop/__init__.py

@@ -1,10 +1,10 @@
-"""Liquid Loop — Workspace Cognitive Runtime v0.6.1 (CPE-fused, proactive, rhythmic sampling)"""
-__version__ = "0.6.1"
+"""Liquid Loop — Workspace Cognitive Runtime v0.7.0 (CPE-fused, SEAL dual-opt, dual-track multi-agent, MESH v2 integration)"""
+__version__ = "0.7.0"
 
 from .workspace import (
     WorkspaceState, Anchor, Evidence, Memory, Conflict,
     AuditChain, CPERegularizer, SelfRefineEngine,
     rhythmic_retrieve,
 )
-from .storage import load, save
+from .storage import load, save, locked_state
 from .entropy import calculate, calculate_detail, calculate as calculate_entropy

liquid_loop-0.7.0/liquid_loop/cognitive_budget.py

@@ -0,0 +1,105 @@
+"""认知预算稳态器（落地 PEEK arXiv:2604.09932 固定预算驱逐）
+
+把 PEEK 三模块蒸馏并适配液环：
+  Distiller     evidence.weight + anchor.value_score + recency → 蒸馏价值
+  Cartographer  价值 × (0.5+0.5*访问热度) × 流动性 → 重要性
+  Evictor       超额时驱逐最低重要性证据，标记 archived（冷归档，零丢失）
+
+设计哲学（呼应液环零向量/零丢失）：
+  驱逐 ≠ 删除。超预算证据标记 archived=True，从活跃检索集移出（recall 跳过），
+  但数据与审计链完整保留，可随时解冻。记忆系统因此维持"稳态预算"而非无限膨胀。
+
+预算来源：环境变量 LIQUID_EVIDENCE_BUDGET（默认 0 = 不限制）。
+"""
+from __future__ import annotations
+import os
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Optional
+
+LIQUIDITY_HEAT = {"hot": 1.0, "warm": 0.7, "cold": 0.4, "frozen": 0.1}
+
+
+@dataclass
+class _BudgetItem:
+    id: str
+    weight: float = 1.0
+    anchor_value: float = 1.0
+    access_count: int = 0
+    liquidity: str = "warm"
+    gap_hours: float = 0.0
+    distilled_value: float = 0.0
+    importance: float = 0.0
+
+
+def _distill(it: _BudgetItem) -> float:
+    recency = 1.0 / (1.0 + it.gap_hours / 168.0)
+    v = 0.4 * it.weight + 0.3 * it.anchor_value + 0.3 * recency
+    it.distilled_value = max(0.0, min(1.0, v))
+    return it.distilled_value
+
+
+def _rank(items: list[_BudgetItem]) -> list[_BudgetItem]:
+    for it in items:
+        if it.distilled_value == 0.0:
+            _distill(it)
+        access_heat = min(it.access_count / 10.0, 1.0)
+        liquidity_heat = LIQUIDITY_HEAT.get(it.liquidity, 0.4)
+        it.importance = it.distilled_value * (0.5 + 0.5 * access_heat) * liquidity_heat
+    return sorted(items, key=lambda x: x.importance, reverse=True)
+
+
+def _evict(items: list[_BudgetItem], budget: int) -> list[_BudgetItem]:
+    if len(items) <= budget:
+        return []
+    ranked = _rank(items)
+    return ranked[budget:]  # 尾部最低重要性
+
+
+class CognitiveBudgetStabilizer:
+    """接 WorkspaceState，超预算时冷归档低价值证据"""
+
+    def __init__(self, state, budget: Optional[int] = None):
+        self.state = state
+        self.budget = budget if budget is not None else int(os.environ.get("LIQUID_EVIDENCE_BUDGET", "0"))
+
+    @staticmethod
+    def _gap_hours(anchor) -> float:
+        if not anchor or not anchor.last_accessed:
+            return 9999.0
+        try:
+            last = datetime.fromisoformat(anchor.last_accessed)
+            return (datetime.now(timezone.utc) - last).total_seconds() / 3600
+        except ValueError:
+            return 9999.0
+
+    def stabilize(self) -> dict:
+        if self.budget <= 0:
+            return {"evicted": 0, "budget": 0, "total": len(self.state.evidences),
+                    "note": "预算未设置（LIQUID_EVIDENCE_BUDGET=0），跳过"}
+        evs = self.state.evidences
+        if len(evs) <= self.budget:
+            return {"evicted": 0, "budget": self.budget, "total": len(evs)}
+        anchor_map = {a.id: a for a in self.state.anchors}
+        items: list[_BudgetItem] = []
+        for e in evs:
+            a = anchor_map.get(e.anchor_id)
+            items.append(_BudgetItem(
+                id=e.id,
+                weight=e.weight,
+                anchor_value=a.value_score if a else 0.5,
+                access_count=a.access_count if a else 0,
+                liquidity=a.liquidity if a else "warm",
+                gap_hours=self._gap_hours(a),
+            ))
+        evicted = _evict(items, self.budget)
+        evicted_ids = {it.id for it in evicted}
+        for e in evs:
+            if e.id in evicted_ids:
+                e.archived = True  # 冷归档，零丢失
+        return {
+            "evicted": len(evicted_ids),
+            "evicted_ids": list(evicted_ids),
+            "budget": self.budget,
+            "total": len(evs),
+        }

liquid_loop-0.7.0/liquid_loop/mesh/__init__.py

@@ -0,0 +1,50 @@
+"""
+liquid_loop.mesh — 液环 MESH 进阶版（v2）共识协议集成
+=====================================================
+把"多智能体共识协议规范"从文档落地为可复用代码，作为 liquid-loop 的官方
+MESH 集成层。零向量哲学：一致性判定走结构化精确相等 + 审计链哈希，绝不引入
+任何 embedding / 相似度。
+
+职责（详见 .v2）：
+  - validate_evidence()    agent 侧契约自检（结构化证据 schema）
+  - check_contract()       双向契约合规检查（身份 / 写 / 消费 / 冲突）
+  - compute_cci()          主体间性共识指数（记忆层）
+  - cognitive_health()     统一认知健康仪表盘（CCI / drift / H_e / P_mem）
+  - detect_conflict()      同锚点冲突证据检测
+  - fetch_state()          从 8790 REST /list 拉取当前状态
+  - main()                 连接 8790 打印认知健康报告（CLI）
+
+快速使用：
+    from liquid_loop.mesh import validate_evidence, compute_cci, cognitive_health
+    from liquid_loop.mesh import fetch_state, main
+
+    ok, errs = validate_evidence({"agent_id": "vera", "content": "..."})
+    health = cognitive_health(fetch_state())
+"""
+from .v2 import (
+    REGISTRY,
+    CLAIM_TYPES,
+    SCOPES,
+    Evidence,
+    validate_evidence,
+    check_contract,
+    compute_cci,
+    cognitive_health,
+    detect_conflict,
+    fetch_state,
+    main,
+)
+
+__all__ = [
+    "REGISTRY",
+    "CLAIM_TYPES",
+    "SCOPES",
+    "Evidence",
+    "validate_evidence",
+    "check_contract",
+    "compute_cci",
+    "cognitive_health",
+    "detect_conflict",
+    "fetch_state",
+    "main",
+]

liquid_loop-0.7.0/liquid_loop/mesh/v2.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python3
+"""
+liquid_loop_mesh_v2.py — 液环 MESH 进阶版（v2）参考实现
+======================================================
+把"共识协议规范"从文档落地为可复用代码。零向量哲学：一致性判定走
+结构化精确相等 + 审计链哈希，绝不引入任何 embedding / 相似度。
+
+职责：
+  1. validate_evidence()      — agent 侧契约自检（结构化证据 schema）
+  2. check_contract()         — 双向契约合规检查（身份/写/消费/冲突）
+  3. compute_cci()            — 主体间性共识指数（记忆层）
+  4. cognitive_health()       — 统一认知健康仪表盘（CCI / drift / H_e / P_mem）
+  5. detect_conflict()        — 同锚点冲突证据检测
+  6. fetch_state()            — 从 8790 REST /list 拉取当前状态
+
+依赖：标准库 + 可选 liquid_loop（仅类型提示）。可直接 import 使用，
+也可 `python3 liquid_loop_mesh_v2.py` 连 8790 打印健康报告。
+"""
+from __future__ import annotations
+import json
+import sys
+import urllib.request
+from dataclasses import dataclass, field
+from typing import Optional
+
+# ── agent-mesh 注册表（接入 agent 的唯一 id 白名单）──────────────
+REGISTRY = {"workbuddy", "vera", "qwenpaw", "marvis", "parlant-ctrl", "cawpaw", "tabbit", "llama"}
+
+CLAIM_TYPES = {"fact", "conclusion", "preference", "conflict"}
+SCOPES = {"private", "consensus"}
+
+
+# ── 1. 结构化证据 schema 校验 ──────────────────────────────────
+@dataclass
+class Evidence:
+    agent_id: str
+    content: str
+    category: str = "fact"
+    claim_type: str = "fact"
+    value: Optional[float] = None
+    session_id: str = ""
+    prev_hash: str = ""
+    id: str = ""
+
+    def to_dict(self) -> dict:
+        return {
+            "agent_id": self.agent_id,
+            "content": self.content,
+            "category": self.category,
+            "claim_type": self.claim_type,
+            "value": self.value,
+            "session_id": self.session_id,
+            "prev_hash": self.prev_hash,
+            "id": self.id,
+        }
+
+
+def validate_evidence(ev: dict) -> tuple[bool, list[str]]:
+    """agent 侧契约自检：返回 (ok, 错误列表)。"""
+    errs: list[str] = []
+    if not ev.get("agent_id"):
+        errs.append("agent_id 必填（共用机制要求声明写入者标识）")
+    elif ev["agent_id"] not in REGISTRY:
+        errs.append(f"agent_id '{ev['agent_id']}' 未在 mesh 注册表（禁止匿名污染）")
+    if not ev.get("content"):
+        errs.append("content 必填（一致性比对键）")
+    ct = ev.get("claim_type", "fact")
+    if ct not in CLAIM_TYPES:
+        errs.append(f"claim_type '{ct}' 非法，须为 {sorted(CLAIM_TYPES)}")
+    # content 精确相等判定 → 禁止任何 embedding/相似度
+    if ev.get("content") and not isinstance(ev["content"], str):
+        errs.append("content 必须为精确字符串（零向量一致性比对键）")
+    return (len(errs) == 0, errs)
+
+
+# ── 2. 双向契约合规检查 ────────────────────────────────────────
+def check_contract(agent_id: str, did_recall: bool, wrote_structured: bool) -> tuple[bool, list[str]]:
+    """①身份 ②结构化写 ③主动消费 ④冲突响应(由 detect_conflict 触发)。"""
+    errs: list[str] = []
+    if agent_id not in REGISTRY:
+        errs.append("① 身份未声明/未注册")
+    if not wrote_structured:
+        errs.append("② 未结构化写入（缺 claim_type/session_id/prev_hash）")
+    if not did_recall:
+        errs.append("③ 会话未主动消费 consensus 视图（退化成孤岛）")
+    return (len(errs) == 0, errs)
+
+
+# ── 3. CCI 主体间性共识指数（记忆层）────────────────────────────
+def compute_cci(items: list[dict]) -> dict:
+    """CCI_mem = |consensus| / (|consensus| + |private|)。"""
+    cons = [x for x in items if x.get("scope") == "consensus"]
+    priv = [x for x in items if x.get("scope") == "private"]
+    denom = len(cons) + len(priv)
+    cci = (len(cons) / denom) if denom else 0.0
+    # 共识强度 secondary：平均 contributors 基数
+    strengths = [len(x.get("contributors", [])) for x in cons] or [0]
+    avg_strength = sum(strengths) / len(strengths) if strengths else 0
+    return {
+        "cci": round(cci, 4),
+        "consensus": len(cons),
+        "private": len(priv),
+        "avg_contributors": round(avg_strength, 2),
+    }
+
+
+# ── 4. 统一认知健康仪表盘 ─────────────────────────────────────
+def cognitive_health(items: list[dict], drift_rate: float = 0.0,
+                     H_e: float = 0.0, P_mem: float = 0.0) -> dict:
+    cci = compute_cci(items)
+    evs = [x for x in items if x.get("type") == "evidence"]
+    from collections import Counter
+    by_agent = Counter(x.get("agent_id") for x in evs)
+    return {
+        "CCI": cci["cci"],
+        "consensus_crystals": cci["consensus"],
+        "private_crystals": cci["private"],
+        "drift_rate": drift_rate,
+        "H_e": H_e,
+        "P_mem": P_mem,
+        "total_evidence": len(evs),
+        "agents": dict(by_agent),
+    }
+
+
+# ── 5. 冲突检测 ───────────────────────────────────────────────
+def detect_conflict(items: list[dict]) -> list[dict]:
+    """同锚点下 claim_type=conflict 或同 content 反义 → 标记冲突 agent。"""
+    conflicts = []
+    by_cat = {}
+    for x in items:
+        if x.get("type") in ("evidence", "memory"):
+            by_cat.setdefault(x.get("category", "?"), []).append(x)
+    for cat, recs in by_cat.items():
+        conflict_recs = [r for r in recs if r.get("claim_type") == "conflict"]
+        if conflict_recs:
+            agents = sorted({r.get("agent_id") for r in conflict_recs if r.get("agent_id")})
+            conflicts.append({"anchor": cat, "conflict_agents": agents,
+                              "kind": "explicit_conflict"})
+    return conflicts
+
+
+# ── 6. 从 8790 拉取状态 ───────────────────────────────────────
+def fetch_state(base: str = "http://127.0.0.1:8790") -> list[dict]:
+    req = urllib.request.Request(base + "/list", data=b"{}",
+                                 headers={"Content-Type": "application/json"})
+    with urllib.request.urlopen(req, timeout=5) as r:
+        d = json.load(r)
+    return d if isinstance(d, list) else d.get("result", d.get("items", []))
+
+
+# ── CLI：打印健康报告 ──────────────────────────────────────────
+def main():
+    try:
+        items = fetch_state()
+    except Exception as e:
+        print(f"[ERR] 无法连接 8790: {e}")
+        sys.exit(1)
+    health = cognitive_health(items)
+    print("=== 液环 MESH v2 认知健康仪表盘 ===")
+    for k, v in health.items():
+        print(f"  {k:18}: {v}")
+    conf = detect_conflict(items)
+    if conf:
+        print("\n=== 冲突锚点 ===")
+        for c in conf:
+            print(" ", c)
+    else:
+        print("\n[OK] 无显式冲突")
+
+
+if __name__ == "__main__":
+    main()

{liquid_loop-0.6.2 → liquid_loop-0.7.0}/liquid_loop/storage.py

@@ -36,7 +36,12 @@ def _file_lock(filepath: str, mode: str = "w"):
         finally:
             fcntl.flock(f, fcntl.LOCK_UN)
 
+def _lock_path(workspace_root: Path) -> Path:
+    return _ensure_dir(workspace_root) / "state.lock"
+
+
 def load(workspace_root: Path) -> WorkspaceState:
+    """纯读取，无锁。并发安全由上层 locked_state 上下文保证。"""
     path = _ensure_dir(workspace_root) / STATE_FILE
     if not path.exists():
         return WorkspaceState()
@@ -46,6 +51,7 @@ def load(workspace_root: Path) -> WorkspaceState:
 
 
 def save(state: WorkspaceState, workspace_root: Path):
+    """原子写（temp+rename）：崩溃永不留下半截文件。锁由 locked_state 持有。"""
     state.updated_at = now()
     path = _ensure_dir(workspace_root) / STATE_FILE
     # 审计链：记录并回写哈希
@@ -59,8 +65,28 @@ def save(state: WorkspaceState, workspace_root: Path):
     data = asdict(state)
     # overlap_cache 仅为运行时熵计算缓存，键为 tuple，不可 JSON 序列化，且不具持久价值
     data.pop("overlap_cache", None)
-    with open(path, "w", encoding="utf-8") as f:
+    tmp = path.with_suffix(".tmp")
+    with open(tmp, "w", encoding="utf-8") as f:
         json.dump(data, f, indent=2, ensure_ascii=False)
+        f.flush()
+        os.fsync(f.fileno())
+    os.replace(tmp, path)  # POSIX 原子替换，读端永不看到半截文件
+
+
+@contextmanager
+def locked_state(workspace_root: Path):
+    """单一锁层：排他锁跨 load→modify→save 整段，根除并发丢写(P0)。
+    跨进程安全（fcntl 建议锁）；server 与批量喂入脚本共用同一把锁。"""
+    d = _ensure_dir(workspace_root)
+    lk = open(d / "state.lock", "w")
+    fcntl.flock(lk, fcntl.LOCK_EX)
+    try:
+        st = load(workspace_root)
+        yield st
+        save(st, workspace_root)
+    finally:
+        fcntl.flock(lk, fcntl.LOCK_UN)
+        lk.close()
 
 
 def _from_dict(data: dict) -> WorkspaceState:

{liquid_loop-0.6.2 → liquid_loop-0.7.0}/liquid_loop/workspace.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from typing import Optional, List, Dict, Any
@@ -9,6 +11,8 @@ import os
 import re
 from collections import Counter
 
+from .cognitive_budget import CognitiveBudgetStabilizer
+
 
 def now() -> str:
     return datetime.now(timezone.utc).isoformat()
@@ -84,6 +88,7 @@ class Anchor:
     last_accessed: str = ""
     value_score: float = 1.0
     anchor_strength: float = 1.0
+    seal_adjust: float = 0.0  # SEAL 自评层增量；_recalc 合成进 stability，不被覆盖（解 v0.6.3 假落地）
 
     def decay_value(self, factor: float = 0.95, evidence_count: int = 0) -> float:
         if not self.created_at:
@@ -149,6 +154,8 @@ class Evidence:
     timestamp: str = field(default_factory=now)
     weight: float = 1.0
     quality: str = "normal"
+    archived: bool = False  # 预算超额冷归档标记（PEEK 落地，零丢失）
+    agent_id: str = ""  # 多智能体共用：写入者标识（共用机制，缺省=legacy/单实例）
 
 
 @dataclass
@@ -158,6 +165,8 @@ class Memory:
     formed_at: str = field(default_factory=now)
     evidence_ids: list[str] = field(default_factory=list)
     confidence: float = 0.0
+    scope: str = "private"  # 结晶来源: private(同 agent≥2一致) / consensus(跨 distinct owner≥2一致)
+    contributors: list[str] = field(default_factory=list)  # 参与成核的 agent_id 列表
 
 
 @dataclass
@@ -239,10 +248,11 @@ class WorkspaceState:
         self.updated_at = now()
         return a
 
-    def add_evidence(self, anchor: str, content: str, quality: float = 1.0) -> Optional[Evidence]:
+    def add_evidence(self, anchor, content: str, quality: float = 1.0, agent_id: str = "") -> Optional[Evidence]:
         """向指定锚点添加一条证据。
 
         anchor 参数兼容：锚点名称(str) | 锚点ID(str) | Anchor对象
+        agent_id：多智能体共用写入者标识（缺省空=legacy/单实例）
         """
         target = None
         if isinstance(anchor, Anchor):
@@ -254,9 +264,13 @@ class WorkspaceState:
                 target = next((a for a in self.anchors if a.id == anchor), None)
         if not target:
             return None
+        # 幂等去重：同锚点+同内容+同 agent 已存在则复用，防止重复证据膨胀（mesh 重试/高频喂入）
+        for ex in self.evidences:
+            if ex.anchor_id == target.id and ex.content == content and ex.agent_id == agent_id:
+                return ex
         e = Evidence(
             id=uid(), anchor_id=target.id, content=content,
-            quality=quality, timestamp=now(),
+            quality=quality, timestamp=now(), agent_id=agent_id,
         )
         self.evidences.append(e)
         target.evidence_ids.append(e.id)
@@ -266,11 +280,18 @@ class WorkspaceState:
         return e
 
     def _on_evidence_added(self, anchor_id: str):
-        """证据添加后的统一后处理：衰减→成核→稳定性刷新→冲突检测"""
+        """证据添加后的统一后处理：衰减→成核→稳定性刷新→冲突检测→预算稳态"""
         self._decay_anchor(anchor_id)
         self._nucleate(anchor_id)
         self._recalc_anchor(anchor_id)
         self._detect_conflicts(anchor_id)
+        self._stabilize_budget()
+
+    def _stabilize_budget(self):
+        """认知预算稳态（PEEK 落地）：超预算时冷归档最低价值证据。默认无预算不动作。"""
+        result = CognitiveBudgetStabilizer(self).stabilize()
+        if result.get("evicted", 0) > 0:
+            self.updated_at = now()
 
     def _decay_anchor(self, anchor_id: str):
         for e in self.evidences:
@@ -278,31 +299,68 @@ class WorkspaceState:
                 e.weight = max(e.weight * 0.95, 0.1)
 
     def _nucleate(self, anchor_id: str):
-        """成核：同锚点下 >= 2 条一致证据形成记忆结晶。
+        """双轨成核（多智能体共用机制）：
+
+        - private 轨：同一 agent_id 下 >= 2 条一致证据 -> scope=private 结晶
+        - consensus 轨：同一 content 被 >= 2 个 distinct agent_id 证据支持 -> scope=consensus 结晶
 
-        复合键判定：查重限定在当前锚点内（(anchor_id, content)），避免跨锚点
-        同 content 证据被错误吞掉或并入同一结晶（P0 跨锚点误结晶修复, v0.6.2）。
+        复合键 (anchor_id, content, scope) 防跨锚点/跨轨污染。
+        兼容 legacy：agent_id 为空视为单实例私有（走 private 轨，contributors=["legacy"]）。
         """
         group = [e for e in self.evidences if e.anchor_id == anchor_id]
         if len(group) < 2:
             return
-        # 本锚点已结晶的 content 集合（复合键判定，杜绝跨锚点污染）
-        crystallized_contents: set[str] = set()
+        # 已结晶键集合（复合键判定，杜绝跨锚点/跨轨污染）
+        crystallized_keys: set = set()
         for m in self.memories:
             for eid in m.evidence_ids:
                 ev = next((e for e in self.evidences if e.id == eid), None)
                 if ev is not None and ev.anchor_id == anchor_id:
-                    crystallized_contents.add(m.content)
+                    crystallized_keys.add((m.content, m.scope))
                     break
-        content_counts = Counter(e.content for e in group)
-        for content, count in content_counts.items():
-            if count >= 2 and content not in crystallized_contents:
-                evidence_ids = [e.id for e in group if e.content == content]
-                confidence = min(count / len(group), 1.0)
+        from collections import defaultdict
+        # ── private 轨：按 agent_id 分组，组内同 content >= 2 ──
+        by_agent: dict = defaultdict(list)
+        for e in group:
+            by_agent[e.agent_id if e.agent_id else "legacy"].append(e)
+        for owner, evs in by_agent.items():
+            content_counts = Counter(e.content for e in evs)
+            for content, count in content_counts.items():
+                if count >= 2 and (content, "private") not in crystallized_keys:
+                    evidence_ids = [e.id for e in evs if e.content == content]
+                    confidence = min(count / len(evs), 1.0)
+                    self.memories.append(Memory(
+                        content=content,
+                        evidence_ids=evidence_ids,
+                        confidence=confidence,
+                        scope="private",
+                        contributors=[owner],
+                    ))
+        # ── consensus 轨：跨 distinct owner 同 content >= 2 ──
+        owners_by_content: dict = defaultdict(set)
+        for e in group:
+            if not e.agent_id:
+                continue  # legacy 不参与共识轨（无法跨主体）
+            owners_by_content[e.content].add(e.agent_id)
+        for content, owners in owners_by_content.items():
+            if len(owners) < 2:
+                continue
+            # 已存在的共识结晶：把新一致方并入 contributors（动态扩展，支撑三方+ CCI 计量）
+            existing = next((m for m in self.memories if m.scope == "consensus" and m.content == content), None)
+            if existing is not None:
+                merged = set(existing.contributors) | owners
+                if merged != set(existing.contributors):
+                    existing.contributors = sorted(merged)
+                continue
+            if (content, "consensus") not in crystallized_keys:
+                evidence_ids = [e.id for e in group if e.content == content and e.agent_id in owners]
+                confidence = min(len(owners) / 2.0, 1.0)
                 self.memories.append(Memory(
                     content=content,
                     evidence_ids=evidence_ids,
                     confidence=confidence,
+                    scope="consensus",
+                    contributors=sorted(owners),
                 ))
         # 成核后触发自动描述回流（仅当描述为空）
         self._auto_describe_anchor(anchor_id)
@@ -360,7 +418,10 @@ class WorkspaceState:
         avg_weight = sum(e.weight for e in group) / len(group)
         for a in self.anchors:
             if a.id == anchor_id:
-                a.stability = avg_weight
+                # 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)
                 evidence_count = len(group)
                 a.decay_value(evidence_count=evidence_count)
                 a.recalc_strength(evidence_count)
@@ -851,6 +912,51 @@ class SelfRefineEngine:
                     repairs.append(f"REPAIR: 为锚点[{target_anchor.name}]新增evidence: {gold[:40]}")
         return repairs
 
+    # ── SEAL 落地（arXiv:2605.24426 失败诊断双优化）──
+    def diagnose(self, failure: Dict[str, Any]) -> Dict[str, Any]:
+        """SEAL 诊断：失败探测归因到锚点，判定失败类型。
+
+        fail_type:
+          retrieval  召回失败（记忆存在但未检索到）→ 策略侧 boost_stability
+          reason     推理失败（检索到但判断不中）   → 策略侧 downweight_noise
+        """
+        reason = failure.get("reason", "")
+        if "检索" in reason or "无相关" in reason:
+            fail_type = "retrieval"
+        else:
+            fail_type = "reason"
+        source = failure.get("source", "")
+        target = None
+        if source:
+            target = next((a for a in self.state.anchors if a.id == source), None)
+            if not target:
+                ev = next((e for e in self.state.evidences if e.id == source), None)
+                if ev:
+                    target = next((a for a in self.state.anchors if a.id == ev.anchor_id), None)
+        if fail_type == "retrieval":
+            tune = "boost_stability"
+            root = "召回失败：记忆存在但未检索到（权重/描述召回不足）"
+        else:
+            tune = "downweight_noise"
+            root = "推理失败：检索到但关键词判断不中（噪声/描述歧义）"
+        return {"fail_type": fail_type, "target_anchor": target.id if target else None,
+                "root_cause": root, "tune": tune}
+
+    def apply_strategy(self, diag: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """SEAL 双优化 - 策略侧：修复确认→boost_stability；噪声→downweight。"""
+        if not diag.get("target_anchor"):
+            return []
+        a = next((x for x in self.state.anchors if x.id == diag["target_anchor"]), None)
+        if not a:
+            return []
+        if diag["tune"] == "boost_stability":
+            a.seal_adjust = min(0.5, round(a.seal_adjust + 0.1, 3))
+        else:
+            a.seal_adjust = max(-0.5, round(a.seal_adjust - 0.1, 3))
+        base = getattr(a, "base_stability", a.stability)
+        projected = round(min(1.0, max(0.1, base + a.seal_adjust)), 3)
+        return [{"op": diag["tune"], "anchor": a.name, "seal_adjust": a.seal_adjust, "projected_stability": projected}]
+
     def run(self, evidence_ids: List[str] = None) -> Dict[str, Any]:
         """执行完整后向自进化周期。"""
         probes = self.generate_probes(evidence_ids)
@@ -862,10 +968,15 @@ class SelfRefineEngine:
         failures = [r for p, r in zip(probes, results)
                     if not r.get("passed") and p.get("type") != "overview"]
         repairs = self.repair(failures)
+        # SEAL 双优化 - 策略侧：诊断失败 → 调锚点 stability
+        diagnoses = [self.diagnose(f) for f in failures]
+        strategy_actions = []
+        for d in diagnoses:
+            strategy_actions.extend(self.apply_strategy(d))
         self.state.self_refine_probes = probes
         self.state.self_refine_results = results
         self.state.self_refine_repair_count += len(repairs)
-        return {"total": len(probes), "passed": passed, "failed": len(failures), "pass_rate": round(passed / len(probes), 2), "repairs": repairs, "failed_details": [{"q": r.get("question", "")[:60], "reason": r.get("reason", "")} for r in failures[:5]]}
+        return {"total": len(probes), "passed": passed, "failed": len(failures), "pass_rate": round(passed / len(probes), 2), "repairs": repairs, "diagnoses": diagnoses, "strategy_actions": strategy_actions, "failed_details": [{"q": r.get("question", "")[:60], "reason": r.get("reason", "")} for r in failures[:5]]}
 
 
 # ==============================================================================

{liquid_loop-0.6.2 → liquid_loop-0.7.0}/liquid_loop.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liquid-loop
-Version: 0.6.2
+Version: 0.7.0
 Summary: Self-Organizing Cognitive Memory for AI Agents — Liquid Loop theory implementation
 Author: fishbook0001
 Maintainer: fishbook0001
@@ -147,6 +147,26 @@ liquid-loop snapshot
 
 ---
 
+## MESH 集成（多智能体共识）
+
+液环从 v0.7.0 起内置官方 MESH 集成 `liquid_loop.mesh`，把"多智能体共识协议"落地为可复用代码，作为 agent-mesh 节点的标准接入层。
+
+```python
+from liquid_loop.mesh import validate_evidence, compute_cci, cognitive_health, fetch_state
+
+# agent 写入前契约自检（零向量：content 必须精确字符串，禁 embedding）
+ok, errs = validate_evidence({"agent_id": "vera", "content": "用户偏好简洁输出"})
+
+# 从 8790 拉取记忆状态，算主体间性共识指数 CCI
+items = fetch_state("http://127.0.0.1:8790")
+health = cognitive_health(items)
+print(health["CCI"], health["consensus_crystals"])
+```
+
+零向量哲学：一致性判定走**结构化精确相等 + 审计链哈希**，绝不引入任何 embedding / 相似度。规范详见 `mesh/liquid_loop_mesh_v2_spec.md`。
+
+---
+
 ## 架构对比
 
 ```
@@ -194,6 +214,7 @@ liquid-loop/
 │   ├── workspace.py     # 核心数据模型 + AuditChain + auto_classify + decay
 │   ├── storage.py       # JSON 持久化 + 审计链写入
 │   ├── entropy.py       # 四维熵值计算
+│   ├── mesh/            # MESH v2 多智能体共识协议集成（validate_evidence / compute_cci / ...）
 │   └── cli.py           # Click CLI (11 命令)
 ├── examples/
 │   └── quickstart.py
@@ -220,7 +241,7 @@ pytest -v
 ## 路线图
 
 - [ ] 语义一致性结晶（嵌入相似度替代精确匹配）
-- [ ] 多 Agent 液环耦合
+- [x] 多 Agent 液环耦合（`liquid_loop.mesh` v2 共识协议，2026-07-15 落地）
 - [ ] LX 扩展：世界模型预测纳入液环
 - [ ] LoCoMo / LongMemEval 基准对比
 - [ ] 边缘端部署优化（<50KB）

{liquid_loop-0.6.2 → liquid_loop-0.7.0}/liquid_loop.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ pyproject.toml
 liquid_loop/__init__.py
 liquid_loop/__main__.py
 liquid_loop/cli.py
+liquid_loop/cognitive_budget.py
 liquid_loop/entropy.py
 liquid_loop/storage.py
 liquid_loop/workspace.py
@@ -13,6 +14,12 @@ liquid_loop.egg-info/dependency_links.txt
 liquid_loop.egg-info/entry_points.txt
 liquid_loop.egg-info/requires.txt
 liquid_loop.egg-info/top_level.txt
+liquid_loop/mesh/__init__.py
+liquid_loop/mesh/v2.py
+tests/test_consensus_expansion.py
 tests/test_entropy.py
+tests/test_nucleate_dual_track.py
+tests/test_peek_seal.py
+tests/test_seal_persistence.py
 tests/test_self_evolve.py
 tests/test_workspace.py

{liquid_loop-0.6.2 → liquid_loop-0.7.0}/pyproject.toml

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

liquid_loop-0.7.0/tests/test_consensus_expansion.py

@@ -0,0 +1,45 @@
+"""共识结晶 contributors 随新一致方动态扩展（三方+ CCI 计量）。"""
+from liquid_loop import WorkspaceState
+from liquid_loop.workspace import Anchor, Evidence, Memory
+
+
+def _add(st, name, content, agent_id):
+    a = next((x for x in st.anchors if x.name == name), None)
+    if a is None:
+        a = st.add_anchor(name)
+    e = Evidence(content=content, anchor_id=a.id, agent_id=agent_id)
+    st.add_evidence(a, content, agent_id=agent_id)
+    return a
+
+
+def test_consensus_expands_with_third_agent():
+    st = WorkspaceState()
+    # qwenpaw + vera 先达成共识
+    _add(st, "液环", "液环是零向量记忆", "qwenpaw")
+    _add(st, "液环", "液环是零向量记忆", "qwenpaw")  # qwenpaw >=2 -> private
+    _add(st, "液环", "液环是零向量记忆", "vera")      # +vera -> consensus[qwenpaw,vera]
+    cons = next(m for m in st.memories if m.scope == "consensus")
+    assert cons.contributors == ["qwenpaw", "vera"], cons.contributors
+    # marvis 也写同内容 -> 应并入三方共识
+    _add(st, "液环", "液环是零向量记忆", "marvis")
+    cons = next(m for m in st.memories if m.scope == "consensus")
+    assert cons.contributors == ["marvis", "qwenpaw", "vera"], cons.contributors
+
+
+def test_consensus_no_duplicate_on_repeat():
+    st = WorkspaceState()
+    _add(st, "fact", "X", "a")
+    _add(st, "fact", "X", "a")          # private[a]
+    _add(st, "fact", "X", "b")          # consensus[a,b]
+    _add(st, "fact", "X", "b")          # b 重复，不应扩
+    cons = next(m for m in st.memories if m.scope == "consensus")
+    assert cons.contributors == ["a", "b"], cons.contributors
+
+
+def test_private_untouched_by_consensus_expansion():
+    st = WorkspaceState()
+    _add(st, "fact", "Y", "qwenpaw")
+    _add(st, "fact", "Y", "qwenpaw")    # private[qwenpaw]
+    _add(st, "fact", "Y", "vera")       # consensus
+    priv = [m for m in st.memories if m.scope == "private"]
+    assert priv and priv[0].contributors == ["qwenpaw"], priv

liquid_loop-0.7.0/tests/test_nucleate_dual_track.py

@@ -0,0 +1,115 @@
+"""双轨成核 + 防污染回归测试（多智能体共用机制）。
+
+锁住行为：
+  - private 轨：同一 agent_id 内 >= 2 一致证据 -> scope=private
+  - consensus 轨：同一 content 跨 >= 2 distinct agent_id -> scope=consensus
+  - 防污染：不同 agent 不互相成私有晶；跨锚点同 content 不合并；复合键 (anchor,content,scope)
+"""
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from liquid_loop.workspace import WorkspaceState
+
+
+def _add(st, name, content, agent_id=""):
+    a = next((x for x in st.anchors if x.name == name), None)
+    if a is None:
+        a = st.add_anchor(name)
+    return st.add_evidence(a, content, agent_id=agent_id)
+
+
+def test_private_nucleation_same_agent():
+    st = WorkspaceState()
+    _add(st, "topic", "液环是零向量记忆", agent_id="qwenpaw")
+    _add(st, "topic", "液环是零向量记忆", agent_id="qwenpaw")
+    priv = [m for m in st.memories if m.scope == "private"]
+    cons = [m for m in st.memories if m.scope == "consensus"]
+    assert len(priv) == 1
+    assert priv[0].contributors == ["qwenpaw"]
+    assert len(cons) == 0
+
+
+def test_private_isolation_diff_agents():
+    st = WorkspaceState()
+    _add(st, "topic", "同一结论", agent_id="qwenpaw")
+    _add(st, "topic", "同一结论", agent_id="vera")
+    # 各 agent 内仅 1 条 -> 不 privately 成核
+    assert all(m.scope != "private" for m in st.memories)
+    # 但跨 2 distinct owner -> consensus 成核
+    cons = [m for m in st.memories if m.scope == "consensus"]
+    assert len(cons) == 1
+    assert set(cons[0].contributors) == {"qwenpaw", "vera"}
+
+
+def test_consensus_requires_distinct_owner():
+    st = WorkspaceState()
+    _add(st, "topic", "共识结论", agent_id="qwenpaw")
+    _add(st, "topic", "共识结论", agent_id="qwenpaw")  # 同 owner 重复
+    # 同 owner 2 条 -> private，但不该有 consensus（只有 1 个 owner）
+    cons = [m for m in st.memories if m.scope == "consensus"]
+    assert len(cons) == 0
+    priv = [m for m in st.memories if m.scope == "private"]
+    assert len(priv) == 1
+
+
+def test_cross_anchor_no_pollution():
+    st = WorkspaceState()
+    _add(st, "A", "X", agent_id="qwenpaw")
+    _add(st, "A", "X", agent_id="qwenpaw")
+    _add(st, "B", "X", agent_id="qwenpaw")
+    _add(st, "B", "X", agent_id="qwenpaw")
+    # 两个锚点各成 1 个 private 晶，不合并
+    priv = [m for m in st.memories if m.scope == "private"]
+    assert len(priv) == 2
+
+
+def test_legacy_compat_no_agent_id():
+    st = WorkspaceState()
+    _add(st, "topic", "legacy 内容", agent_id="")
+    _add(st, "topic", "legacy 内容", agent_id="")
+    priv = [m for m in st.memories if m.scope == "private"]
+    assert len(priv) == 1
+    assert priv[0].contributors == ["legacy"]
+
+
+def test_dual_track_coexist():
+    st = WorkspaceState()
+    # 私有：qwenpaw 内 2 条独有结论
+    _add(st, "T", "qwenpaw 私有结论", agent_id="qwenpaw")
+    _add(st, "T", "qwenpaw 私有结论", agent_id="qwenpaw")
+    # 共识：qwenpaw + vera 各 1 条共享结论
+    _add(st, "T", "共享结论", agent_id="qwenpaw")
+    _add(st, "T", "共享结论", agent_id="vera")
+    priv = [m for m in st.memories if m.scope == "private"]
+    cons = [m for m in st.memories if m.scope == "consensus"]
+    assert len(priv) == 1 and priv[0].contributors == ["qwenpaw"]
+    assert len(cons) == 1 and set(cons[0].contributors) == {"qwenpaw", "vera"}
+
+
+def test_no_pollution_between_agents_private():
+    st = WorkspaceState()
+    _add(st, "T", "结论A", agent_id="qwenpaw")
+    _add(st, "T", "结论A", agent_id="qwenpaw")
+    _add(st, "T", "结论A", agent_id="vera")  # vera 只有 1 条 -> 不成私有
+    priv = [m for m in st.memories if m.scope == "private"]
+    cons = [m for m in st.memories if m.scope == "consensus"]
+    # qwenpaw 私有 1 晶；vera 仅 1 条不足私有；二者合计 2 distinct owner -> consensus 1 晶
+    assert len(priv) == 1 and priv[0].contributors == ["qwenpaw"]
+    assert len(cons) == 1 and set(cons[0].contributors) == {"qwenpaw", "vera"}
+
+
+def test_storage_roundtrip_agent_id_scope(tmp_path):
+    """持久化往返：agent_id / scope / contributors 必须无损保存加载。"""
+    from liquid_loop import storage
+    st = WorkspaceState()
+    _add(st, "T", "X", agent_id="qwenpaw")
+    _add(st, "T", "X", agent_id="qwenpaw")
+    storage.save(st, tmp_path)
+    st2 = storage.load(tmp_path)
+    assert len(st2.memories) == 1
+    m = st2.memories[0]
+    assert m.scope == "private"
+    assert m.contributors == ["qwenpaw"]
+    assert st2.evidences[0].agent_id == "qwenpaw"

liquid_loop-0.7.0/tests/test_peek_seal.py

@@ -0,0 +1,115 @@
+"""PEEK 预算稳态 + SEAL 双优化 落地测试（液环仓库内）"""
+import pytest
+from liquid_loop.workspace import WorkspaceState, SelfRefineEngine
+from liquid_loop.cognitive_budget import CognitiveBudgetStabilizer
+
+
+# ───────────── PEEK 落地：认知预算稳态器 ─────────────
+
+def test_budget_stabilizer_evicts_low_value(monkeypatch):
+    monkeypatch.setenv("LIQUID_EVIDENCE_BUDGET", "3")
+    st = WorkspaceState()
+    a_hot = st.add_anchor("hot")
+    a_hot.value_score = 0.9
+    a_hot.access_count = 20
+    a_hot.liquidity = "hot"
+    a_cold = st.add_anchor("cold")
+    a_cold.value_score = 0.2
+    a_cold.access_count = 0
+    a_cold.liquidity = "frozen"
+    for i in range(3):
+        st.add_evidence("hot", f"重要证据{i} 液环锚点")
+    for i in range(3):
+        st.add_evidence("cold", f"陈旧证据{i} 旧记忆")
+    # 6 条证据，预算 3 → 应冷归档 3 条最低价值（cold 锚点）
+    arch = [e for e in st.evidences if e.archived]
+    assert len(arch) == 3
+    assert all(e.anchor_id == a_cold.id for e in arch)
+
+
+def test_budget_no_limit_when_unset(monkeypatch):
+    monkeypatch.delenv("LIQUID_EVIDENCE_BUDGET", raising=False)
+    st = WorkspaceState()
+    a = st.add_anchor("x")
+    for i in range(10):
+        st.add_evidence("x", f"证据{i}")
+    arch = [e for e in st.evidences if e.archived]
+    assert arch == []  # 无预算不驱逐
+
+
+def test_budget_stabilizer_direct_call(monkeypatch):
+    monkeypatch.setenv("LIQUID_EVIDENCE_BUDGET", "2")
+    st = WorkspaceState()
+    a = st.add_anchor("x")
+    a.value_score = 0.5
+    for i in range(5):
+        st.add_evidence("x", f"证据{i}")
+    res = CognitiveBudgetStabilizer(st).stabilize()
+    assert res["evicted"] == 3
+    assert res["total"] == 5
+    assert res["budget"] == 2
+
+
+# ───────────── SEAL 落地：失败诊断双优化 ─────────────
+
+def test_seal_diagnose_retrieval():
+    st = WorkspaceState()
+    a = st.add_anchor("液环", description="液环记忆理论")
+    st.add_evidence("液环", "液环锚点结晶")
+    eng = SelfRefineEngine(st)
+    failure = {"source": a.id, "reason": "检索失败，无相关记忆", "question": "?", "gold": "?"}
+    diag = eng.diagnose(failure)
+    assert diag["fail_type"] == "retrieval"
+    assert diag["target_anchor"] == a.id
+    assert diag["tune"] == "boost_stability"
+
+
+def test_seal_diagnose_reason_downweights():
+    st = WorkspaceState()
+    a = st.add_anchor("稳态")
+    eng = SelfRefineEngine(st)
+    failure = {"source": a.id, "reason": "关键词不匹配，gold=稳态"}
+    diag = eng.diagnose(failure)
+    assert diag["fail_type"] == "reason"
+    eng.apply_strategy(diag)
+    # v0.6.4：改 seal_adjust 层，不直接动 stability
+    assert a.seal_adjust == -0.1
+    st.add_evidence(a, "补充证据")  # 触发 _recalc 合成
+    assert a.stability == round(min(1.0, max(0.1, a.base_stability + a.seal_adjust)), 3)
+    assert a.stability < a.base_stability  # 负增量生效，自洽性降权
+
+
+def test_seal_apply_strategy_boost():
+    st = WorkspaceState()
+    a = st.add_anchor("液环")
+    eng = SelfRefineEngine(st)
+    diag = {"fail_type": "retrieval", "target_anchor": a.id, "tune": "boost_stability"}
+    acts = eng.apply_strategy(diag)
+    assert acts[0]["op"] == "boost_stability"
+    assert a.seal_adjust == 0.1
+    st.add_evidence(a, "补充证据")  # 触发 _recalc 合成
+    assert a.stability == round(min(1.0, max(0.1, a.base_stability + a.seal_adjust)), 3)
+    assert a.stability >= a.base_stability  # 正增量生效
+
+
+def test_seal_run_integration_dual_optimize(monkeypatch):
+    st = WorkspaceState()
+    a = st.add_anchor("液环", description="液环")
+    st.add_evidence("液环", "液环锚点")
+    eng = SelfRefineEngine(st)
+
+    def fake_verify(p):
+        if p.get("type") == "fact":
+            # 模拟"检索失败但记忆应存在"：source 指向锚点，gold 为新内容（需补证据）
+            return {"passed": False, "reason": "检索失败，无相关记忆",
+                    "question": p.get("question", ""), "gold": "全新记忆内容需补回",
+                    "source": a.id}
+        return {"passed": True, "reason": "ok"}
+
+    monkeypatch.setattr(eng, "verify", fake_verify)
+    out = eng.run()
+    assert out["failed"] >= 1
+    assert len(out["strategy_actions"]) >= 1
+    assert out["strategy_actions"][0]["op"] == "boost_stability"
+    # 双优化：memory 侧（repairs）与 strategy 侧（strategy_actions）都应存在
+    assert len(out["repairs"]) >= 1

liquid_loop-0.7.0/tests/test_seal_persistence.py

@@ -0,0 +1,63 @@
+"""E8/v0.6.4 — 验证 SEAL 双优化不再被 _recalc_anchor 覆盖（解 v0.6.3 假落地）。
+
+修复核心：stability = base(证据权重均值) + seal_adjust(SEAL 自评层增量)；
+apply_strategy 改 seal_adjust 而非直接动 stability，_recalc 合成时保留。
+
+本测试直接构造诊断（绕过 SelfRefineEngine.verify 的脆弱归因），专注验证
+apply_strategy → seal_adjust → _recalc 合成的持久性。
+"""
+from liquid_loop.workspace import WorkspaceState, SelfRefineEngine
+
+
+def _boost(a, eng):
+    diag = {"fail_type": "retrieval", "target_anchor": a.id,
+            "root_cause": "召回失败", "tune": "boost_stability"}
+    return eng.apply_strategy(diag)
+
+
+def _down(a, eng):
+    diag = {"fail_type": "reason", "target_anchor": a.id,
+            "root_cause": "推理失败", "tune": "downweight_noise"}
+    return eng.apply_strategy(diag)
+
+
+def test_seal_boost_persists_through_recalc():
+    """SEAL boost 后即便再 add_evidence 触发 _recalc，stability 仍含 seal_adjust。"""
+    st = WorkspaceState()
+    eng = SelfRefineEngine(st)
+    a = st.add_anchor("probe_seal")
+    st.add_evidence(a, "初始证据")
+    _boost(a, eng)
+    assert a.seal_adjust == 0.1
+    st.add_evidence(a, "再来一条证据")  # 触发 _recalc_anchor
+    assert a.seal_adjust == 0.1  # 增量持久
+    expected = round(min(1.0, max(0.1, a.base_stability + a.seal_adjust)), 3)
+    assert a.stability == expected
+    assert a.stability >= a.base_stability  # 正增量应 >= base
+
+
+def test_seal_downweight():
+    st = WorkspaceState()
+    eng = SelfRefineEngine(st)
+    a = st.add_anchor("noise")
+    st.add_evidence(a, "x")
+    acts = _down(a, eng)
+    assert a.seal_adjust == -0.1
+    assert acts[0]["op"] == "downweight_noise"
+
+
+def test_seal_adjust_applied_in_recalc():
+    """开 SEAL 的锚点 stability = base + seal_adjust；对照无 SEAL 锚点 adjust=0。"""
+    st = WorkspaceState()
+    eng = SelfRefineEngine(st)
+    a = st.add_anchor("x")
+    st.add_evidence(a, "e1")
+    _boost(a, eng)
+    st.add_evidence(a, "e2")  # 触发 _recalc
+    # 开 SEAL：stability 合成 seal_adjust（含 clamp，与期望值精确匹配）
+    assert a.stability == round(min(1.0, max(0.1, a.base_stability + a.seal_adjust)), 3)
+    # 对照：无 SEAL 的锚点 seal_adjust=0，stability=base
+    b = st.add_anchor("y")
+    st.add_evidence(b, "f1")
+    assert b.seal_adjust == 0.0
+    assert abs(b.stability - b.base_stability) < 1e-6