liquid-loop 1.8.4__tar.gz → 2.0.0__tar.gz

{liquid_loop-1.8.4 → liquid_loop-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liquid-loop
-Version: 1.8.4
+Version: 2.0.0
 Summary: Self-Organizing Cognitive Memory for AI Agents — Liquid Loop theory implementation
 Author: fishbook0001
 Maintainer: fishbook0001
@@ -43,6 +43,8 @@ Dynamic: license-file
 
 > **Self-Organizing Cognitive Memory for AI Agents** — Zero LLM dependency, pure Python implementation of the Liquid Loop theory.
 
+> **当前包版本：`2.0.0`**（2026-08-24 统一版号里程碑，详见 [CHANGELOG.md](CHANGELOG.md)。数据 schema `0.4.0` 与 workspace state `0.5.1` 为记忆层数据格式版本，独立于包发布版本）。
+
 [![PyPI](https://img.shields.io/pypi/v/liquid-loop.svg)](https://pypi.org/project/liquid-loop/)
 [![Python](https://img.shields.io/pypi/pyversions/liquid-loop.svg)](https://pypi.org/project/liquid-loop/)
 [![License](https://img.shields.io/pypi/l/liquid-loop.svg)](https://opensource.org/licenses/MIT)
@@ -120,9 +122,9 @@ RED    (entropy ≥ 0.6)  — 需清理
 
 ---
 
-## v0.8 反证轨 + 时间动力学（液态循环核心）
+## 核心机制：反证轨 + 时间动力学（液态循环核心）
 
-液环 v0.8 从"静态结晶"升级为**自调节记忆动力学**：记忆不是对象，而是过程。
+液环从"静态结晶"升级为**自调节记忆动力学**：记忆不是对象，而是过程。以下机制均随 **v2.0.0** 发布（历史演进中曾标 v0.8 / v0.9）。
 
 ### 反证轨（Contradiction Track）
 
@@ -364,11 +366,12 @@ pytest -v
 ## 路线图
 
 - [ ] 多 Agent 液环耦合（`liquid_loop.mesh` 已移除，见 commit ac7260e）
-- [x] **[v0.8] 反证轨（Evidence Graph）**：Evidence 分 support / contradiction，一致增稳、冲突降稳，驱动 memory stability score（不再"一致即真"）
-- [x] **[v0.8] 显式时间动力学**：`M(t+1) = M(t) + reinforcement − decay − contradiction_penalty`，让记忆成为"过程"而非"对象"（真正的液态循环）
-- [x] **[v0.8] 三实验全 PASS**：E2 错误记忆恢复 → E3 多 agent 冲突 → E1 长期漂移（见上节）
-- [x] **[v0.9] 冲突检测 O(g²)→O(d²)**：`_detect_conflicts` 按 content 去重后只对 distinct 内容求两两重叠（d≤g），overlap_cache 复用；语义更纯净（度量不同论点分歧），大规模高频写入性能提升（非正确性变更）
-- [x] **[v0.9] 液态算法正式落地**：时间动力学 / 反证轨 / 双轨成核在 v0.8 已实现并经 E1/E2/E3 三实验背书，v0.9 作为稳定版正式发布（README 顶部 Hero Banner 已上线）
+- [x] **[已发布] 反证轨（Evidence Graph）**：Evidence 分 support / contradiction，一致增稳、冲突降稳，驱动 memory stability score（不再"一致即真"）
+- [x] **[已发布] 显式时间动力学**：`M(t+1) = M(t) + reinforcement − decay − contradiction_penalty`，让记忆成为"过程"而非"对象"（真正的液态循环）
+- [x] **[已发布] 三实验全 PASS**：E2 错误记忆恢复 → E3 多 agent 冲突 → E1 长期漂移（见上节）
+- [x] **[已发布] 冲突检测 O(g²)→O(d²)**：`_detect_conflicts` 按 content 去重后只对 distinct 内容求两两重叠（d≤g），overlap_cache 复用；语义更纯净（度量不同论点分歧），大规模高频写入性能提升（非正确性变更）
+- [x] **[已发布] 液态算法正式落地**：时间动力学 / 反证轨 / 双轨成核经 E1/E2/E3 三实验背书，作为稳定机制随 **v2.0.0** 发布
+- [x] **[v2.0.0] 统一版号里程碑**：`pyproject.toml` / `__init__.__version__` / 投喂客户端 `LIQUIDLOOP_CLIENT_VERSION` 全部对齐 `2.0.0`；数据 schema `0.4.0` 与 workspace state `0.5.1` 保持独立（记忆层格式版本，禁区不动）
 - [ ] LoCoMo / LongMemEval 基准对比
 - [ ] 边缘端部署优化（<50KB）
 

{liquid_loop-1.8.4 → liquid_loop-2.0.0}/README.md

@@ -4,6 +4,8 @@
 
 > **Self-Organizing Cognitive Memory for AI Agents** — Zero LLM dependency, pure Python implementation of the Liquid Loop theory.
 
+> **当前包版本：`2.0.0`**（2026-08-24 统一版号里程碑，详见 [CHANGELOG.md](CHANGELOG.md)。数据 schema `0.4.0` 与 workspace state `0.5.1` 为记忆层数据格式版本，独立于包发布版本）。
+
 [![PyPI](https://img.shields.io/pypi/v/liquid-loop.svg)](https://pypi.org/project/liquid-loop/)
 [![Python](https://img.shields.io/pypi/pyversions/liquid-loop.svg)](https://pypi.org/project/liquid-loop/)
 [![License](https://img.shields.io/pypi/l/liquid-loop.svg)](https://opensource.org/licenses/MIT)
@@ -81,9 +83,9 @@ RED    (entropy ≥ 0.6)  — 需清理
 
 ---
 
-## v0.8 反证轨 + 时间动力学（液态循环核心）
+## 核心机制：反证轨 + 时间动力学（液态循环核心）
 
-液环 v0.8 从"静态结晶"升级为**自调节记忆动力学**：记忆不是对象，而是过程。
+液环从"静态结晶"升级为**自调节记忆动力学**：记忆不是对象，而是过程。以下机制均随 **v2.0.0** 发布（历史演进中曾标 v0.8 / v0.9）。
 
 ### 反证轨（Contradiction Track）
 
@@ -325,11 +327,12 @@ pytest -v
 ## 路线图
 
 - [ ] 多 Agent 液环耦合（`liquid_loop.mesh` 已移除，见 commit ac7260e）
-- [x] **[v0.8] 反证轨（Evidence Graph）**：Evidence 分 support / contradiction，一致增稳、冲突降稳，驱动 memory stability score（不再"一致即真"）
-- [x] **[v0.8] 显式时间动力学**：`M(t+1) = M(t) + reinforcement − decay − contradiction_penalty`，让记忆成为"过程"而非"对象"（真正的液态循环）
-- [x] **[v0.8] 三实验全 PASS**：E2 错误记忆恢复 → E3 多 agent 冲突 → E1 长期漂移（见上节）
-- [x] **[v0.9] 冲突检测 O(g²)→O(d²)**：`_detect_conflicts` 按 content 去重后只对 distinct 内容求两两重叠（d≤g），overlap_cache 复用；语义更纯净（度量不同论点分歧），大规模高频写入性能提升（非正确性变更）
-- [x] **[v0.9] 液态算法正式落地**：时间动力学 / 反证轨 / 双轨成核在 v0.8 已实现并经 E1/E2/E3 三实验背书，v0.9 作为稳定版正式发布（README 顶部 Hero Banner 已上线）
+- [x] **[已发布] 反证轨（Evidence Graph）**：Evidence 分 support / contradiction，一致增稳、冲突降稳，驱动 memory stability score（不再"一致即真"）
+- [x] **[已发布] 显式时间动力学**：`M(t+1) = M(t) + reinforcement − decay − contradiction_penalty`，让记忆成为"过程"而非"对象"（真正的液态循环）
+- [x] **[已发布] 三实验全 PASS**：E2 错误记忆恢复 → E3 多 agent 冲突 → E1 长期漂移（见上节）
+- [x] **[已发布] 冲突检测 O(g²)→O(d²)**：`_detect_conflicts` 按 content 去重后只对 distinct 内容求两两重叠（d≤g），overlap_cache 复用；语义更纯净（度量不同论点分歧），大规模高频写入性能提升（非正确性变更）
+- [x] **[已发布] 液态算法正式落地**：时间动力学 / 反证轨 / 双轨成核经 E1/E2/E3 三实验背书，作为稳定机制随 **v2.0.0** 发布
+- [x] **[v2.0.0] 统一版号里程碑**：`pyproject.toml` / `__init__.__version__` / 投喂客户端 `LIQUIDLOOP_CLIENT_VERSION` 全部对齐 `2.0.0`；数据 schema `0.4.0` 与 workspace state `0.5.1` 保持独立（记忆层格式版本，禁区不动）
 - [ ] LoCoMo / LongMemEval 基准对比
 - [ ] 边缘端部署优化（<50KB）
 

{liquid_loop-1.8.4 → liquid_loop-2.0.0}/liquid_loop/__init__.py

@@ -1,5 +1,5 @@
-"""Liquid Loop — Workspace Cognitive Runtime v1.8.4 (禁向量·活态液态神经网络：成核门槛/反证轨/老化回收/原理优先成核/因果演化/软取代supersede+治理查询state_at/impact/duplicates+程序性记忆层procedural_memory)"""
-__version__ = "1.8.4"
+"""Liquid Loop — Workspace Cognitive Runtime v2.0.0 (禁向量·活态液态神经网络：成核门槛/反证轨/老化回收/原理优先成核/因果演化/软取代supersede+治理查询state_at/impact/duplicates+程序性记忆层procedural_memory+PerceptionGate因果共生门控)"""
+__version__ = "2.0.0"
 
 from .workspace import (
     WorkspaceState, Anchor, Evidence, Memory, Conflict,
@@ -15,3 +15,10 @@ from .recall_filter import recall_content_filter, content_aware_filter, cosine_d
 from .procedural_memory import (
     ProceduralMemory, ProceduralRegistry, procmem_recall, procmem_admit,
 )
+# 蒸馏落地的公共原语（零侵入，供 cli / server / agent loop 接入）
+from .guard import should_escalate, confirm_gate, CapabilityMenu
+from .session import SessionState, mark_abort, recover, save_session, load_session
+from .recall_filter import adaptive_recall
+from .rar import RARIndex, build_or_cache  # 公共检索 API（原 workspace 局部 import）
+# TTL 回收入口：evict_expired 是 WorkspaceState 实例方法（见 workspace.py:254），
+# 已随 WorkspaceState 一并导出；cli.prune 经 state.evict_expired() 调用。

liquid_loop-2.0.0/liquid_loop/audit.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import os
+import hashlib
+
+from .textutil import (
+    now, uid, _derive_lifecycle_thresholds, _get_version,
+    _tokenize, _keyword_overlap, _judge_answer,
+    _dissolve_votes_path, _load_dissolve_votes, _save_dissolve_votes,
+)
+
+class AuditChain:
+    """轻量级审计链：每次变更追加 SHA256 链式哈希"""
+
+    def __init__(self, audit_path: str):
+        self._path = audit_path
+        self._chain: list[str] = []
+        self._load()
+
+    def _load(self):
+        if os.path.exists(self._path):
+            with open(self._path, "r") as f:
+                for line in f:
+                    line = line.strip()
+                    if line:
+                        parts = line.split("|")
+                        if len(parts) >= 2:
+                            self._chain.append(parts[1])
+
+    def _maybe_rotate(self) -> None:
+        """08-18 工程化修复：按大小轮转，防 audit.log 无限增长（轮转为断链点，工程取舍）。"""
+        try:
+            max_bytes = int(os.environ.get("LL_AUDIT_MAX_BYTES", "8388608"))  # 默认 8MB
+            if os.path.exists(self._path) and os.path.getsize(self._path) > max_bytes:
+                os.replace(self._path, self._path + ".1")
+                self._chain = []
+        except (OSError, ValueError):
+            pass  # 轮转失败不影响写
+
+    def append(self, event_type: str, data: str) -> str:
+        self._maybe_rotate()
+        prev = self._chain[-1] if self._chain else "genesis"
+        chain_hash = hashlib.sha256(f"{event_type}:{data}:{prev}".encode()).hexdigest()[:16]
+        self._chain.append(chain_hash)
+        ts = now()
+        with open(self._path, "a") as f:
+            f.write(f"{ts}|{chain_hash}|{event_type}|{data}|{prev}\n")
+        return chain_hash
+
+    @property
+    def root(self) -> str:
+        return self._chain[-1] if self._chain else "genesis"
+
+    def verify(self, entry: str) -> bool:
+        """验证某条完整日志行是否匹配链中记录"""
+        if "|" not in entry:
+            return False
+        parts = entry.strip().split("|")
+        if len(parts) < 5:
+            return False
+        _, stored_hash, event_type, data, prev = parts[:5]
+        expected = hashlib.sha256(f"{event_type}:{data}:{prev}".encode()).hexdigest()[:16]
+        return expected == stored_hash

{liquid_loop-1.8.4 → liquid_loop-2.0.0}/liquid_loop/cli.py

@@ -526,6 +526,18 @@ def version():
     click.echo(f"liquid-loop {__version__}")
 
 
+@main.command()
+def prune():
+    """回收过期临时记忆（蒸馏 #202·TTL 生命周期）"""
+    s = _load()
+    evicted = s.evict_expired()
+    if evicted:
+        _save(s)
+        click.echo(f"✓ 回收 {evicted} 条过期临时记忆")
+    else:
+        click.echo("无过期临时记忆可回收。")
+
+
 if __name__ == "__main__":
     main()
 

liquid_loop-2.0.0/liquid_loop/cpe.py

@@ -0,0 +1,247 @@
+from __future__ import annotations
+
+from .textutil import (
+    now, uid, _derive_lifecycle_thresholds, _get_version,
+    _tokenize, _keyword_overlap, _judge_answer,
+    _dissolve_votes_path, _load_dissolve_votes, _save_dissolve_votes,
+)
+from .entropy import calculate
+
+class CPERegularizer:
+    """CPE 正则化引擎：在证据添加前做能力保留裁决"""
+
+    def __init__(self, state: WorkspaceState):
+        self.state = state
+
+    def evaluate_new_evidence(self, anchor: Anchor, new_content: str) -> Dict[str, Any]:
+        """评估新证据对既有锚点体系的能力侵蚀风险（CPE §3 Regularized Self-Evolution Objective）
+
+        返回:
+            action: "PASS" | "BLOCK" | "FLAG"
+            score: 0.0(安全) ~ 1.0(高风险)
+            reasons: 原因列表
+        """
+        if not anchor.evidence_ids:
+            return {"action": "PASS", "score": 0.0, "reasons": ["锚点无现有证据，无覆盖风险"]}
+
+        evs = [e for e in self.state.evidences if e.anchor_id == anchor.id]
+        if not evs:
+            return {"action": "PASS", "score": 0.0, "reasons": ["无对应证据，安全"]}
+
+        # ── 1. 回顾性检查（Retrospective Protection）：新证据是否与旧证据方向一致 ──
+        old_contents = [e.content for e in evs if e.content]
+        overlaps = [_keyword_overlap(new_content, old) for old in old_contents]
+        max_overlap = max(overlaps) if overlaps else 0.0
+        avg_overlap = sum(overlaps) / len(overlaps) if overlaps else 0.0
+
+        # ── 2. 漂移检查（Drift Constraint）：新证据是否偏离锚点定义 ──
+        drift_score = 1.0 - _keyword_overlap(new_content, anchor.description or anchor.name)
+
+        # ── 4. 重复检测：新证据与已有证据相似度 > 0.7 → 近似重复，建议合并 ──
+        duplicate_of = None
+        for old_content in old_contents:
+            if _keyword_overlap(new_content, old_content) > 0.7:
+                duplicate_of = old_content[:60]
+                break
+
+        if duplicate_of:
+            return {
+                "action": "MERGE",
+                "score": 0.0,
+                "reasons": [f"与已有证据近似重复: '{duplicate_of}...'"],
+                "details": {
+                    "max_overlap": round(max_overlap, 3),
+                    "avg_overlap": round(avg_overlap, 3),
+                    "drift_score": round(drift_score, 3),
+                    "existing_evidence_count": len(evs),
+                    "duplicate_of": duplicate_of,
+                }
+            }
+
+        # ── 综合风险评分 ──
+        risk_score = 0.0
+        reasons = []
+
+        # 低重叠 → 高回顾性衰退风险
+        if max_overlap < 0.1:
+            risk_score += 0.5
+            reasons.append(f"回顾性风险: 与现有证据最大重叠{max_overlap:.2f}，可能侵蚀")
+        elif max_overlap < 0.3:
+            risk_score += 0.25
+            reasons.append(f"回顾性风险: 中等重叠{max_overlap:.2f}，建议验证")
+
+        if drift_score > 0.7:
+            risk_score += 0.3
+            reasons.append(f"漂移风险: 与锚点方向偏离概率{drift_score:.2f}")
+        elif drift_score > 0.4:
+            risk_score += 0.1
+            reasons.append(f"漂移风险: 轻微偏离{drift_score:.2f}")
+
+        # 证据量越多 → 保护应该越强（CPE的"旧能力权重递增"思想）
+        protection_weight = min(len(evs) / 10, 1.0)
+        risk_score = risk_score * (1.0 + protection_weight)  # 证据越多风险越敏感
+        risk_score = min(risk_score, 1.0)
+
+        # ── 判定 ──
+        if risk_score > 0.7:
+            action = "BLOCK"
+        elif risk_score > 0.4:
+            action = "FLAG"
+        else:
+            action = "PASS"
+
+        return {
+            "action": action,
+            "score": round(risk_score, 3),
+            "reasons": reasons,
+            "details": {
+                "max_overlap": round(max_overlap, 3),
+                "avg_overlap": round(avg_overlap, 3),
+                "drift_score": round(drift_score, 3),
+                "protection_weight": round(protection_weight, 3),
+                "existing_evidence_count": len(evs),
+            }
+        }
+
+    def scan_erosion(self) -> List[Dict[str, Any]]:
+        """扫描全工作区，检测能力侵蚀信号（CPE §2.2 Capability Erosion）
+
+        对标 CPE 三大表现：
+        - 回顾性衰退: value_score 连续两次衰减
+        - 策略漂移: 锚点近期的 stability 波动超过阈值
+        - 泛化崩塌: 同锚点证据之间的一致性持续下降
+        """
+        warnings = []
+        for a in self.state.anchors:
+            evs = sorted(
+                [e for e in self.state.evidences if e.anchor_id == a.id],
+                key=lambda x: x.timestamp
+            )
+            if len(evs) < 2:
+                continue
+
+            # 回顾性衰退：最新 vs 次新 value_score
+            a.decay_value(evidence_count=len(evs))
+            new_score = a.value_score
+            a.decay_value(evidence_count=len(evs) - 1)
+            old_score = a.value_score
+            if old_score > new_score and (old_score - new_score) > 0.1:
+                warnings.append({
+                    "type": "retrospective_decay",
+                    "anchor": a.name,
+                    "severity": "medium",
+                    "detail": f"value_score {old_score:.2f}→{new_score:.2f} (Δ={old_score - new_score:.2f})",
+                })
+
+            # 策略漂移：stability 突变
+            old_strength = a.recalc_strength(len(evs) - 1)
+            new_strength = a.recalc_strength(len(evs))
+            drift = abs(new_strength - old_strength)
+            if drift > 0.15:
+                warnings.append({
+                    "type": "behavioral_drift",
+                    "anchor": a.name,
+                    "severity": "medium",
+                    "detail": f"stability {old_strength:.2f}→{new_strength:.2f} (Δ={drift:.2f})",
+                })
+
+            # 泛化崩塌：证据间平均重叠度
+            content_pairs = []
+            for i in range(len(evs)):
+                for j in range(i + 1, len(evs)):
+                    if evs[i].content and evs[j].content:
+                        content_pairs.append(
+                            _keyword_overlap(evs[i].content, evs[j].content)
+                        )
+            if content_pairs:
+                avg_consistency = sum(content_pairs) / len(content_pairs)
+                if avg_consistency < 0.2 and len(evs) >= 3:
+                    warnings.append({
+                        "type": "generalization_erosion",
+                        "anchor": a.name,
+                        "severity": "high",
+                        "detail": f"证据间平均重叠度{avg_consistency:.2f} (<0.2, {len(evs)}条证据)",
+                    })
+
+        self.state.cpe_erosion_warnings = warnings
+        return warnings
+
+    def coalesce(self, anchor_name: str, threshold: float = 0.7) -> Dict[str, Any]:
+        """模糊去重合并：同锚点下相似度 > threshold 的证据自动合并
+
+        合并策略：
+          1. 遍历同锚点所有证据，两两计算 _keyword_overlap
+          2. 重叠度 > threshold → 保留较长的那条，标记较短的那条废弃
+          3. 返回合并统计
+
+        这是 CPE 泛化防线的主动修复动作——检测到 erosion 后调用。
+        """
+        anchor = next((a for a in self.state.anchors if a.name == anchor_name), None)
+        if not anchor:
+            return {"status": "error", "message": f"锚点 '{anchor_name}' 不存在"}
+
+        evs = [e for e in self.state.evidences if e.anchor_id == anchor.id]
+        if len(evs) < 2:
+            return {"status": "skip", "message": "证据不足2条，无需合并", "removed": 0}
+
+        # 按时间戳排序（旧→新）
+        evs_sorted = sorted(evs, key=lambda x: x.timestamp)
+        to_remove: set[str] = set()
+        merged = 0
+
+        for i in range(len(evs_sorted)):
+            if evs_sorted[i].id in to_remove:
+                continue
+            for j in range(i + 1, len(evs_sorted)):
+                if evs_sorted[j].id in to_remove:
+                    continue
+                overlap = _keyword_overlap(evs_sorted[i].content, evs_sorted[j].content)
+                if overlap > threshold:
+                    # 保留较长的，移除较短的
+                    if len(evs_sorted[i].content) >= len(evs_sorted[j].content):
+                        to_remove.add(evs_sorted[j].id)
+                    else:
+                        to_remove.add(evs_sorted[i].id)
+                        break
+                    merged += 1
+
+        self.state.evidences = [e for e in self.state.evidences if e.id not in to_remove]
+        self.state.cpe_regularization_count += 1
+
+        return {
+            "status": "ok",
+            "anchor": anchor_name,
+            "threshold": threshold,
+            "removed": len(to_remove),
+            "merged_pairs": merged,
+            "remaining": len(evs) - len(to_remove),
+        }
+
+    def regularize(self, anchor_name: str, content: str, force: bool = False) -> Dict[str, Any]:
+        """对单条证据执行 CPE 正则化检查（对外接口）
+
+        force=True 时跳过 BLOCK，仅做 FLAG 标记
+        """
+        s = self.state
+        anchor = next((a for a in s.anchors if a.name == anchor_name), None)
+        if not anchor:
+            return {"action": "PASS", "reason": "锚点不存在，不拦截"}
+
+        result = self.evaluate_new_evidence(anchor, content)
+        action = result["action"]
+        if force and action == "BLOCK":
+            action = "FLAG"
+
+        if action == "PASS":
+            # 已通过的证据ID会在外部添加后追加到 regularized_evidences
+            pass
+        elif action == "BLOCK":
+            s.blocked_evidences.append(f"{anchor_name}:{content[:40]}")
+            s.cpe_regularization_count += 1
+        elif action == "FLAG":
+            s.blocked_evidences.append(f"FLAG:{anchor_name}:{content[:40]}")
+            s.cpe_regularization_count += 1
+
+        # 保存扫描结果
+        self.scan_erosion()
+        return result

{liquid_loop-1.8.4 → liquid_loop-2.0.0}/liquid_loop/entropy.py

@@ -1,5 +1,10 @@
+from __future__ import annotations
+
 from datetime import datetime, timezone, timedelta
-from .workspace import WorkspaceState
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .workspace import WorkspaceState
 
 
 from contextlib import contextmanager

liquid_loop-2.0.0/liquid_loop/guard.py

@@ -0,0 +1,174 @@
+"""蒸馏 #197 + #198 守卫原语：能力菜单 + 升级刹车 + 确认闸。
+
+#197 MCP 安全边界：能力描述/标签只是提示语，不是沙箱；隔离靠部署层。
+      → CapabilityMenu：声明带名字/参数/风险等级的能力；高危调用前插确认闸。
+#198 Agent 停下问人：升级条件 = 低置信 ∨ 不可逆 ∨ 超预算；审批=方向盘。
+      → should_escalate(confidence, irreversible, over_budget) + confirm_gate。
+
+液环 cli 已有 --force 确认雏形（cpe_check）；本模块提供通用原语，供破坏性操作接入，
+让「动作前问人」成为可配置策略而非散落各处的硬编码。零依赖：仅标准库。
+"""
+from __future__ import annotations
+
+RISK_LEVELS = ("low", "medium", "high")
+
+
+def validate_content(content: str) -> str | None:
+    """内容质量 ValidationRule（08-18 审计补盲）：挡无意义/垃圾写入。
+
+    返回拒绝原因字符串；通过返回 None。
+    规则（纯规则零依赖，只挡"无意义"，不评"价值"）：
+      1) 空内容；
+      2) 无字母/汉字 且 过短(<8) 的纯占位/符号噪音（如 "1"、"!"、"!!!"）；
+      3) 字符多样性过低(熵代理)的重复噪音（如 "aaaaaa"、"111111"）。
+    单点维护：server ll_remember 与 workspace.add_evidence 共用本函数。
+    """
+    c = (content or "").strip()
+    if not c:
+        return "content 为空: 疑似无意义写入"
+    has_text = any(not ch.isdigit() and ch.isalnum() for ch in c)
+    if not has_text and len(c) < 8:
+        return "content 无文字内容且过短: 疑似占位噪音"
+    if len(set(c)) / len(c) < 0.2:
+        return "content 字符多样性过低(熵代理): 疑似重复噪音"
+    return None
+
+
+def should_escalate(confidence: float = 1.0, irreversible: bool = False,
+                    over_budget: bool = False) -> bool:
+    """升级刹车：命中任一红线即交回人。低置信 ∨ 不可逆 ∨ 超预算。
+
+    全自动不是高级，敢于在关键时刻说"我需要你"才是设计出来的安全网。
+    """
+    return (confidence < 0.5) or bool(irreversible) or bool(over_budget)
+
+
+class CapabilityMenu:
+    """能力菜单：声明带风险等级的能力，隔离靠部署层而非标签。"""
+
+    def __init__(self):
+        self._caps: dict = {}
+
+    def declare(self, name: str, risk: str = "low", description: str = "",
+                 params: list | None = None) -> None:
+        if risk not in RISK_LEVELS:
+            raise ValueError(f"risk 必须是 {RISK_LEVELS}，收到 {risk!r}")
+        self._caps[name] = {
+            "risk": risk,
+            "description": description,
+            "params": params or [],
+        }
+
+    def risk_of(self, name: str) -> str | None:
+        cap = self._caps.get(name)
+        return cap["risk"] if cap else None
+
+    def requires_confirm(self, name: str) -> bool:
+        """high 风险能力调用前必须确认（对齐液环确认闸门）。"""
+        return self.risk_of(name) == "high"
+
+    def as_menu(self) -> dict:
+        """供协议层展示的菜单（提示语，非沙箱）。"""
+        return dict(self._caps)
+
+
+def confirm_gate(action: str, risk: str = "high", auto_approve: bool = False) -> bool:
+    """确认闸：high 风险且未 auto 确认 → 返回 False（拦截，交回人）。
+
+    auto_approve=True 用于 dry-run / 测试；真实高危操作应默认拦截。
+    返回 True=放行，False=拦截（需人工确认）。
+    """
+    if risk not in RISK_LEVELS:
+        risk = "high"  # 未知风险按最高处置
+    if risk == "high" and not auto_approve:
+        return False
+    return True
+
+
+class PerceptionGate:
+    """门控-液环因果共生环的胶水层（“单终端机器人”概念落地件）。
+
+    设计定位（克制原则：精选 4 模块，不重新膨胀）：
+      - 输入候选感知动作 + 预算余量 + 灵敏度，输出 allow / degrade / block + 理由。
+      - 内部消费：
+          1) guard.should_escalate —— 不可逆变 + 低置信 → 交回人（block）。
+          2) 因果边（workspace.causal：enables/causes/contradicts）→ 「因果核心永饿死」
+             豁免：命中因果核心的动作即便超预算也放行，保证液环主链路不被闸饿死。
+          3) adaptive_recall 的负载双模（load<0.5 冗余验证 / ≥0.5 分工扩容）→
+             超预算时按当前认知负载决定 degrade（省算力）还是 allow（精度优先）。
+          4) build_or_cache（rar 本地索引缓存）→ 本地算力溶解「重建索引」成本，
+             使高载降级 skip 无后顾之忧（详见测试 test_perception_gate.py）。
+
+    零依赖：真实因果边 / 负载来自 liquid-loop 的 workspace / recall_filter / rar，
+    由 adapter 注入（causal_core_predicate / load_probe），不在本模块 import 重型依赖。
+    这样门控成为「可配置策略」，而非把整套液环塞进门里的膨胀方案。
+    """
+
+    def __init__(self, budget: float = 1.0, sensitivity: str = "normal",
+                 causal_core_predicate=None, load_probe=None):
+        self.budget = float(budget)
+        self.sensitivity = sensitivity
+        self._spent = 0.0
+        # 默认谓词：无注入时一律非因果核心（保守，闸正常生效）
+        self.causal_core_predicate = causal_core_predicate or (lambda action: False)
+        # 默认负载探测器：无注入时返回 0.0（低载，精度优先路径）
+        self.load_probe = load_probe or (lambda: 0.0)
+
+    def decide(self, action, cost: float = 0.0, confidence: float = 1.0,
+               irreversible: bool = False) -> dict:
+        """对一条候选感知动作做门控裁决。
+
+        返回 dict: {"decision": allow|degrade|block, "reason": str, ...}
+          - block    : 需人工确认（交回人），不消耗预算。
+          - allow    : 放行（因果核心豁免 / 正常 / 低载精度优先）。
+          - degrade  : 超预算 + 高载 → 降采样 / 跳过，省算力；不消耗预算。
+        """
+        # 1) 不可逆变 + 低置信 → 交回人（should_escalate 红线）
+        if should_escalate(confidence=confidence, irreversible=irreversible):
+            return {
+                "decision": "block",
+                "reason": "irreversible+low_confidence→需人工确认",
+                "escalate": True,
+            }
+
+        # 2) 因果核心 → 永放行（never starve causal core）
+        if self.causal_core_predicate(action):
+            return {
+                "decision": "allow",
+                "reason": "因果核心动作永放行（保护液环主链路）",
+                "causal_core": True,
+            }
+
+        # 3) 预算检查
+        remaining = self.budget - self._spent
+        if cost > remaining:
+            load = float(self.load_probe())
+            if load >= 0.5:
+                # 高载：降级 skip / 降采样，省算力
+                # （rar.build_or_cache 已本地化索引重建成本，skip 无后顾之忧）
+                return {
+                    "decision": "degrade",
+                    "reason": f"超预算+高载({load:.2f})→降采样/跳过省算力",
+                    "load": load,
+                    "over_budget": True,
+                }
+            # 低载：冗余验证，精度优先（仍消耗预算）
+            self._spent += cost
+            return {
+                "decision": "allow",
+                "reason": f"超预算+低载({load:.2f})→冗余验证精度优先",
+                "load": load,
+                "over_budget": True,
+            }
+
+        # 4) 正常放行
+        self._spent += cost
+        return {
+            "decision": "allow",
+            "reason": "正常放行",
+            "load": float(self.load_probe()),
+        }
+
+    def remaining(self) -> float:
+        """剩余预算。"""
+        return self.budget - self._spent

{liquid_loop-1.8.4 → liquid_loop-2.0.0}/liquid_loop/rar.py

@@ -318,6 +318,8 @@ class RARIndex:
         for e in state.evidences:
             if agent_id and e.agent_id != agent_id:
                 continue
+            if getattr(e, "superseded_by", False) or getattr(e, "archived", False):
+                continue  # 08-18 对齐 ll_recall：被取代/归档证据退出召回候选
             cands.append({
                 "id": e.id, "type": "evidence",
                 "category": _category_of(state, e.anchor_id),