liquid-loop 1.8.2__tar.gz → 1.8.3__tar.gz

{liquid_loop-1.8.2 → liquid_loop-1.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liquid-loop
-Version: 1.8.2
+Version: 1.8.3
 Summary: Self-Organizing Cognitive Memory for AI Agents — Liquid Loop theory implementation
 Author: fishbook0001
 Maintainer: fishbook0001

{liquid_loop-1.8.2 → liquid_loop-1.8.3}/liquid_loop/__init__.py

@@ -1,5 +1,5 @@
-"""Liquid Loop — Workspace Cognitive Runtime v1.8.2 (禁向量·活态液态神经网络：成核门槛/反证轨/老化回收/原理优先成核/因果演化/软取代supersede+治理查询state_at/impact/duplicates)"""
-__version__ = "1.8.2"
+"""Liquid Loop — Workspace Cognitive Runtime v1.8.3 (禁向量·活态液态神经网络：成核门槛/反证轨/老化回收/原理优先成核/因果演化/软取代supersede+治理查询state_at/impact/duplicates)"""
+__version__ = "1.8.3"
 
 from .workspace import (
     WorkspaceState, Anchor, Evidence, Memory, Conflict,
@@ -9,3 +9,6 @@ from .storage import load, save, locked_state
 from .entropy import calculate, calculate_detail, calculate as calculate_entropy
 from .selfspin import LiquidSelfSpin
 from .liquid_reweight import LiquidReweight
+from .context_compress import ExtractiveCondenser, compress_context, CondenseReport
+from .self_eval import consensus_self_check, diverg_beta, majority_vote, u_opsd_step
+from .recall_filter import recall_content_filter, content_aware_filter, cosine_dict

liquid_loop-1.8.3/liquid_loop/context_compress.py

@@ -0,0 +1,155 @@
+"""长会话/长上下文提取式压缩（蒸馏自 Octomind condense.rs，落地液环）
+
+把外部 runtime 的「提取式上下文压缩」蒸馏为液环一等公民组件：
+  - 超阈值触发 → 选行保留（非生成式摘要）
+  - 单条 < MIN_CANDIDATE_TOKENS 绝不触碰
+  - 压后 ≥ 压前则保留原文（no-gain 保护）
+  - 任何异常保留原文（fail-open）
+
+契合液环哲学：零向量、确定性、零丢失。
+压缩仅裁剪噪声行，原文语义结构（决策/错误/文件路径/代码/结论）保留；
+底层 storage 完整存档，「蒸馏」与「归档」互不干扰。
+
+触发阈值：环境变量 LIQUID_CONTEXT_COMPRESS_TOKENS（默认 0 = 不压缩），
+与 LIQUID_EVIDENCE_BUDGET 运维风格一致。
+"""
+from __future__ import annotations
+
+import os
+import re
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+def estimate_tokens(text: str) -> int:
+    """字符数 / 4 启发式（对预算触发判断足够精确，零依赖 tiktoken）。"""
+    if not text:
+        return 0
+    return max(1, len(text) // 4)
+
+
+# 高价值行信号：保留含错误/决策/文件路径/代码定义/符号的行
+_HIGH_VALUE = re.compile(
+    r"(?i)("
+    r"\b(error|failed|exception|traceback|panic)\b"  # 错误/异常
+    r"|\b(decision|changed|fixed|result|todo|fix|note)\b"  # 决策/结论
+    r"|[\w./\-]+\.(py|rs|ts|js|go|toml|json|md|yaml|yml)"  # 文件路径
+    r"|^\s*(def|fn|func|class|impl|pub|import|export)\b"  # 代码定义
+    r"|=>|==|!=|::|->"  # 代码符号
+    r")"
+)
+# 噪声行信号：空/纯符号行、闲聊开场
+_NOISE = re.compile(
+    r"(?i)^[\s>*\-–·•]*$"
+    r"|^(thinking|let me|i'll|sure|okay|great|here's)\b"
+)
+
+
+@dataclass
+class CondenseReport:
+    """压缩运行报告（对齐原版统计字段）。"""
+
+    triggered: bool = False
+    candidates: int = 0
+    condensed: int = 0
+    untouched: int = 0
+    saved_tokens: int = 0
+    notes: list = field(default_factory=list)
+
+
+class ExtractiveCondenser:
+    """超阈值触发 → 选行保留（非生成式摘要）→ fail-open 不崩。
+
+    与原版 condense_round 不变量对齐：
+      - 整轮 token 总和 > threshold 才触发（防小结果免费注入大轮）
+      - 单条 < MIN_CANDIDATE_TOKENS 绝不触碰
+      - 压后 ≥ 压前则保留原文 (no-gain)
+      - 任何异常返回原样 (fail-open)
+    """
+
+    MIN_CANDIDATE_TOKENS = 512
+    KEEP_RATIO = 0.5  # 候选结果最多保留的行比例上限
+
+    def __init__(self, tokens_threshold: int = 0):
+        # 0 = 不压缩（缺省关闭，与 LIQUID_EVIDENCE_BUDGET 风格一致）
+        self.tokens_threshold = tokens_threshold
+
+    def _score_line(self, line: str) -> float:
+        """启发式重要性打分（替代原版 cheap-LLM 行选择，零 LLM 依赖）。"""
+        s = 0.0
+        if _HIGH_VALUE.search(line):
+            s += 3.0
+        if _NOISE.search(line):
+            s -= 2.0
+        stripped = line.strip()
+        if len(stripped) >= 20:
+            s += 1.0
+        # 近似重复行惩罚
+        if len(stripped) > 40 and stripped.count(stripped[:10]) > 2:
+            s -= 1.5
+        return s
+
+    def condense_round(self, results: list) -> tuple:
+        """results: list of dict {"tool": str, "content": str}
+
+        返回 (压缩后 results, CondenseReport)。fail-open 时 triggered=False。
+        """
+        rep = CondenseReport()
+        try:
+            sizes = [estimate_tokens(r.get("content", "")) for r in results]
+            if sum(sizes) <= self.tokens_threshold:
+                return results, rep  # 未触发
+            rep.triggered = True
+
+            candidates = [i for i, t in enumerate(sizes)
+                          if t >= self.MIN_CANDIDATE_TOKENS]
+            rep.candidates = len(candidates)
+            if not candidates:
+                return results, rep
+
+            out = list(results)
+            for idx in candidates:
+                r = results[idx]
+                original = r.get("content", "")
+                before = estimate_tokens(original)
+                lines = original.splitlines()
+                if len(lines) <= 2:
+                    rep.untouched += 1
+                    continue
+                scored = [(self._score_line(ln), i, ln) for i, ln in enumerate(lines)]
+                scored.sort(key=lambda x: x[0], reverse=True)
+                keep_n = max(2, int(len(lines) * self.KEEP_RATIO))
+                keep_idx = sorted(i for _, i, _ in scored[:keep_n])
+                new_content = "\n".join(lines[i] for i in keep_idx)
+                after = estimate_tokens(new_content)
+                if after >= before:  # no-gain 保护
+                    rep.untouched += 1
+                    continue
+                out[idx] = {"tool": r.get("tool", ""), "content": new_content}
+                rep.condensed += 1
+                rep.saved_tokens += (before - after)
+            if rep.condensed:
+                rep.notes.append("📎 CONDENSED by supervisor")
+            return out, rep
+        except Exception as e:
+            rep.notes.append(f"fail-open: {e}")
+            return results, rep
+
+
+def compress_context(
+    texts: list,
+    threshold: Optional[int] = None,
+) -> tuple:
+    """液环便捷入口：把多条证据/上下文作为一轮压缩。
+
+    texts: 待压缩文本列表（如 recall 返回的多条证据 content）
+    threshold: 触发阈值 token；None 时读 LIQUID_CONTEXT_COMPRESS_TOKENS（默认 0=不压）
+    返回 (压缩后文本列表, CondenseReport)
+    """
+    if threshold is None:
+        threshold = int(os.environ.get("LIQUID_CONTEXT_COMPRESS_TOKENS", "0"))
+    if threshold <= 0:
+        return list(texts), CondenseReport()  # 未启用
+    results = [{"tool": "", "content": t} for t in texts]
+    out, rep = ExtractiveCondenser(threshold).condense_round(results)
+    return [r["content"] for r in out], rep

liquid_loop-1.8.3/liquid_loop/recall_filter.py

@@ -0,0 +1,126 @@
+"""液环召回相关性过滤（蒸馏自 RobSelf arXiv:2602.18822，落地 recall 过滤）
+
+RobSelf 两大组件：
+  ① 错位感知特征转换器：局部窗口搜索吸收空间错位（无需预对齐）
+  ② 内容感知参考滤波器：按内容相似度保留/抑制参考（去噪）
+蒸馏到液环 recall：在 jaccard 主相关性之外，加一层「内容感知 + 错位容忍」的
+辅助相关性打分，并可选抑制近零权重噪声候选。
+
+  - content_aware_weight：token 词频向量的余弦相似度（分布级相关性）。
+    比 jaccard 更能识别「只共享个别稀有 token 的噪声候选」→ RobSelf 去噪。
+  - aligned_score：错位容忍对齐分 = max(jaccard, 含容度(q⊆c), 含容度(c⊆q))。
+    吸收查询与记忆间的措辞/语序错位（paraphrase / 子集包含），即 RobSelf ①。
+
+零爆破半径设计：
+  - 默认仅增强（给每条候选附加两个 metadata 字段），绝不重排 recall 顺序。
+  - 仅当调用方显式给 θ∈(0,1) 时才抑制 content_aware_weight<θ 的噪声候选。
+  - fail-open：异常由 caller 兜底（返回原样）。
+
+零依赖：仅 Python 标准库（math, re, collections）。
+"""
+from __future__ import annotations
+
+import math
+import re
+from collections import Counter
+
+# 与 server 同源的 token 切分
+_TOKEN = re.compile(r"[一-鿿]|[a-zA-Z0-9]+")
+
+
+def _tokens(s: str) -> list:
+    return _TOKEN.findall(s or "")
+
+
+def _vec(s: str) -> dict:
+    """字符串 → 词频分布向量 {token: freq}。空串返回 {}。"""
+    toks = _tokens(s)
+    if not toks:
+        return {}
+    n = len(toks)
+    c = Counter(toks)
+    return {t: v / n for t, v in c.items()}
+
+
+def cosine_dict(a: dict, b: dict) -> float:
+    """两分布向量的余弦相似度（内容感知打分核心）。"""
+    keys = set(a) | set(b)
+    if not keys:
+        return 0.0
+    dot = sum(a.get(k, 0.0) * b.get(k, 0.0) for k in keys)
+    na = math.sqrt(sum(v * v for v in a.values()))
+    nb = math.sqrt(sum(v * v for v in b.values()))
+    if na == 0.0 or nb == 0.0:
+        return 0.0
+    return dot / (na * nb)
+
+
+def _jaccard_sets(a: set, b: set) -> float:
+    if not a or not b:
+        return 0.0
+    return len(a & b) / len(a | b)
+
+
+def _containment_sets(a: set, b: set) -> float:
+    """重叠系数 |A∩B| / min(|A|,|B|)：对子集包含（错位/部分匹配）鲁棒。"""
+    if not a or not b:
+        return 0.0
+    return len(a & b) / min(len(a), len(b))
+
+
+def content_aware_filter(ref_vec: dict, tgt_vec: dict, theta: float):
+    """内容感知参考滤波器（RobSelf ② 落地）：
+       计算参考与目标的内容相似度；≥θ 保留权重1，<θ 软抑制（权重=sim/θ）。
+       返回 (weight, sim)。不变量：抑制噪声/不匹配区域，保留有用内容。"""
+    sim = cosine_dict(ref_vec, tgt_vec)
+    weight = 1.0 if sim >= theta else max(sim / theta, 0.0) if theta > 0 else sim
+    return weight, sim
+
+
+def recall_content_filter(query: str, candidates: list, theta: float = 0.0,
+                          window: int = 3) -> tuple:
+    """对 recall 候选做内容感知 + 错位容忍增强（RobSelf 蒸馏落地）。
+
+    参数：
+        query     — 查询串
+        candidates— recall 返回的候选 dict 列表（需含 "content"）
+        theta     — 噪声抑制阈值（0=仅增强不抑制；0<θ<1=抑制 weight<θ 的候选）
+        window    — 错位容忍窗口（保留接口，当前对齐用含容度吸收错位）
+    返回 (过滤后候选列表, report)。
+      · 每条保留候选附加 content_aware_weight / aligned_score 两字段
+      · theta>0 时丢弃 content_aware_weight<θ 的噪声候选（RobSelf 去噪）
+    不变量：绝不重排（保留原 jaccard score 作为主排序）；fail-open 由 caller 包裹。
+    """
+    q_set = set(_tokens(query))
+    q_vec = _vec(query)
+    kept = []
+    suppressed = 0
+    for r in candidates:
+        content = r.get("content", "") or ""
+        c_set = set(_tokens(content))
+        c_vec = _vec(content)
+
+        # ① 内容感知权重（RobSelf ②）
+        if theta > 0:
+            weight, _ = content_aware_filter(c_vec, q_vec, theta)
+        else:
+            weight = cosine_dict(c_vec, q_vec)  # 纯相似度，仅展示
+
+        # ② 错位容忍对齐分（RobSelf ①）：吸收措辞/语序/子集包含错位
+        jac = _jaccard_sets(q_set, c_set)
+        cont_qc = _containment_sets(q_set, c_set)  # query 是候选的子集
+        cont_cq = _containment_sets(c_set, q_set)  # 候选是 query 的子集
+        aligned = max(jac, cont_qc, cont_cq)
+
+        if theta > 0 and weight < theta:
+            suppressed += 1
+            continue  # 噪声候选：内容感知低相似 → 抑制（不进入召回）
+
+        new_r = dict(r)  # 复制，避免污染原 dict
+        new_r["content_aware_weight"] = round(weight, 4)
+        new_r["aligned_score"] = round(aligned, 4)
+        kept.append(new_r)
+
+    rep = {"enabled": True, "theta": theta, "n_in": len(candidates),
+           "n_out": len(kept), "suppressed": suppressed}
+    return kept, rep

liquid_loop-1.8.3/liquid_loop/self_eval.py

@@ -0,0 +1,164 @@
+"""液环自评估（蒸馏自 U-OPSD arXiv:2608.06296，落地液环自检环节）
+
+U-OPSD 核心：无外部真值自评估——采样 G 条 rollout → 多数投票 → 最长同意 rollout
+为伪解 → 沿不同意 rollout 前缀逐 token D_β 蒸馏。蒸馏到液环的「自检环节」：
+
+  - consensus_self_check(answers, tau)：给定一组候选答案（如 Vera 对同一提议的
+    多条推理路径 / 改写），算共识票比 frac + 是否达 τ 触发 + 伪解；无需外部真值，
+    即给 AI 提议做一致性自检打分。vera-self-evolve 可经 8790 /selfcheck 调用。
+  - diverg_beta(p, q, beta)：β-散度（β=0.5 JSD 对称 / β=1 reverse KL 非对称）。
+  - u_opsd_step：原版三步骤（token 级 rollout 分布版），留给有真实策略分布的 caller。
+
+与 vera-self-evolve v2「RSI 内化」强同构：U-OPSD 的「无外部真值自评估」正是
+自进化评估器的确定性落地——不依赖外部标注即可给提议打一致性分（紧致度=可信度）。
+零依赖：仅 Python 标准库（math, re, collections）。fail-open：异常由 caller 兜底。
+"""
+from __future__ import annotations
+
+import math
+import re
+from collections import Counter
+
+# 与 server 同源的 token 切分：中文单字 + 英文数字连续串
+_TOKEN = re.compile(r"[一-鿿]|[a-zA-Z0-9]+")
+
+
+def _tokens(s: str) -> list:
+    return _TOKEN.findall(s or "")
+
+
+def majority_vote(answers):
+    """多数投票：返回 (伪答案, 胜出票比例)。
+
+    对齐 U-OPSD：伪解来自多数票；frac 即共识强度（无需外部真值）。
+    """
+    c = Counter(answers)
+    top, cnt = c.most_common(1)[0]
+    return top, cnt / len(answers)
+
+
+def diverg_beta(p, q, beta):
+    """β-散度 D_β(p∥q)：
+       β=1   → reverse KL: Σ q·log(q/p)
+       β≈0   → forward KL: Σ p·log(p/q)（β→0 极限）
+       β=0.5 → JSD（对称）：0.5·KL(P∥M)+0.5·KL(Q∥M), M=(P+Q)/2
+    论文 Table 5：β=0.5 标为 JSD，β=1 标为 reverse KL。
+    零依赖：标准库 math；p/q 为 {token: prob} 分布（缺失键按 1e-9 平滑）。
+    """
+    tokens = set(p) | set(q)
+    P = {t: p.get(t, 1e-9) for t in tokens}
+    Q = {t: q.get(t, 1e-9) for t in tokens}
+
+    def kl(a, b):
+        return sum(a[t] * math.log(a[t] / b[t]) for t in tokens)
+
+    if beta >= 1.0:
+        return kl(Q, P)  # reverse KL
+    if beta <= 0.0:
+        return kl(P, Q)  # forward KL
+    # β=0.5 → JSD
+    M = {t: 0.5 * (P[t] + Q[t]) for t in tokens}
+    return 0.5 * kl(P, M) + 0.5 * kl(Q, M)
+
+
+def _dist_of(s: str) -> dict:
+    """字符串 → 词频分布（token 级）。空串返回 {}。"""
+    toks = _tokens(s)
+    if not toks:
+        return {}
+    n = len(toks)
+    c = Counter(toks)
+    return {t: v / n for t, v in c.items()}
+
+
+def string_divergence(a: str, b: str, beta: float = 0.5) -> float:
+    """两条答案字符串间的 token 分布散度（U-OPSD D_β 的字符串级落地）。"""
+    return diverg_beta(_dist_of(a), _dist_of(b), beta)
+
+
+def consensus_self_check(answers, tau: float = 0.5, beta: float = 0.5) -> dict:
+    """字符串级共识自检（U-OPSD 落地版）—— 无外部真值，给提议打一致性分。
+
+    参数：
+        answers — 同一提议的多条候选答案（如多条推理路径 / 改写 / 重采样结果）
+        tau     — 触发阈值（默认 0.5，对齐论文 τ=1/2）
+        beta    — 散度阶（默认 0.5 JSD）
+    返回 dict：
+        triggered        — 多数票比 ≥ τ 且存在分歧（与 U-OPSD 触发条件同构）
+        frac             — 共识票比（共识强度）
+        pseudo_index     — 伪解（最长同意答案）在原列表的索引
+        pseudo_answer    — 伪解内容
+        mean_divergence  — 同意集内平均两两散度（越小越紧致=越可信伪解）
+        n                — 候选数
+    不变量：
+      ① 触发条件：胜出票比 ≥ τ(=1/2) 且 至少一条答案不同意（𝒴⁻ ≠ ∅）
+      ② 伪解 = 最长「同意」答案（argmax_{y∈𝒴⁺}|y|）
+    """
+    if not answers:
+        return {"triggered": False, "frac": 0.0, "pseudo_index": -1,
+                "pseudo_answer": None, "mean_divergence": 0.0, "n": 0}
+    pseudo, frac = majority_vote(answers)
+    Y_plus_idx = [i for i, a in enumerate(answers) if a == pseudo]
+    Y_minus = [a for a in answers if a != pseudo]
+
+    triggered = (frac >= tau) and (len(Y_minus) > 0)
+
+    # 伪解 = 最长同意答案
+    pseudo_index = max(Y_plus_idx, key=lambda i: len(answers[i]))
+
+    # 同意集内平均两两散度（紧致度）：越低→伪解越被多条路径共同支撑
+    plus = [answers[i] for i in Y_plus_idx]
+    if len(plus) >= 2:
+        divs = []
+        for i in range(len(plus)):
+            for j in range(i + 1, len(plus)):
+                divs.append(string_divergence(plus[i], plus[j], beta))
+        mean_div = sum(divs) / len(divs) if divs else 0.0
+    else:
+        mean_div = 0.0
+
+    return {"triggered": triggered, "frac": frac, "pseudo_index": pseudo_index,
+            "pseudo_answer": pseudo, "mean_divergence": mean_div, "n": len(answers)}
+
+
+# ---------- 策略分布版（进阶，留给有真实 π/π̄ 的 caller）----------
+def u_opsd_step(rollouts, pseudo_pick, tau: float = 0.5, beta: float = 0.5,
+                teacher_dist=None, student_dist=None) -> tuple:
+    """token 级 U-OPSD 核心三步（蒸馏版，分布由 caller 提供）。
+
+    参数：
+        rollouts     — 每条 rollout 为 (answer, tokens_tuple)
+        pseudo_pick  — 选伪解函数：给定同意 rollouts 返回伪解 tokens（默认最长）
+        teacher_dist — fn(ctx_tokens) → {token: prob}（stop-grad 副本 π̄）
+        student_dist — fn(ctx_tokens) → {token: prob}（可训练 π_θ）
+    返回 (loss, info)。loss 仅在触发时为正（未触发=0.0）。
+    不变量对齐论文 ℒ_U-OPSD：触发→选伪解→仅对 𝒴⁻ 前缀逐 token D_β。
+    """
+    if teacher_dist is None or student_dist is None:
+        raise ValueError("u_opsd_step 需要 teacher_dist / student_dist 策略分布函数")
+    answers = [r[0] for r in rollouts]
+    pseudo, frac = majority_vote(answers)
+    Y_plus = [r for r, a in zip(rollouts, answers) if a == pseudo]
+    Y_minus = [r for r, a in zip(rollouts, answers) if a != pseudo]
+
+    triggered = (frac >= tau) and (len(Y_minus) > 0)
+    if not triggered:
+        return 0.0, {"triggered": False, "frac": frac, "n_minus": len(Y_minus),
+                     "pseudo": pseudo, "loss": 0.0}
+
+    y_plus = pseudo_pick(Y_plus) if pseudo_pick else max(Y_plus, key=lambda r: len(r[1]))[1]
+
+    total = 0.0
+    n_terms = 0
+    for (_, y_minus_toks) in Y_minus:
+        for n in range(1, len(y_minus_toks)):
+            teacher_ctx = list(y_plus) + list(y_minus_toks[:n])
+            student_ctx = list(y_minus_toks[:n])
+            p_t = teacher_dist(teacher_ctx)   # π̄(·|x, y⁺, y⁻<n)
+            p_s = student_dist(student_ctx)   # π_θ(·|x, y⁻<n)
+            total += diverg_beta(p_t, p_s, beta)
+            n_terms += 1
+
+    loss = total / n_terms if n_terms else 0.0
+    return loss, {"triggered": True, "frac": frac, "pseudo": pseudo,
+                  "n_minus": len(Y_minus), "n_terms": n_terms, "loss": loss}

{liquid_loop-1.8.2 → liquid_loop-1.8.3}/liquid_loop/workspace.py

@@ -284,8 +284,8 @@ def _get_version() -> str:
     pyproject = Path(__file__).parent.parent / "pyproject.toml"
     if pyproject.exists():
         data = tomllib.loads(pyproject.read_text())
-        return data.get("project", {}).get("version", "1.8.2")
-    return "1.8.2"
+        return data.get("project", {}).get("version", "1.8.3")
+    return "1.8.3"
 
 @dataclass
 class WorkspaceState:
@@ -770,6 +770,8 @@ class WorkspaceState:
           - loser==winner → 拒绝（自取代无意义）
           - winner 不存在 → 拒绝（取代者须先存在，否则丧失血缘根基）
           - 重复取代同一 winner → 幂等（supersedes 去重，不堆叠）
+          - v1.8.3 consensus 保护（Palantir owned 细化）：loser 若是 consensus 结晶的证据，
+            禁止单边软取代——共识证据属于全体贡献者，只能走全员 dissolve（与 delete_as 同语义）。
         """
         if loser_id == winner_id:
             return {"ok": False, "error": "self_supersede_rejected", "loser_id": loser_id}
@@ -778,6 +780,13 @@ class WorkspaceState:
             return {"ok": False, "error": "loser_not_found", "loser_id": loser_id}
         if winner_id not in by_id:
             return {"ok": False, "error": "winner_not_found", "winner_id": winner_id}
+        # v1.8.3 consensus 保护：consensus 结晶的证据禁止单边软取代（防 admin 误伤共识）
+        consensus_evidence = {eid for m in self.memories if m.scope == "consensus"
+                              for eid in m.evidence_ids}
+        if loser_id in consensus_evidence:
+            return {"ok": False,
+                    "error": "forbidden: consensus evidence requires unanimous dissolution, not single supersede",
+                    "loser_id": loser_id}
         loser = by_id[loser_id]
         winner = by_id[winner_id]
         ts = now()

{liquid_loop-1.8.2 → liquid_loop-1.8.3}/liquid_loop.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liquid-loop
-Version: 1.8.2
+Version: 1.8.3
 Summary: Self-Organizing Cognitive Memory for AI Agents — Liquid Loop theory implementation
 Author: fishbook0001
 Maintainer: fishbook0001

{liquid_loop-1.8.2 → liquid_loop-1.8.3}/liquid_loop.egg-info/SOURCES.txt

@@ -5,9 +5,12 @@ liquid_loop/__init__.py
 liquid_loop/__main__.py
 liquid_loop/cli.py
 liquid_loop/cognitive_budget.py
+liquid_loop/context_compress.py
 liquid_loop/entropy.py
 liquid_loop/liquid_reweight.py
 liquid_loop/rar.py
+liquid_loop/recall_filter.py
+liquid_loop/self_eval.py
 liquid_loop/selfspin.py
 liquid_loop/storage.py
 liquid_loop/workspace.py
@@ -23,6 +26,7 @@ tests/test_attention_gain.py
 tests/test_auth_guard.py
 tests/test_cli_version.py
 tests/test_consensus_expansion.py
+tests/test_context_compress.py
 tests/test_entropy.py
 tests/test_layer1_persistence.py
 tests/test_lifecycle.py
@@ -30,8 +34,10 @@ tests/test_liquid_reweight.py
 tests/test_nucleate_dual_track.py
 tests/test_peek_seal.py
 tests/test_rar.py
+tests/test_recall_filter.py
 tests/test_replay_pressure.py
 tests/test_seal_persistence.py
+tests/test_self_eval.py
 tests/test_self_evolve.py
 tests/test_selfspin.py
 tests/test_semantica_borrow.py

{liquid_loop-1.8.2 → liquid_loop-1.8.3}/pyproject.toml

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

liquid_loop-1.8.3/tests/test_context_compress.py

@@ -0,0 +1,102 @@
+"""液环长会话提取式压缩落地测试（蒸馏自 Octomind condense.rs）"""
+import pytest
+from liquid_loop.context_compress import (
+    ExtractiveCondenser,
+    compress_context,
+    estimate_tokens,
+)
+
+
+def _big_text() -> str:
+    """单条 ≥ 512 token（≈2048 字符）才入候选。"""
+    return (
+        "error: connection refused\n"
+        + "okay sure let me think\n" * 5
+        + "def fix(): return True\n/path/to/module.py:42 changed\n"
+        + "result: 3 rows updated\n"
+        + "blah blah noise line\n" * 100
+    )
+
+
+# ───────────── 核心不变量 ─────────────
+
+def test_no_trigger_below_threshold():
+    cond = ExtractiveCondenser(tokens_threshold=100000)
+    texts = ["short line one", "short line two"]
+    out, rep = cond.condense_round([{"tool": "", "content": t} for t in texts])
+    assert rep.triggered is False
+    assert rep.condensed == 0
+
+
+def test_candidate_below_min_not_touched():
+    # 整轮超阈值，但单条 < 512 token → 不压缩任何条
+    small = "error: x\n" * 10  # 远小于 512 token
+    cond = ExtractiveCondenser(tokens_threshold=1)
+    out, rep = cond.condense_round([{"tool": "shell", "content": small}])
+    assert rep.triggered is True
+    assert rep.candidates == 0
+    assert rep.condensed == 0
+
+
+def test_condense_saves_tokens():
+    cond = ExtractiveCondenser(tokens_threshold=200)
+    out, rep = cond.condense_round([{"tool": "shell", "content": _big_text()}])
+    assert rep.triggered is True
+    assert rep.candidates == 1
+    assert rep.condensed == 1
+    assert rep.saved_tokens > 0
+    assert estimate_tokens(out[0]["content"]) < estimate_tokens(_big_text())
+
+
+def test_no_gain_keeps_original():
+    # 全是高价值短行（无可裁剪噪声）→ 不应越压越大，保留原文
+    cond = ExtractiveCondenser(tokens_threshold=1)
+    val = "def f(): return 1\n" * 5  # 每条短且高价值，压缩无收益
+    out, rep = cond.condense_round([{"tool": "x", "content": val}])
+    # 单条 < 512 token 不入候选，直接 untouched
+    assert rep.candidates == 0
+
+
+def test_fail_open_on_bad_input():
+    cond = ExtractiveCondenser(tokens_threshold=1)
+    # content 为非 str 真值（如 int）→ estimate_tokens 抛 TypeError，
+    # 被 try 捕获，fail-open 返回原样（不崩、不丢数据）
+    bad = [{"tool": "x", "content": 12345}]
+    out, rep = cond.condense_round(bad)
+    assert rep.notes and "fail-open" in rep.notes[0]
+    assert out == bad
+
+
+def test_none_content_safe_no_trigger():
+    # content=None 视为空，安全返回未触发（非异常路径）
+    cond = ExtractiveCondenser(tokens_threshold=1)
+    out, rep = cond.condense_round([{"tool": "x", "content": None}])
+    assert rep.triggered is False
+    assert rep.notes == []
+
+
+# ───────────── 便捷入口 + env 阈值 ─────────────
+
+def test_compress_context_env_threshold(monkeypatch):
+    monkeypatch.setenv("LIQUID_CONTEXT_COMPRESS_TOKENS", "200")
+    out, rep = compress_context([_big_text()])
+    assert rep.triggered is True
+    assert rep.condensed == 1
+
+
+def test_compress_context_disabled_by_default(monkeypatch):
+    monkeypatch.delenv("LIQUID_CONTEXT_COMPRESS_TOKENS", raising=False)
+    texts = [_big_text()]
+    out, rep = compress_context(texts)
+    assert rep.triggered is False  # 默认 0 = 不压缩
+    assert out == texts
+
+
+def test_compress_context_multi_round():
+    # 多条文本作为一轮，总 token 超阈值才触发
+    cond = ExtractiveCondenser(tokens_threshold=300)
+    texts = [_big_text(), _big_text()]
+    out, rep = cond.condense_round([{"tool": "", "content": t} for t in texts])
+    assert rep.triggered is True
+    assert rep.candidates == 2
+    assert rep.condensed == 2

liquid_loop-1.8.3/tests/test_recall_filter.py

@@ -0,0 +1,79 @@
+"""液环召回相关性过滤（蒸馏自 RobSelf）落地测试"""
+import math
+from liquid_loop.recall_filter import (
+    cosine_dict,
+    content_aware_filter,
+    recall_content_filter,
+    _vec,
+)
+
+
+def test_cosine_identical():
+    a = _vec("液环 禁 向量")
+    assert abs(cosine_dict(a, a) - 1.0) < 1e-9
+
+
+def test_cosine_orthogonal_zero():
+    a = _vec("苹果 香蕉")
+    b = _vec("西瓜 葡萄")
+    assert cosine_dict(a, b) == 0.0
+
+
+def test_content_aware_filter_suppress_vs_keep():
+    hi = _vec("液环 禁 向量 记忆")
+    lo = _vec("苹果 香蕉 西瓜")
+    tgt = _vec("液环 禁 向量 自检")
+    w_hi, s_hi = content_aware_filter(hi, tgt, theta=0.3)
+    w_lo, s_lo = content_aware_filter(lo, tgt, theta=0.3)
+    assert w_hi == 1.0 and s_hi >= 0.3
+    assert w_lo < 1.0 and s_lo < 0.3  # 低相似被软抑制
+
+
+def test_augment_only_attaches_metadata():
+    # theta=0 → 仅增强，不抑制，所有候选保留且附字段
+    cands = [
+        {"memory_id": "e1", "type": "evidence", "content": "液环禁向量记忆系统"},
+        {"memory_id": "m1", "type": "memory", "content": "共识结晶内容"},
+    ]
+    out, rep = recall_content_filter("液环 向量", cands, theta=0.0)
+    assert rep["suppressed"] == 0
+    assert len(out) == 2
+    assert "content_aware_weight" in out[0]
+    assert "aligned_score" in out[0]
+    # 记忆候选也附加 metadata（未抑制）
+    assert "content_aware_weight" in out[1]
+
+
+def test_suppress_noise_at_theta():
+    # theta=0.3 → 内容无关候选被抑制
+    cands = [
+        {"memory_id": "e1", "type": "evidence", "content": "液环禁向量记忆系统"},
+        {"memory_id": "e2", "type": "evidence", "content": "苹果 香蕉 西瓜 葡萄"},
+    ]
+    out, rep = recall_content_filter("液环 向量", cands, theta=0.3)
+    assert rep["suppressed"] == 1
+    assert len(out) == 1
+    assert out[0]["memory_id"] == "e1"
+
+
+def test_aligned_score_absorbs_subset_misalignment():
+    # query 是候选的子集 → 错位容忍对齐分应 > 纯 jaccard（子集被识别为相关）
+    cands = [{"memory_id": "e1", "type": "evidence",
+              "content": "液环 禁 向量 记忆 系统 自检 环节"}]
+    out, _ = recall_content_filter("液环 向量", cands, theta=0.0)
+    # aligned_score = max(jaccard, containment(q⊆c), containment(c⊆q))
+    # query⊆candidate → containment(q⊆c) = 1.0
+    assert out[0]["aligned_score"] == 1.0
+
+
+def test_recall_order_preserved_no_rerank():
+    # 过滤绝不重排：输入顺序保持
+    cands = [
+        {"memory_id": "e1", "type": "evidence", "content": "苹果 香蕉"},
+        {"memory_id": "e2", "type": "evidence", "content": "液环 向量 记忆"},
+        {"memory_id": "e3", "type": "evidence", "content": "西瓜 葡萄"},
+    ]
+    # theta=0.3 → e1/e3 被抑制，仅 e2 保留，但顺序应紧随其原位置（输出顺序=输入顺序）
+    out, rep = recall_content_filter("液环 向量", cands, theta=0.3)
+    assert [r["memory_id"] for r in out] == ["e2"]
+    assert rep["n_in"] == 3

liquid_loop-1.8.3/tests/test_self_eval.py

@@ -0,0 +1,77 @@
+"""液环自检（蒸馏自 U-OPSD）落地测试"""
+import math
+from liquid_loop.self_eval import (
+    majority_vote,
+    diverg_beta,
+    consensus_self_check,
+    string_divergence,
+)
+
+
+def test_majority_vote():
+    ans = ["A", "A", "B", "A", "C"]
+    top, frac = majority_vote(ans)
+    assert top == "A"
+    assert abs(frac - 0.6) < 1e-9
+
+
+def test_diverg_beta_jsd_symmetric():
+    pa = {1: 0.9, 2: 0.1}
+    pb = {1: 0.5, 2: 0.5}
+    js_ab = diverg_beta(pa, pb, beta=0.5)
+    js_ba = diverg_beta(pb, pa, beta=0.5)
+    assert abs(js_ab - js_ba) < 1e-9  # JSD 对称
+
+
+def test_diverg_beta_reverse_kl_asymmetric():
+    pa = {1: 0.9, 2: 0.1}
+    pb = {1: 0.5, 2: 0.5}
+    rk_ab = diverg_beta(pa, pb, beta=1.0)
+    rk_ba = diverg_beta(pb, pa, beta=1.0)
+    assert abs(rk_ab - rk_ba) > 1e-6  # reverse KL 非对称
+
+
+def test_consensus_triggered_with_disagreement():
+    # 3/5 同意 → frac=0.6≥0.5 且存在分歧 → 触发
+    ans = ["液环禁向量", "液环禁向量", "液环禁向量", "用embedding", "别禁向量"]
+    rep = consensus_self_check(ans, tau=0.5)
+    assert rep["triggered"] is True
+    assert abs(rep["frac"] - 0.6) < 1e-9
+    assert rep["pseudo_answer"] == "液环禁向量"
+    assert rep["n"] == 5
+    assert rep["mean_divergence"] >= 0.0
+
+
+def test_consensus_not_triggered_all_same():
+    # 全同意 → 𝒴⁻=∅ → 不触发
+    ans = ["same"] * 6
+    rep = consensus_self_check(ans, tau=0.5)
+    assert rep["triggered"] is False
+    assert rep["frac"] == 1.0
+    assert rep["mean_divergence"] == 0.0
+
+
+def test_consensus_not_triggered_low_frac():
+    # 票比 < τ → 不触发
+    ans = ["x", "y", "z", "w"]
+    rep = consensus_self_check(ans, tau=0.5)
+    assert rep["triggered"] is False
+
+
+def test_consensus_empty():
+    rep = consensus_self_check([], tau=0.5)
+    assert rep["triggered"] is False
+    assert rep["n"] == 0
+    assert rep["pseudo_answer"] is None
+
+
+def test_string_divergence_identical_zero():
+    assert string_divergence("液环 禁 向量", "液环 禁 向量") == 0.0
+
+
+def test_consensus_tight_pseudo_low_divergence():
+    # 同意集高度一致 → mean_divergence 应远小于分歧大的情况
+    ans_tight = ["液环禁向量", "液环禁向量", "液环禁向量", "不同答案"]
+    rep_tight = consensus_self_check(ans_tight, tau=0.5)
+    assert rep_tight["triggered"] is True
+    assert rep_tight["mean_divergence"] < 1e-6  # 同意集完全相同 → 散度为0

{liquid_loop-1.8.2 → liquid_loop-1.8.3}/tests/test_semantica_borrow.py

@@ -72,3 +72,26 @@ def test_find_duplicates_detects_real_duplicate():
                                  agent_id="marvis"))
     r = st.find_duplicates(threshold=0.8)
     assert any(c["similarity"] >= 1.0 for c in r["candidates"])
+
+
+# ── v1.8.3 consensus 保护（Palantir owned 细化）：consensus 结晶证据禁止单边 supersede ──
+def test_supersede_consensus_protected():
+    st = WorkspaceState()
+    st.evidences = [
+        Evidence(id="c1", content="共识事实", agent_id="vera"),
+        Evidence(id="c2", content="共识事实", agent_id="marvis"),
+        Evidence(id="w1", content="取代者", agent_id="vera"),
+    ]
+    # 构造 consensus 结晶：c1+c2 跨 agent 一致
+    st.memories = [
+        Memory(id="m1", content="共识事实", scope="consensus",
+               evidence_ids=["c1", "c2"], contributors=["vera", "marvis"]),
+    ]
+    # loser 是 consensus 证据 → 拒绝
+    r = st.supersede_evidence("c1", "w1")
+    assert not r.get("ok")
+    assert "consensus evidence requires unanimous dissolution" in r.get("error", "")
+    # 非 consensus 证据仍可 supersede
+    st.evidences.append(Evidence(id="p1", content="普通证据", agent_id="vera"))
+    r = st.supersede_evidence("p1", "w1")
+    assert r.get("ok"), r