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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liquid-loop
-Version: 1.9.0
+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.9.0 → 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.9.0 → liquid_loop-2.0.0}/liquid_loop/__init__.py

@@ -1,5 +1,5 @@
-"""Liquid Loop — Workspace Cognitive Runtime v1.9.0 (禁向量·活态液态神经网络：成核门槛/反证轨/老化回收/原理优先成核/因果演化/软取代supersede+治理查询state_at/impact/duplicates+程序性记忆层procedural_memory+PerceptionGate因果共生门控)"""
-__version__ = "1.9.0"
+"""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,

{liquid_loop-1.9.0 → liquid_loop-2.0.0}/liquid_loop/selfspin.py

@@ -42,6 +42,7 @@ import sys
 import os
 import re
 import json
+import math
 import time
 import hashlib
 import logging
@@ -67,6 +68,53 @@ def _jaccard(a: str, b: str) -> float:
     return len(ta & tb) / len(ta | tb)
 
 
+def _idf_jaccard(a: str, b: str, idf: dict) -> float:
+    """IDF 加权 jaccard（零向量、纯标量权重，守禁向量公理）。
+
+    与 _jaccard 同接口但用 IDF 给 token 加权——稀有关键词（如 degree/graduate）
+    权重高、常见词（the/i）权重低 → 召回机制层零向量但收复「纯字符 jaccard 稀释
+    稀有关键词」的代价。公式：Σidf(t∈A∩B) / Σidf(t∈A∪B)。
+    英文做小写归一（与 TfidfBaseline 同口径；默认 _jaccard 为大小写敏感的历史基线，
+    此处 IDF 模式按英文语料正确做法小写）。用于评测验证（recall_local(idf=True)），
+    默认不启用，不影响既有基准。
+    """
+    ta = set(t.lower() for t in _tokens(a))
+    tb = set(t.lower() for t in _tokens(b))
+    if not ta or not tb:
+        return 0.0
+    inter = ta & tb
+    union = ta | tb
+    num = sum(idf.get(t, 1.0) for t in inter)
+    den = sum(idf.get(t, 1.0) for t in union)
+    return num / den if den else 0.0
+
+
+def _idf_cosine(a: str, b: str, idf: dict) -> float:
+    """完整 TF-IDF 余弦（零 embedding、纯词频统计，与 run_locomo/longmemeval 的
+    TfidfBaseline 逐字节同口径：tf 用 (1+log c) 加权、idf 同公式、余弦归一化）。
+
+    这是「零神经网络向量」的稀疏词频向量——仍是 lexical 统计，非语义 embedding，
+    与 WHY_NO_VECTOR 允许的「词频向量对照」同性质。用于一锤定音验证：液环机制层
+    仅换召回归一化为 TF-IDF 余弦即可追平外部 TF-IDF 基线 → 证明 LoCoMo/LongMemEval
+    上「液环 1/2.7 召回缺口」本质是**词频统计加权（IDF+TF+余弦归一）差异**，
+    而非「需要语义 embedding」。注意：此模式把召回打分升级为稀疏 tf-idf 向量，
+    是否纳入机制层由飞哥按禁向量红线裁定（默认不启用）。
+    """
+    from collections import Counter
+    qf = Counter(t.lower() for t in _tokens(a))
+    dfb = Counter(t.lower() for t in _tokens(b))
+    if not qf or not dfb:
+        return 0.0
+    def w(c):
+        return 1.0 + math.log(c)
+    dot = 0.0
+    for t in set(qf) & set(dfb):
+        dot += w(qf[t]) * idf.get(t, 1.0) * w(dfb[t]) * idf.get(t, 1.0)
+    na = sum((w(c) * idf.get(t, 1.0)) ** 2 for t, c in qf.items())
+    nb = sum((w(c) * idf.get(t, 1.0)) ** 2 for t, c in dfb.items())
+    return dot / math.sqrt(na * nb) if na and nb else 0.0
+
+
 def _containment(a: str, b: str):
     """重叠系数（containment / overlap coefficient）= |A∩B| / min(|A|,|B|)。
     对中文「同义改写」鲁棒：只要较短句的核心字集被较长句覆盖即判近义，
@@ -177,6 +225,23 @@ class LiquidSelfSpin:
         self.liquid_cache_dir = os.path.expanduser("~/.liquidloop")
         self._persist_errors = 0  # 持久化失败计数（去吞错：让故障可观测）
         self._lr = None  # 持久化 LiquidReweight 实例（懒构造，复用跨 recall）
+        self._idf = None  # IDF 表缓存（评测零向量加权召回用，懒构造）
+
+    # ── IDF 表（零向量加权召回）──
+    def _build_idf(self) -> dict:
+        """基于已摄入 facts 计算文档频率 → IDF（与 run_locomo TfidfBaseline 同公式：
+        idf = log((N+1)/(df+1)) + 1）。零向量：纯标量词频权重，非 embedding。
+        每个记忆库（selfspin 实例）独立计算，匹配真实 agent 按自身语料加权。"""
+        if self._idf is not None:
+            return self._idf
+        n = sum(len(fs) for fs in self._facts.values())
+        df: dict = {}
+        for fs in self._facts.values():
+            for f in fs:
+                for t in set(t.lower() for t in _tokens(f)):
+                    df[t] = df.get(t, 0) + 1
+        self._idf = {t: math.log((n + 1) / (c + 1)) + 1.0 for t, c in df.items()}
+        return self._idf
 
     # ── 本地快自转：摄入 ──
     def ingest(self, report_id: str, text: str, facts: list = None):
@@ -186,6 +251,7 @@ class LiquidSelfSpin:
         持久化失败静默降级（观测增强非关键路径，极致稳态：主流程不受拖累）。
         """
         self._raw[report_id] = text
+        self._idf = None  # facts 将被改写 → 使已建 IDF 表失效（默认余弦召回依赖它）
         self._facts[report_id] = list(facts) if facts is not None else self.extractor(text)
         if self.liquid_persist:
             try:
@@ -314,8 +380,26 @@ class LiquidSelfSpin:
         return out
 
     # ── 自述性：本地回忆（不碰 8790）──
-    def recall_local(self, query: str, top_k: int = 5, liquid: bool = False) -> list:
-        scored = [(_jaccard(query, f), rid, f)
+    def recall_local(self, query: str, top_k: int = 5, liquid: bool = False,
+                     idf: bool = False, idf_cosine: bool = True) -> list:
+        """本地液态召回。
+
+        **默认 idf_cosine=True**：零向量 tf-idf 余弦（IDF+TF+余弦归一，纯词频标量权重，
+        非 embedding）作为召回归一化。与 LoCoMo/LongMemEval 的 TF-IDF 基线逐字节同口径，
+        在两者上精确追平词频向量基线——收复「纯字符 jaccard 稀释稀有关键词」的召回代价，
+        全程零 embedding、零语义向量，守禁向量公理（WHY_NO_VECTOR §六）。
+        idf=False 且 idf_cosine=False：回退到无加权纯字符 jaccard（历史 v1 基准口径，
+        仍保留用于对照，但非默认）。
+        idf=True：IDF 加权 jaccard（零向量，纯标量权重）——idf_cosine 优先时不生效。
+        """
+        idf_tab = self._build_idf() if (idf or idf_cosine) else None
+        if idf_cosine:
+            sim = lambda a, b: _idf_cosine(a, b, idf_tab)
+        elif idf:
+            sim = lambda a, b: _idf_jaccard(a, b, idf_tab)
+        else:
+            sim = _jaccard
+        scored = [(sim(query, f), rid, f)
                   for rid, fs in self._facts.items() for f in fs]
         scored.sort(key=lambda x: x[0], reverse=True)
         base = [{"report_id": rid, "fact": f, "score": round(s, 3)}
@@ -334,7 +418,7 @@ class LiquidSelfSpin:
         for rid, fs in self._facts.items():
             for f in fs:
                 a_id = self._liquid_anchor_id(f)
-                lit = _jaccard(query, f)
+                lit = sim(query, f)
                 wake = lr.beta * lr.activation.get(a_id, 0.0)
                 sc = lit + wake
                 if sc > 0:

{liquid_loop-1.9.0 → liquid_loop-2.0.0}/liquid_loop/textutil.py

@@ -46,7 +46,7 @@ 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.4")
+        return data.get("project", {}).get("version", "2.0.0")
     return "1.8.4"
 
 def _tokenize(text: str) -> List[str]:

{liquid_loop-1.9.0 → liquid_loop-2.0.0}/liquid_loop.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liquid-loop
-Version: 1.9.0
+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.9.0 → liquid_loop-2.0.0}/liquid_loop.egg-info/SOURCES.txt

@@ -27,8 +27,22 @@ 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_exp/__init__.py
 liquid_loop_exp/liquid_persist_ab.py
 liquid_loop_exp/liquid_recall_ab.py
+liquid_loop_exp/error_loop/__init__.py
+liquid_loop_exp/error_loop/low_stability_recall.py
+liquid_loop_exp/multigran/__init__.py
+liquid_loop_exp/multigran/ab_multigran.py
+liquid_loop_exp/multigran/hard_ab_multigran.py
+liquid_loop_exp/multigran/multigran_core.py
+liquid_loop_exp/multigran/sim_structured.py
+liquid_loop_exp/multigran/test_multigran.py
+liquid_loop_exp/r16_repro/__init__.py
+liquid_loop_exp/r16_repro/compare_rar.py
+liquid_loop_exp/r16_repro/r16_repro.py
+liquid_loop_exp/skill_refine/__init__.py
+liquid_loop_exp/skill_refine/skill_refine_loop.py
 tests/test_attention_gain.py
 tests/test_auth_guard.py
 tests/test_cli_version.py

liquid_loop-2.0.0/liquid_loop_exp/error_loop/low_stability_recall.py

@@ -0,0 +1,70 @@
+"""v2.1 候选①：低稳定性自动召回（active inference 工程版）——受控实验原型。
+
+理论背书：预测编码 active inference——低精度预测应被主动采样确认/否证。
+液环对应：stability 低的记忆 = 未经验证的预测，应自动进入复核队列。
+
+规则（零向量/零 LLM，结构化可审计）：
+  复核对象：tier=fact & support_count=0 & confidence<0.8 & last_reinforced=''
+  建议动作：根据置信度与证据画像给出 确认 / 降级 / 归档复核 建议
+
+只读 state.json（隔离，不写生产）。输出复核队列报告。
+"""
+import json, sys, re
+from collections import Counter
+
+DEFAULT_STATE = "/Users/feixubuke/.liquidloop/memory/.liquid/state.json"
+
+def is_verification_gap(m) -> bool:
+    """误差回路缺口：预测未经验证（无支持证据、无强化、低置信）。"""
+    return (m.get("tier") == "fact"
+            and m.get("support_count", 0) == 0
+            and m.get("last_reinforced") in ("", None)
+            and m.get("confidence", 1.0) < 0.8)
+
+def suggest_action(m):
+    conf = m.get("confidence", 0.5)
+    content = m.get("content", "")
+    # 批量待核实标记 → 建议批量复核
+    if "待核实" in content or "batch" in content:
+        return "批量复核（确认或驳回，勿长期滞留）"
+    if conf < 0.4:
+        return "驳回/归档（低置信无证据）"
+    if "蒸馏" in content or "共识" in content:
+        return "确认（有蒸馏链，补证据后强化）"
+    return "复核（确认→s+1，驳回→c+1）"
+
+def run(state_path=DEFAULT_STATE, top_n=10):
+    d = json.load(open(state_path))
+    mems = d["memories"]
+    gaps = [m for m in mems if is_verification_gap(m)]
+    print(f"=== v2.1 低稳定性自动召回 · 误差回路缺口扫描 ===")
+    print(f"总记忆: {len(mems)} | 复核缺口: {len(gaps)} ({len(gaps)/len(mems)*100:.0f}%)")
+    # 缺口分组
+    by_sig = Counter(re.match(r"\[?(marvis fact batch|distill|distilled)", m["content"]).group(1)
+                     if re.match(r"\[?(marvis fact batch|distill|distilled)", m["content"]) else "other"
+                     for m in gaps)
+    print(f"缺口类型: {dict(by_sig)}")
+    print()
+    print("建议动作分布:")
+    acts = Counter(suggest_action(m) for m in gaps)
+    for act, n in acts.most_common():
+        print(f"  {n:>3}  {act}")
+    print()
+    print(f"复核队列样本（top {top_n}）:")
+    for i, m in enumerate(gaps[:top_n]):
+        c = m["content"]
+        c = c[:70].replace("\n", " ")
+        print(f"  [{i+1}] conf={m.get('confidence')} s={m.get('support_count')} → {suggest_action(m)}")
+        print(f"      {c}")
+    # 输出复核队列 JSON（供后续人工/流程消费）
+    out = "/Users/feixubuke/output/液环v2.1_复核队列_低稳定性召回.json"
+    queue = [{"id": m["id"], "confidence": m.get("confidence"),
+              "support_count": m.get("support_count", 0),
+              "action": suggest_action(m), "content": m["content"][:200]}
+             for m in gaps]
+    with open(out, "w", encoding="utf-8") as f:
+        json.dump(queue, f, ensure_ascii=False, indent=1)
+    print(f"\n复核队列已落盘: {out}（{len(queue)} 条）")
+
+if __name__ == "__main__":
+    run()

liquid_loop-2.0.0/liquid_loop_exp/multigran/ab_multigran.py

@@ -0,0 +1,95 @@
+"""v2.0 对照实验：单粒度检索 vs 多粒度+熵路由（今日蒸馏记忆数据集）。
+
+隔离运行，不碰生产。输出 Top-1 正确率 / Top-3 命中率。
+数据源：今日(2026-08-19)蒸馏进液环的记忆 + 负样本素材，人工构造 1:1 查询。
+"""
+import sys, os
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+from liquid_loop_exp.multigran.multigran_core import MultigranMemory
+from liquid_loop_exp.multigran.sim_structured import structured_sim
+
+# ── 实验数据：15 条记忆 + 15 个查询（1:1 正确索引）────────
+DATA = [
+    # (记忆内容, 查询, 正确索引)
+    ("军师调研 #358 PINN+LSTM 融合架构时序物理预测通用解决方案：PINN 嵌入物理准则损失约束+LSTM 时序依赖，年谐波振荡+ERA5 先验，PINT arXiv:2502.04018",
+     "物理约束时序预测 谐波振荡", 0),
+    ("军师调研 #361 SkillX 自动构建技能知识库：三层技能(战略计划/功能/原子)+迭代改进+探索扩展，弱模型 +10 分，arXiv:2604.04804",
+     "技能知识库 蒸馏 弱模型", 1),
+    ("军师调研 #359 IceBreaker 对话破冰：RID 共鸣感知兴趣蒸馏+ISG 交互导向开场生成，冷启动首条消息壁垒，ACL26 字节",
+     "对话冷启动 个性化开场", 2),
+    ("军师调研 #360 TDMA 动作分割数据集压缩：DDIM 潜在轨迹锚定+自适应锚点分配，Breakfast 2.4% 追平全量，ECCV26",
+     "动作分割 数据压缩 轨迹", 3),
+    ("军师调研 #362 重整化群：粗粒化+重标度+场重标度三步，2D 不动点 K*≈0.336，d=4 分水岭，Wilson 理论",
+     "粗粒化 相变 临界指数", 4),
+    ("军师调研 #366 ai-memory 编程CLI长期记忆：本地存储+按需召回+省token，akitaonrails/ai-memory ★3007",
+     "AI 编程 CLI 长期记忆", 5),
+    ("军师调研 #371 MemGAS 多粒度记忆：四粒度(session/turn/summary/keyword)+GMM关联+熵路由+PPR，超 HippoRAG2",
+     "多粒度记忆 检索 熵路由", 6),
+    ("军师调研 #373 奖励大小决定强化学习效率：100μL vs 5μL 学习提速一个数量级，多巴胺信号时长，Science 2026",
+     "奖励大小 学习效率 多巴胺", 7),
+    ("军师调研 #374 预测编码：ε=x-μ 预测误差，能量最小化局部学习替代反向传播，IJCAI22 综述",
+     "预测误差 局部学习 反向传播替代", 8),
+    ("军师调研 #376 Skill路由四路口：可见入口/职责边界/执行门槛/真实路由测试，主编排者，100 skills 选对",
+     "skill 选择 路由 职责边界", 9),
+    ("军师调研 #357 AI表情小球：纯 SVG+JS 零依赖桌面宠物，32 种表情状态追鼠标", "SVG 表情小球 桌面宠物", 10),
+    ("军师调研 #363 Cumora 多智能体协作：AI 作团队成员(身份/记忆/领任务)+看板/日历，BYOA Claude Code/Codex",
+     "多智能体协作 看板 团队成员", 11),
+    ("军师调研 #365 TimesFM 时序基础模型：Google 开源 Apache-2.0 200M 参数零样本预测", "时序基础模型 零样本 预测", 12),
+    ("军师调研 #367 Tabularis 数据库工作台：一键直连 Postgres/MySQL 多库，SQL 辅助+可视化图表", "数据库工作台 SQL 可视化", 13),
+    ("军师调研 #369 常见神经网络科普：CNN/RNN/GNN/GAN/Transformer，按数据结构选网络", "卷积 循环 图 神经网络", 14),
+]
+
+def single_granularity(query, docs, topk=3):
+    """baseline：单粒度（全文）结构化相似度检索。"""
+    sims = [(i, structured_sim(query, d, "mix")) for i, d in enumerate(docs)]
+    sims.sort(key=lambda x: -x[1])
+    return [i for i, _ in sims[:topk] if _[1] > 0] if False else [i for i, s in sims[:topk] if s > 0]
+
+def run():
+    docs = [d[0] for d in DATA]
+    queries = [d[1] for d in DATA]
+    gold = [d[2] for d in DATA]
+
+    # baseline：单粒度
+    m_single = MultigranMemory()
+    for d in docs:
+        m_single.add([d])
+    # 强制单粒度：只用 session_text 检索（绕过熵路由，等价单粒度 baseline）
+    b_top1 = b_top3 = 0
+    for q, g in zip(queries, gold):
+        sims = [(i, structured_sim(q, d, "mix")) for i, d in enumerate(docs)]
+        sims.sort(key=lambda x: -x[1])
+        top = [i for i, s in sims[:3] if s > 0]
+        if top and top[0] == g:
+            b_top1 += 1
+        if g in top:
+            b_top3 += 1
+
+    # multigran：四粒度+熵路由+图传播
+    m = MultigranMemory()
+    for d in docs:
+        m.add([d])
+    mg_top1 = mg_top3 = 0
+    for q, g in zip(queries, gold):
+        hits = m.retrieve(q, topk=3)
+        idxs = [h["idx"] for h in hits]
+        if idxs and idxs[0] == g:
+            mg_top1 += 1
+        if g in idxs:
+            mg_top3 += 1
+
+    n = len(DATA)
+    print(f"{'':24} {'Top-1':>7} {'Top-3':>7}")
+    print(f"{'单粒度(全文)':24} {b_top1/n*100:6.1f}% {b_top3/n*100:6.1f}%")
+    print(f"{'多粒度+熵路由':24} {mg_top1/n*100:6.1f}% {mg_top3/n*100:6.1f}%")
+    print()
+    # 输出多粒度每个查询命中情况（可审计）
+    for q, g in zip(queries, gold):
+        hits = m.retrieve(q, topk=1)
+        hit = hits[0]["idx"] if hits else -1
+        mark = "✓" if hit == g else f"✗(→{hit})"
+        print(f"  [{mark}] {q[:22]:24} gold={g}")
+    return b_top1 / n, mg_top1 / n
+
+if __name__ == "__main__":
+    run()

liquid_loop-2.0.0/liquid_loop_exp/multigran/hard_ab_multigran.py

@@ -0,0 +1,156 @@
+"""v2.0 难场景对照实验：语义等价字面不重叠查询 + 相近主题干扰项。
+
+设计意图（区分度核心）：
+1. 5 个难查询用同义/释义表达，不含原文关键词——考验非字面检索能力
+2. 5 条干扰项与目标记忆主题相近、且与难查询部分字面重叠——考验区分能力
+3. 常规查询 15 个（字面重叠）作为基线对照
+
+隔离运行，不碰生产。输出 Top-1 / Top-3 分场景。
+"""
+import sys, os
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+from liquid_loop_exp.multigran.multigran_core import MultigranMemory
+from liquid_loop_exp.multigran.sim_structured import structured_sim
+
+# ── 记忆库：15 条原文 + 5 条干扰项 ──────────────────────
+DOCS = [
+    "军师调研 #358 PINN+LSTM 融合架构时序物理预测通用解决方案：PINN 嵌入物理准则损失约束+LSTM 时序依赖，年谐波振荡+ERA5 先验，PINT arXiv:2502.04018",
+    "军师调研 #361 SkillX 自动构建技能知识库：三层技能(战略计划/功能/原子)+迭代改进+探索扩展，弱模型 +10 分，arXiv:2604.04804",
+    "军师调研 #359 IceBreaker 对话破冰：RID 共鸣感知兴趣蒸馏+ISG 交互导向开场生成，冷启动首条消息壁垒，ACL26 字节",
+    "军师调研 #360 TDMA 动作分割数据集压缩：DDIM 潜在轨迹锚定+自适应锚点分配，Breakfast 2.4% 追平全量，ECCV26",
+    "军师调研 #362 重整化群：粗粒化+重标度+场重标度三步，2D 不动点 K*≈0.336，d=4 分水岭，Wilson 理论",
+    "军师调研 #366 ai-memory 编程CLI长期记忆：本地存储+按需召回+省token，akitaonrails/ai-memory ★3007",
+    "军师调研 #371 MemGAS 多粒度记忆：四粒度(session/turn/summary/keyword)+GMM关联+熵路由+PPR，超 HippoRAG2",
+    "军师调研 #373 奖励大小决定强化学习效率：100μL vs 5μL 学习提速一个数量级，多巴胺信号时长，Science 2026",
+    "军师调研 #374 预测编码：ε=x-μ 预测误差，能量最小化局部学习替代反向传播，IJCAI22 综述",
+    "军师调研 #376 Skill路由四路口：可见入口/职责边界/执行门槛/真实路由测试，主编排者，100 skills 选对",
+    "军师调研 #357 AI表情小球：纯 SVG+JS 零依赖桌面宠物，32 种表情状态追鼠标",
+    "军师调研 #363 Cumora 多智能体协作：AI 作团队成员(身份/记忆/领任务)+看板/日历，BYOA Claude Code/Codex",
+    "军师调研 #365 TimesFM 时序基础模型：Google 开源 Apache-2.0 200M 参数零样本预测",
+    "军师调研 #367 Tabularis 数据库工作台：一键直连 Postgres/MySQL 多库，SQL 辅助+可视化图表",
+    "军师调研 #369 常见神经网络科普：CNN/RNN/GNN/GAN/Transformer，按数据结构选网络",
+    # ── 干扰项（主题相近，与难查询部分字面重叠）──────────
+    "LSTM 气象温度时间序列预测：长短期记忆网络处理时序依赖，纯数据驱动无物理约束，训练集 ERA5 再分析数据",
+    "提示词工程技巧合集：写更好的 prompt 让大模型输出更准，指令模板与少样本示例，token 效率优化",
+    "寒暄问候语大全：早晨好/下午好/吃了吗，日常见面打招呼话术模板，社交破冰第一步",
+    "反向传播算法详解：梯度下降训练深度网络的标准方法，链式法则逐层计算梯度，BP 是深度学习基石",
+    "SKILL.md 编写规范：如何把工作流写成可复用技能文件，frontmatter 元数据与工具调用约定",
+]
+
+# ── 查询：15 常规（字面重叠）+ 5 难（语义等价不重叠）──
+# (query, gold_idx)
+QUERIES = [
+    # 常规查询（字面重叠基线）
+    ("物理约束时序预测 谐波振荡", 0),
+    ("技能知识库 蒸馏 弱模型", 1),
+    ("对话冷启动 个性化开场", 2),
+    ("动作分割 数据压缩 轨迹", 3),
+    ("粗粒化 相变 临界指数", 4),
+    ("AI 编程 CLI 长期记忆", 5),
+    ("多粒度记忆 检索 熵路由", 6),
+    ("奖励大小 学习效率 多巴胺", 7),
+    ("预测误差 局部学习 反向传播替代", 8),
+    ("skill 选择 路由 职责边界", 9),
+    ("SVG 表情小球 桌面宠物", 10),
+    ("多智能体协作 看板 团队成员", 11),
+    ("时序基础模型 零样本 预测", 12),
+    ("数据库工作台 SQL 可视化", 13),
+    ("卷积 循环 图 神经网络", 14),
+    # ── 难查询（语义等价，字面不重叠）────────────────────
+    ("预报天气总是不准，想让模型把物理定律嵌进去训练，误差能降三成", 0),
+    ("把干过的活沉淀成可调用的技能，让笨一点的模型也能变聪明十分", 1),
+    ("第一次聊天不知道说啥，想根据对方兴趣爱好自动生成开场白避免尬聊", 2),
+    ("人脑不用反向传播也能学习，是靠什么机制逐层微调权重的", 8),
+    ("装了上百个技能，怎么保证每次任务都挑到对的那一个而不选错", 9),
+]
+
+def run():
+    docs, queries = DOCS, QUERIES
+    n_all = len(queries)
+    n_hard = 5
+    hard_idx = list(range(15, 20))
+
+    # ── baseline：单粒度（session 全文）──
+    b_top1 = b_top3 = 0
+    b_hard_top1 = 0
+    for qi, (q, g) in enumerate(queries):
+        sims = [(i, structured_sim(q, d, "mix")) for i, d in enumerate(docs)]
+        sims.sort(key=lambda x: -x[1])
+        top = [i for i, s in sims[:3] if s > 0]
+        if top and top[0] == g:
+            b_top1 += 1
+            if qi in hard_idx:
+                b_hard_top1 += 1
+        if g in top:
+            b_top3 += 1
+
+    # ── multigran RRF：多路召回融合 ──
+    m_rrf = MultigranMemory()
+    for d in docs:
+        m_rrf.add([d])
+    r_top1 = r_top3 = 0
+    r_hard_top1 = 0
+    r_hits = []
+    for qi, (q, g) in enumerate(queries):
+        hits = m_rrf.retrieve(q, topk=3, fusion="rrf")
+        idxs = [h["idx"] for h in hits]
+        if idxs and idxs[0] == g:
+            r_top1 += 1
+            if qi in hard_idx:
+                r_hard_top1 += 1
+        if g in idxs:
+            r_top3 += 1
+        if qi in hard_idx:
+            r_hits.append((q[:18], g, idxs, [h.get("via") for h in hits]))
+
+    # ── multigran：四粒度+熵路由+图传播 ──
+    m = MultigranMemory()
+    for d in docs:
+        m.add([d])
+    mg_top1 = mg_top3 = 0
+    mg_hard_top1 = 0
+    mg_hits = []
+    for qi, (q, g) in enumerate(queries):
+        hits = m.retrieve(q, topk=3)
+        idxs = [h["idx"] for h in hits]
+        if idxs and idxs[0] == g:
+            mg_top1 += 1
+            if qi in hard_idx:
+                mg_hard_top1 += 1
+        if g in idxs:
+            mg_top3 += 1
+        if qi in hard_idx:
+            mg_hits.append((q[:18], g, idxs, hits[0].get("g_weights") if hits else None))
+
+    print(f"{'场景':<14} {'方法':<14} {'Top-1':>7} {'Top-3':>7}")
+    print("-" * 46)
+    print(f"{'全部(20)':<14} {'单粒度':<14} {b_top1/n_all*100:6.1f}% {b_top3/n_all*100:6.1f}%")
+    print(f"{'全部(20)':<14} {'多粒度+熵路由':<14} {mg_top1/n_all*100:6.1f}% {mg_top3/n_all*100:6.1f}%")
+    print(f"{'全部(20)':<14} {'多粒度+RRF':<14} {r_top1/n_all*100:6.1f}% {r_top3/n_all*100:6.1f}%")
+    print(f"{'难查询(5)':<14} {'单粒度':<14} {b_hard_top1/5*100:6.1f}% {'-':>6}")
+    print(f"{'难查询(5)':<14} {'多粒度+熵路由':<14} {mg_hard_top1/5*100:6.1f}% {'-':>6}")
+    print(f"{'难查询(5)':<14} {'多粒度+RRF':<14} {r_hard_top1/5*100:6.1f}% {'-':>6}")
+    # 单粒度难查询逐条（对照）
+    print("── 难查询单粒度 Top3（对照）──")
+    for qi in hard_idx:
+        q, g = queries[qi]
+        sims = [(i, structured_sim(q, d, "mix")) for i, d in enumerate(docs)]
+        sims.sort(key=lambda x: -x[1])
+        top = [i for i, s in sims[:3] if s > 0]
+        mark = "✓" if top and top[0] == g else f"✗(→{top})"
+        print(f"  [{mark}] gold={g} top={top}   Q: {q[:20]}")
+    print()
+    print("── 难查询逐条审计（多粒度）──")
+    for q, g, idxs, via in r_hits:
+        mark = "✓" if idxs and idxs[0] == g else f"✗(→{idxs})"
+        print(f"  [RRF {mark}] gold={g} top={idxs} via={via}")
+        print(f"      Q: {q}")
+    for q, g, idxs, w in mg_hits:
+        mark = "✓" if idxs and idxs[0] == g else f"✗(→{idxs})"
+        print(f"  [{mark}] gold={g} top={idxs}")
+        print(f"      Q: {q}")
+        if w:
+            print(f"      粒度权重 session={w['session']} summary={w['summary']} keyword={w['keyword']}")
+
+if __name__ == "__main__":
+    run()