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

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

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

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

@@ -1,5 +1,5 @@
-"""Liquid Loop — Workspace Cognitive Runtime v0.9.2 (Layer-1 修复: 结构化投影层 + 冲突惩罚持久化 + 有效迭代 τ)"""
-__version__ = "0.9.2"
+"""Liquid Loop — Workspace Cognitive Runtime v1.0.0 (双层自转 + 四循环本体论 + 墙钟实测 11.5× 成核加速)"""
+__version__ = "1.0.0"
 
 from .workspace import (
     WorkspaceState, Anchor, Evidence, Memory, Conflict,
@@ -8,3 +8,4 @@ from .workspace import (
 )
 from .storage import load, save, locked_state
 from .entropy import calculate, calculate_detail, calculate as calculate_entropy
+from .selfspin import LiquidSelfSpin

liquid_loop-1.0.0/liquid_loop/selfspin.py

@@ -0,0 +1,392 @@
+#!/usr/bin/env python3
+"""液环 v1.0 · 双层自转模块  Liquid Self-Spin
+=============================================
+解决飞哥提出的 v1.0 最大症结：本地多 agent 协作架构已拆除后，
+「记忆演化状态如何协同管理」？
+
+本模块以「双层自转」给出主体性保底方案（Vera 提案，2026-07-21）：
+
+  ① 本地快自转  rotation(fast)  —— 单节点微观自洽（类比 WorkspaceState.step(dt)）
+     会话内 transient 缓存，跨篇去重 / 共性提取；
+     不进 8790、不跨 agent 同步 → 支撑「自述性」(self-narrativity)。
+
+  ② 后端慢自转沉淀  revolution(slow deposition) —— 全局宏观节律收敛
+     经门控写 8790，隔离 agent_id（exp:selfspin:*）→ 支撑「自洽性」(self-consistency)；
+     8790 的 consensus 成核承接「主体间性」(inter-subjectivity)。
+
+意识三要素对齐：
+  自述性  = 本地自转（本节点说过什么，自己清楚）
+  自洽性  = 本地 + 后端（本节点说的与自己沉淀的一致）
+  主体间性 = 8790 consensus（跨节点一致 → 由后端承接）
+
+加速成核原理（墙钟实验 A/B 的核心）：
+  朴素直写 = 每篇报告抽出的事实文本略有差异 → 落到 8790 同 content 命中 < 2 → 几乎不成核。
+  双层自转 = 本地先聚类规范化，把跨 ≥2 篇一致的「同一事实」压成一条 canonical 陈述，
+            再以（同一 content × 同一 agent_id）按支持篇数重复写入 → 立刻触发 private 成核。
+  ⇒ 把「跨源自洽」在本地完成，后端只接收已收敛的结晶原料，成核被加速。
+
+零外部依赖（仅标准库 urllib/json/re），与 liquid_preping.py 同源风格。
+严格隔离：所有写入走 exp:selfspin:<run_id> namespace，绝不污染生产
+vera/trae/parlant/qiucai 记忆；且服务端 PREPING 闸门仅对 warmup:* 生效，selfspin 不被误杀。
+
+用法：
+  # 单元自测（纯逻辑，不写 8790）
+  python3 liquid_selfspin.py selftest
+
+  # 真实入库自测（写 8790，隔离 exp:selfspin:selftest，T250 打扫会清）
+  python3 liquid_selfspin.py selftest --live
+
+  # 作为库：见底部 LiquidSelfSpin 类
+"""
+import sys
+import os
+import re
+import json
+import time
+import argparse
+import urllib.request
+import urllib.error
+from collections import defaultdict
+
+DEFAULT_BACKEND = os.environ.get("LL_BASE", "http://127.0.0.1:8790")
+
+# ── Token / Jaccard（与 8790 server 同源：中文单字 + 英文数字连续串）──
+_TOKEN = re.compile(r"[一-鿿]|[a-zA-Z0-9]+")
+
+
+def _tokens(s: str) -> list:
+    return _TOKEN.findall(s or "")
+
+
+def _jaccard(a: str, b: str) -> float:
+    ta, tb = set(_tokens(a)), set(_tokens(b))
+    if not ta or not tb:
+        return 0.0
+    return len(ta & tb) / len(ta | tb)
+
+
+def _containment(a: str, b: str):
+    """重叠系数（containment / overlap coefficient）= |A∩B| / min(|A|,|B|)。
+    对中文「同义改写」鲁棒：只要较短句的核心字集被较长句覆盖即判近义，
+    避免 Jaccard 因双方各带不同修饰语而偏低（实测 0.25~0.55 漏合）。"""
+    ta, tb = set(_tokens(a)), set(_tokens(b))
+    if not ta or not tb:
+        return 0.0, 0
+    inter = ta & tb
+    return len(inter) / min(len(ta), len(tb)), len(inter)
+
+
+# 核心词抽取：去中文虚词 / 极泛连接词，保留领域实体与结论词，
+# 用于跨篇「同主题不同表述」的聚合信号（结构化精确匹配，守禁向量）。
+_STOP = set("的 是 在 存在 普遍 常 问题 风险 一种 我们 本文 该 其 与 和 或 对 为 有 被 "
+            "进行 使用 基于 采用 表明 指出 认为 提出 实现 用于 以及 即 也 都 等 这种 这个 "
+            "一个 没有 不 未 各 类 中 上 下 从 到 把 让 使 当 如果 但 而 则 并 且 将 已 仍 "
+            "更 最 较 很 之 间 内 外 后 前 时 处 它 他 她 我 你 这 那 哪 谁 什么 如何 怎么 "
+            "为何 是否 由于 因此 所以 因为 虽然 但是 然而 此外 同时 另外 例如 比如 包括 "
+            "涉及 针对 关于 对于 根据 按照".split())
+
+
+def _core(s: str) -> set:
+    """去虚词后的核心词集（中文单字 + 英文数字连续串）。"""
+    return set(t for t in _tokens(s) if t not in _STOP)
+
+
+# CJK / 全角标点 → ASCII 归一（用于沉积内容规范化，保证同义不同标点的事实成 byte 一致 → 触发成核）
+_PUNCT_MAP = {
+    "，": ",", "。": ".", "、": ",", "；": ";", "：": ":", "（": "(", "）": ")",
+    "“": '"', "”": '"', "‘": "'", "’": "'", "！": "!", "？": "?", "·": " ",
+    "～": " ", "—": "-", "《": "<", "》": ">", "【": "[", "】": "]",
+}
+def _normalize(s: str) -> str:
+    """去全角/空白的规范化：用于沉积内容，使同义异标点事实在 8790 中 byte 一致。"""
+    s = (s or "").lower()
+    for f, t in _PUNCT_MAP.items():
+        s = s.replace(f, t)
+    s = re.sub(r"\s+", "", s)
+    return s.strip()
+
+
+def _http_post(url: str, payload: dict, timeout: int = 15) -> dict:
+    data = json.dumps(payload, ensure_ascii=False).encode("utf-8")
+    req = urllib.request.Request(
+        url, data=data,
+        headers={"content-type": "application/json; charset=utf-8"}, method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as r:
+            return json.loads(r.read().decode("utf-8"))
+    except urllib.error.HTTPError as e:
+        try:
+            return json.loads(e.read().decode("utf-8"))
+        except Exception:
+            return {"ok": False, "error": f"http_{e.code}"}
+    except Exception as e:
+        return {"ok": False, "error": str(e)}
+
+
+# ── 默认事实抽取（无 LLM，确定性，作为占位 / 兜底）──
+_BOILER = re.compile(r"(微信|公众号|关注|转载|版权|声明|点击|扫码|登录|注册|免责|侵删|原文链接)")
+
+
+def _default_extract(text: str) -> list:
+    """把一段文本切成候选事实句（按句末标点 / 换行）。
+    无 LLM、纯规则，作为本地快自转的默认抽取器；墙钟实验会用 Gemma4 替换。"""
+    sents = re.split(r"[。！？!?\n]+", text or "")
+    out = []
+    for s in sents:
+        s = s.strip()
+        if 8 <= len(s) <= 120 and not _BOILER.search(s):
+            out.append(s)
+    return out
+
+
+class LiquidSelfSpin:
+    """双层自转客户端：本地快自转（consolidation）+ 后端慢自转沉淀（deposition）。
+
+    意识三要素：自述性=本地缓存(recall_local)、自洽性=本地+后端(deposit)、
+    主体间性=后端 consensus（本模块不负责，由 8790 承接）。
+
+    Args:
+      run_id       : 本次运行标识，拼成 agent_id = f"{agent_ns}:{run_id}"
+      agent_ns     : 隔离命名空间前缀，默认 exp:selfspin（绝不污染生产）
+      backend      : 8790 REST 基址
+      fast_jaccard : 本地聚类阈值（重叠系数 containment，默认 0.60 + 共享字≥4）
+      deposit_jac  : 预留（后端层同源去重阈值，暂未启用，保持接口一致）
+      extractor    : 事实抽取器 callable(text)->list[str]，默认 _default_extract
+    """
+
+    def __init__(self, run_id: str, agent_ns: str = "exp:selfspin",
+                 backend: str = DEFAULT_BACKEND, fast_jaccard: float = 0.60,
+                 deposit_jac: float = 0.95, extractor=None):
+        self.run_id = run_id
+        self.agent_id = f"{agent_ns}:{run_id}"
+        self.agent_ns = agent_ns
+        self.backend = backend.rstrip("/")
+        self.fast_jaccard = fast_jaccard
+        self.deposit_jac = deposit_jac
+        self.extractor = extractor or _default_extract
+        # 本地快自转：transient 缓存（不进 8790、不跨 agent 同步）
+        self._facts: dict = {}        # report_id -> list[fact]
+        self._raw: dict = {}          # report_id -> raw text（自述性溯源）
+        self._clusters: list = []     # 聚类结果
+        self._nuclei: list = []       # 本地核（≥2 篇支持的 canonical 簇）
+
+    # ── 本地快自转：摄入 ──
+    def ingest(self, report_id: str, text: str, facts: list = None):
+        """摄入一篇报告。facts=None 时用 extractor 抽；也可直接传入 LLM 抽取结果。"""
+        self._raw[report_id] = text
+        self._facts[report_id] = list(facts) if facts is not None else self.extractor(text)
+        return len(self._facts[report_id])
+
+    # ── 本地快自转：旋转（聚类 + 抽取 canonical）──
+    def local_rotate(self) -> list:
+        """跨篇聚类：把不同报告里「同义改写」的事实并到同一簇，取最长者为 canonical。
+        本地核 = 被 ≥2 个 distinct report 支持的簇（即跨源自洽）。"""
+        items = [(rid, f) for rid, fs in self._facts.items() for f in fs]
+        clusters = []  # 每簇: {"members":[(rid,f)], "reports":set}
+        for rid, f in items:
+            best, best_score, best_ci = None, 0.0, 0
+            cf = _core(f)
+            for c in clusters:
+                # 与簇内代表（前 3 个成员）比较，取最高相似度
+                for _, m in c["members"][:3]:
+                    j, shared = _containment(f, m)
+                    ci = len(cf & _core(m))
+                    # 主判：重叠系数达标（同义改写，字面近一致）
+                    # 次判：核心词交集 ≥2 且有一定字面重叠（同主题不同表述，如通用命题）
+                    merge = (j >= self.fast_jaccard and shared >= 4) or (ci >= 2 and j >= 0.38)
+                    score = j if j >= self.fast_jaccard else (0.4 + min(ci, 5) * 0.05 if merge else 0.0)
+                    if merge and score > best_score:
+                        best_score, best, best_ci = score, c, ci
+                if best_score >= self.fast_jaccard:
+                    break
+            if best is not None and best_score >= 0.45:
+                best["members"].append((rid, f))
+                best["reports"].add(rid)
+            else:
+                clusters.append({"members": [(rid, f)], "reports": {rid}})
+        # 选 canonical = 簇内最长成员；记录跨源度
+        for c in clusters:
+            c["canonical"] = max((m for _, m in c["members"]), key=len)
+            c["norm"] = _normalize(c["canonical"])  # 沉积用规范化串（byte 一致→成核）
+            c["size"] = len(c["members"])
+            c["reports"] = c["reports"]
+            c["n_reports"] = len(c["reports"])
+        self._clusters = clusters
+        self._nuclei = [c for c in clusters if c["n_reports"] >= 2]
+        return self._nuclei
+
+    # ── 后端慢自转沉淀：把本地核按支持篇数重复写入 8790 ──
+    def deposit(self, category: str = "selfspin", dry_run: bool = False) -> dict:
+        """对每个本地核，以（同一 canonical content × 同一 agent_id）按支持篇数重复写入
+        → 立刻触发 private 成核（≥2 同 content 同 agent）。严格隔离 agent_id。"""
+        if not self._nuclei:
+            self.local_rotate()
+        stats = {"nuclei": 0, "deposited": 0, "written": 0, "nucleated": 0,
+                 "rejected": 0, "fail": 0}
+        for c in self._nuclei:
+            stats["nuclei"] += 1
+            canonical = c["canonical"]
+            for rid in sorted(c["reports"]):
+                stats["deposited"] += 1
+                if dry_run:
+                    stats["written"] += 1
+                    continue
+                resp = _http_post(
+                    f"{self.backend}/remember",
+                    {"content": c["norm"], "category": category, "agent_id": self.agent_id},
+                )
+                if resp.get("ok"):
+                    stats["written"] += 1
+                    if resp.get("nucleated"):
+                        stats["nucleated"] += 1
+                elif resp.get("decision") == "discard":
+                    stats["rejected"] += 1
+                else:
+                    stats["fail"] += 1
+        return stats
+
+    # ── 增量沉积（墙钟实验捕获成核时刻）──
+    def incremental_deposit(self, state: dict, category: str = "selfspin") -> list:
+        """仅把每个 (本地核, 支持报告) 对沉积一次（跨多次调用由 state 去重）。
+        当某本地核的第 2 个支持报告被沉积时，后端 private 成核触发 → 可捕获墙钟成核时刻。
+        state: {"done": {norm: set(report_ids)}}（调用方持久化）。
+        注意：去重键用 c["norm"]（规范化串，稳定）而非 c["canonical"]（随增量重聚类漂移），
+        否则同一事实在不同 step 产生不同 canonical → 去重失效 → 重复成核。"""
+        out = []
+        done = state.setdefault("done", {})
+        for c in self._nuclei:
+            seen = done.setdefault(c["norm"], set())
+            for rid in sorted(c["reports"]):
+                if rid in seen:
+                    continue
+                seen.add(rid)
+                resp = _http_post(
+                    f"{self.backend}/remember",
+                    {"content": c["norm"], "category": category, "agent_id": self.agent_id},
+                )
+                out.append({"canonical": c["canonical"], "report_id": rid,
+                            "ok": resp.get("ok", False),
+                            "nucleated": bool(resp.get("nucleated"))})
+        return out
+
+    # ── 自述性：本地回忆（不碰 8790）──
+    def recall_local(self, query: str, top_k: int = 5) -> list:
+        scored = [(_jaccard(query, f), rid, f)
+                  for rid, fs in self._facts.items() for f in fs]
+        scored.sort(key=lambda x: x[0], reverse=True)
+        return [{"report_id": rid, "fact": f, "score": round(s, 3)}
+                for s, rid, f in scored if s > 0][:top_k]
+
+    # ── 朴素直写基线（A/B 对照用）──
+    @staticmethod
+    def naive_deposit(facts_by_report: dict, agent_id: str,
+                      backend: str = DEFAULT_BACKEND, category: str = "naive",
+                      dry_run: bool = False) -> dict:
+        """朴素直写：每篇抽出的事实各写一次，content 不规范化 → 同 content 命中 <2 → 难成核。"""
+        b = backend.rstrip("/")
+        stats = {"deposited": 0, "written": 0, "nucleated": 0, "rejected": 0, "fail": 0}
+        for rid, facts in facts_by_report.items():
+            for f in facts:
+                stats["deposited"] += 1
+                if dry_run:
+                    stats["written"] += 1
+                    continue
+                resp = _http_post(f"{b}/remember",
+                                  {"content": f, "category": category, "agent_id": agent_id})
+                if resp.get("ok"):
+                    stats["written"] += 1
+                    if resp.get("nucleated"):
+                        stats["nucleated"] += 1
+                elif resp.get("decision") == "discard":
+                    stats["rejected"] += 1
+                else:
+                    stats["fail"] += 1
+        return stats
+
+    def summary(self) -> dict:
+        return {
+            "run_id": self.run_id,
+            "agent_id": self.agent_id,
+            "reports_ingested": len(self._facts),
+            "facts_extracted": sum(len(v) for v in self._facts.values()),
+            "clusters": len(self._clusters),
+            "local_nuclei": len(self._nuclei),
+            "nuclei_preview": [
+                {"canonical": c["canonical"], "n_reports": c["n_reports"], "size": c["size"]}
+                for c in sorted(self._nuclei, key=lambda x: -x["n_reports"])[:10]
+            ],
+        }
+
+    def print_summary(self):
+        s = self.summary()
+        print(f"━━━ 双层自转 · 本地旋转摘要 ━━━")
+        print(f"  run_id           : {s['run_id']}")
+        print(f"  agent_id(隔离)   : {s['agent_id']}")
+        print(f"  摄入报告数       : {s['reports_ingested']}")
+        print(f"  抽出事实数       : {s['facts_extracted']}")
+        print(f"  聚类簇数         : {s['clusters']}")
+        print(f"  本地核(≥2篇支持): {s['local_nuclei']}")
+        for i, n in enumerate(s["nuclei_preview"], 1):
+            print(f"    [{i}] ({n['n_reports']}篇/{n['size']}条) {n['canonical'][:64]}")
+
+
+# ── 自测 ──
+def _selftest(live: bool = False):
+    """模拟真实实验路径：facts 由 Gemma4 抽出并规范化为 short canonical 陈述
+    （墙钟实验 T246 走的就是这条路；这里用同等规范化结果做单元验证）。"""
+    print("━━━ LiquidSelfSpin selftest ━━━")
+    ts = int(time.time())
+    run_id = f"selftest:{ts}"
+    ss = LiquidSelfSpin(run_id, fast_jaccard=0.60)
+
+    # 4 篇报告，Gemma4 抽出的规范化事实（同义改写为近似一致短句）
+    facts = {
+        "report_1": ["液环禁止用向量或embedding做一致性判定与成核", "本地多agent协作架构已拆除"],
+        "report_2": ["液环硬约束：禁用向量embedding做一致性判定", "记忆状态是演化对象而非被管理数据"],
+        "report_3": ["液环North-Star公理：自我调节的记忆状态演化机制", "液环禁止向量做一致性判定"],
+        "report_4": ["本地多agent协作架构已拆除", "今晚月色很好与液环无关"],
+    }
+    for rid, fs in facts.items():
+        n = ss.ingest(rid, "", facts=fs)
+        print(f"  ingest {rid}: {n} 条规范化事实")
+
+    nuclei = ss.local_rotate()
+    print(f"\n  本地旋转 → 聚类 {len(ss._clusters)} 簇，本地核 {len(nuclei)} 个")
+    ss.print_summary()
+
+    # 断言：应识别出 ≥2 个跨篇核（禁向量 ×3篇、多agent拆除 ×2篇）
+    assert len(nuclei) >= 2, f"自测失败：未识别到跨篇核（得到 {len(nuclei)}）"
+    # 断言自述性：本地回忆能命中
+    hit = ss.recall_local("液环 禁 向量 一致性")
+    assert hit and hit[0]["score"] > 0, "自测失败：本地回忆无命中"
+    print(f"\n  ✓ 本地快自转自测通过（自述性命中 top1 score={hit[0]['score']}）")
+
+    # 后端慢自转沉淀
+    if live:
+        print(f"\n  → 真实入库（隔离 agent_id={ss.agent_id}）...")
+        st = ss.deposit(category="selfspin", dry_run=False)
+        print(f"    沉积统计: {json.dumps(st, ensure_ascii=False)}")
+        assert st["nucleated"] >= 2, f"自测失败：后端未加速成核（nucleated={st['nucleated']}）"
+        print(f"  ✓ 后端慢自转沉淀自测通过（成核 {st['nucleated']} 个本地核）")
+    else:
+        st = ss.deposit(dry_run=True)
+        print(f"\n  → dry-run 沉积模拟: {json.dumps(st, ensure_ascii=False)}")
+        print(f"  ✓ 逻辑自测通过（--live 可真实入库验证成核加速）")
+    return True
+
+
+def main():
+    ap = argparse.ArgumentParser(description="液环 v1.0 双层自转模块")
+    sub = ap.add_subparsers(dest="cmd")
+    st = sub.add_parser("selftest", help="单元自测（默认 dry-run）")
+    st.add_argument("--live", action="store_true", help="真实写 8790（隔离 exp:selfspin:*）")
+    args = ap.parse_args()
+    if args.cmd == "selftest":
+        _selftest(live=args.live)
+    else:
+        ap.print_help()
+
+
+if __name__ == "__main__":
+    main()

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

@@ -577,6 +577,180 @@ class WorkspaceState:
         self._iteration += dt  # 推进有效状态更新计数（τ）
         self.updated_at = now()
 
+    # ─────────────────────────────────────────────────────────────
+    # v0.9.3 多智能体授权原语
+    # 修复共识误删事故：把归属校验从各接入层 wrapper 固化进核心，
+    # 使 REST / MCP / trae 桥 / 任意未来 agent 共用同一套授权，杜绝重复实现漂移。
+    # 注：本段不调用 save()，落盘由调用方在变更生效时负责（与 add_evidence 等一致）。
+    # ─────────────────────────────────────────────────────────────
+
+    def list_for(self, agent_id: str = "", category: Optional[str] = None) -> list[dict]:
+        """归属隔离列表：共识仅对贡献者可见，私有仅对贡献者可见，他人证据隔离。
+
+        - evidence：仅返回 agent_id 本人的（agent_id 为空 → 不返回任何证据，避免泄漏）。
+        - consensus 结晶：仅当 agent_id 是其 contributors 之一才返回（修复误删根因）。
+        - private 结晶：仅当 agent_id 在 contributors 才返回。
+        - 未知 scope 一律不暴露。
+        """
+        out: list[dict] = []
+        if agent_id:
+            for e in self.evidences:
+                if e.agent_id != agent_id:
+                    continue
+                cat = ""
+                anchor = next((a for a in self.anchors if a.id == e.anchor_id), None)
+                if anchor is not None:
+                    cat = anchor.name
+                out.append({
+                    "memory_id": e.id,
+                    "type": "evidence",
+                    "category": cat,
+                    "content": e.content,
+                    "agent_id": e.agent_id,
+                })
+        for m in self.memories:
+            if category and category != "(结晶)":
+                continue
+            if m.scope == "consensus":
+                if not agent_id or agent_id not in m.contributors:
+                    continue
+            elif m.scope == "private":
+                if not agent_id or agent_id not in m.contributors:
+                    continue
+            else:
+                continue
+            out.append({
+                "memory_id": m.id,
+                "type": "memory",
+                "category": "(结晶)",
+                "content": m.content,
+                "scope": m.scope,
+                "contributors": m.contributors,
+            })
+        return out
+
+    def delete_as(self, agent_id: str, memory_id: str) -> dict:
+        """带归属校验的删除（不自行落盘，由调用方 save）。
+
+        约束：
+        - 缺 agent_id → 拒绝。
+        - evidence：仅所有者可删。
+        - private 结晶：仅贡献者可删。
+        - consensus 结晶：禁止单端删除（需全体一致 dissolve），返回明确错误。
+        - content 兜底：仅删调用者贡献的 private + 本人 evidence；命中 consensus 整体拒绝。
+        """
+        if not agent_id:
+            return {"ok": False, "error": "forbidden: agent_id required to delete",
+                    "memory_id": memory_id}
+        ev = next((e for e in self.evidences if e.id == memory_id), None)
+        if ev is not None:
+            if ev.agent_id != agent_id:
+                return {"ok": False, "error": "forbidden: not owner of evidence",
+                        "memory_id": memory_id}
+            for a in self.anchors:
+                if ev.anchor_id == a.id and memory_id in a.evidence_ids:
+                    a.evidence_ids.remove(memory_id)
+            self.evidences.remove(ev)
+            return {"ok": True, "deleted": "evidence", "memory_id": memory_id}
+        mem = next((m for m in self.memories if m.id == memory_id), None)
+        if mem is not None:
+            if mem.scope == "consensus":
+                return {"ok": False,
+                        "error": "forbidden: consensus memory requires unanimous contributor dissolution, not single-agent delete",
+                        "memory_id": memory_id}
+            if agent_id not in mem.contributors:
+                return {"ok": False, "error": "forbidden: not a contributor of this private memory",
+                        "memory_id": memory_id}
+            self.memories.remove(mem)
+            return {"ok": True, "deleted": "memory", "memory_id": memory_id}
+        mems = [m for m in self.memories if m.content == memory_id]
+        if mems:
+            if any(m.scope == "consensus" for m in mems):
+                return {"ok": False,
+                        "error": "forbidden: content matches consensus memory; use unanimous dissolution",
+                        "memory_id": memory_id}
+            owned = [m for m in mems if agent_id in m.contributors]
+            if not owned:
+                return {"ok": False, "error": "forbidden: no owned private memory matches content",
+                        "memory_id": memory_id}
+            ev_ids = {eid for m in owned for eid in m.evidence_ids}
+            ev_ids |= {e.id for e in self.evidences if e.content == memory_id and e.agent_id == agent_id}
+            for m in owned:
+                self.memories.remove(m)
+            to_del = [e for e in self.evidences if e.id in ev_ids]
+            for e in to_del:
+                for a in self.anchors:
+                    if e.id in a.evidence_ids:
+                        a.evidence_ids.remove(e.id)
+                self.evidences.remove(e)
+            return {"ok": True, "deleted": "memory+evidence(owned only)", "memory_id": memory_id,
+                    "memories": len(owned), "evidences": len(to_del)}
+        return {"ok": False, "error": "not_found", "memory_id": memory_id}
+
+    def dissolve_as(self, agent_id: str, memory_id: str, votes_root: Path) -> dict:
+        """consensus 结晶的合法移除：全体贡献者各调用一次，集齐才真删。
+
+        - 缺 agent_id / 非 consensus / 非贡献者 → 拒绝。
+        - 每贡献者一票；投票持久化于 votes_root/.dissolve_votes.json。
+        - 集齐 → 真删（移除 memory + 其底层 evidence），清票，返回 dissolved=True。
+        - 未集齐 → 记票返回进度，不删。
+        不自行落盘 state（由调用方在 dissolved=True 时 save）。
+        """
+        if not agent_id:
+            return {"ok": False, "error": "forbidden: agent_id required to dissolve",
+                    "memory_id": memory_id}
+        mem = next((m for m in self.memories if m.id == memory_id), None)
+        if mem is None:
+            return {"ok": False, "error": "not_found", "memory_id": memory_id}
+        if mem.scope != "consensus":
+            return {"ok": False, "error": "not_consensus: use delete_as for private memory",
+                    "memory_id": memory_id}
+        if agent_id not in mem.contributors:
+            return {"ok": False, "error": "forbidden: not a contributor of this consensus",
+                    "memory_id": memory_id}
+        votes = _load_dissolve_votes(votes_root)
+        cast = set(votes.get(memory_id, []))
+        cast.add(agent_id)
+        need = set(mem.contributors)
+        if cast >= need:
+            ev_ids = set(mem.evidence_ids)
+            self.memories.remove(mem)
+            to_del = [e for e in self.evidences if e.id in ev_ids]
+            for e in to_del:
+                for a in self.anchors:
+                    if e.id in a.evidence_ids:
+                        a.evidence_ids.remove(e.id)
+                self.evidences.remove(e)
+            votes.pop(memory_id, None)
+            _save_dissolve_votes(votes_root, votes)
+            return {"ok": True, "dissolved": True, "memory_id": memory_id,
+                    "evidences": len(to_del), "voters": sorted(cast)}
+        votes[memory_id] = sorted(cast)
+        _save_dissolve_votes(votes_root, votes)
+        return {"ok": True, "dissolved": False, "memory_id": memory_id,
+                "voted": sorted(cast), "remaining": sorted(need - cast)}
+
+# ── dissolve 投票持久化（独立于核心 dataclass，守 North-Star 零改动）──
+def _dissolve_votes_path(root: Path) -> Path:
+    return Path(root) / ".dissolve_votes.json"
+
+
+def _load_dissolve_votes(root: Path) -> dict:
+    p = _dissolve_votes_path(root)
+    try:
+        return json.loads(p.read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+
+
+def _save_dissolve_votes(root: Path, votes: dict) -> None:
+    p = _dissolve_votes_path(root)
+    try:
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(json.dumps(votes, ensure_ascii=False), encoding="utf-8")
+    except Exception:
+        pass
+
 
 # ==============================================================================
 # CPERegularizer — 能力保留正则化引擎（借鉴 UIUC CPE 论文 arXiv:2605.09315）

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

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

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

@@ -6,6 +6,7 @@ liquid_loop/__main__.py
 liquid_loop/cli.py
 liquid_loop/cognitive_budget.py
 liquid_loop/entropy.py
+liquid_loop/selfspin.py
 liquid_loop/storage.py
 liquid_loop/workspace.py
 liquid_loop.egg-info/PKG-INFO
@@ -16,6 +17,7 @@ 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_auth_guard.py
 tests/test_consensus_expansion.py
 tests/test_entropy.py
 tests/test_layer1_persistence.py

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

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

liquid_loop-1.0.0/tests/test_auth_guard.py

@@ -0,0 +1,162 @@
+"""v0.9.3 多智能体授权原语无死角测试。
+
+覆盖：读隔离(list_for) / 删除授权(delete_as) / 一致解散(dissolve_as)。
+复现并固化「共识误删事故」修复，确保授权逻辑是单一事实源（库核心），
+而非各接入层 wrapper 重复实现。
+"""
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from liquid_loop import WorkspaceState
+
+
+@pytest.fixture
+def ws():
+    s = WorkspaceState()
+    a = s.add_anchor("fact")
+    ev_vera = s.add_evidence(a, "vera 知道 X", agent_id="vera")
+    ev_trae = s.add_evidence(a, "trae 知道 Y", agent_id="trae")
+    # vera 私有结晶（由 vera 自己的 2 条证据成核）
+    ev_vera2 = s.add_evidence(a, "vera 知道 X（佐证）", agent_id="vera")
+    priv = s.add_memory("vera 的私有结论", [ev_vera.id, ev_vera2.id])
+    priv.scope = "private"
+    priv.contributors = ["vera"]
+    # 跨主体共识结晶（vera × trae）
+    cons = s.add_memory("vera 与 trae 共同结论", [ev_vera.id, ev_trae.id])
+    cons.scope = "consensus"
+    cons.contributors = ["vera", "trae"]
+    return s, dict(a=a, ev_vera=ev_vera, ev_trae=ev_trae,
+                   priv=priv, cons=cons)
+
+
+# ── 1. 读隔离 list_for ──────────────────────────────────────────────
+def test_list_empty_agent_sees_nothing(ws):
+    s, _ = ws
+    out = s.list_for("")
+    assert out == [], "agent_id 为空时不得泄漏任何证据/结晶"
+
+
+def test_list_vera_sees_own_and_consensus(ws):
+    s, d = ws
+    ids = {x["memory_id"] for x in s.list_for("vera")}
+    assert d["ev_vera"].id in ids          # 自己的证据可见
+    assert d["cons"].id in ids             # 作为贡献者，共识可见
+    assert d["priv"].id in ids             # 自己的私有可见
+    assert d["ev_trae"].id not in ids     # 他人证据隔离
+
+
+def test_list_trae_sees_own_and_consensus_not_veras_private(ws):
+    s, d = ws
+    ids = {x["memory_id"] for x in s.list_for("trae")}
+    assert d["ev_trae"].id in ids
+    assert d["cons"].id in ids
+    assert d["ev_vera"].id not in ids
+    assert d["priv"].id not in ids         # vera 私有对 trae 隔离
+
+
+def test_list_consensus_hidden_from_non_contributor(ws):
+    s, d = ws
+    # 伪造一个「非贡献者」agent
+    ids = {x["memory_id"] for x in s.list_for("mallory")}
+    assert d["cons"].id not in ids, "共识仅对贡献者可见"
+    assert d["priv"].id not in ids
+
+
+# ── 2. 删除授权 delete_as ──────────────────────────────────────────
+def test_delete_requires_agent_id(ws):
+    s, d = ws
+    r = s.delete_as("", d["ev_vera"].id)
+    assert r["ok"] is False and "agent_id required" in r["error"]
+
+
+def test_delete_evidence_only_by_owner(ws):
+    s, d = ws
+    bad = s.delete_as("trae", d["ev_vera"].id)
+    assert bad["ok"] is False and "not owner" in bad["error"]
+    good = s.delete_as("vera", d["ev_vera"].id)
+    assert good["ok"] is True and good["deleted"] == "evidence"
+
+
+def test_delete_consensus_forbidden(ws):
+    s, d = ws
+    r = s.delete_as("vera", d["cons"].id)
+    assert r["ok"] is False and "consensus" in r["error"]
+
+
+def test_delete_private_only_by_contributor(ws):
+    s, d = ws
+    bad = s.delete_as("trae", d["priv"].id)
+    assert bad["ok"] is False and "not a contributor" in bad["error"]
+    good = s.delete_as("vera", d["priv"].id)
+    assert good["ok"] is True and good["deleted"] == "memory"
+
+
+def test_delete_by_content_owned_private(ws):
+    s, d = ws
+    # vera 的私有结晶按 content 兜底删除（仅删本人相关）
+    r = s.delete_as("vera", "vera 的私有结论")
+    assert r["ok"] is True and r["memories"] >= 1
+
+
+def test_delete_by_content_hits_consensus_forbidden(ws):
+    s, d = ws
+    r = s.delete_as("vera", "vera 与 trae 共同结论")
+    assert r["ok"] is False and "consensus" in r["error"]
+
+
+def test_delete_not_found(ws):
+    s, d = ws
+    r = s.delete_as("vera", "nonexistent-id")
+    assert r["ok"] is False and r["error"] == "not_found"
+
+
+# ── 3. 一致解散 dissolve_as ────────────────────────────────────────
+def test_dissolve_requires_agent_id(ws):
+    s, d = ws
+    root = Path(tempfile.mkdtemp())
+    r = s.dissolve_as("", d["cons"].id, root)
+    assert r["ok"] is False and "agent_id required" in r["error"]
+
+
+def test_dissolve_rejects_private(ws):
+    s, d = ws
+    root = Path(tempfile.mkdtemp())
+    r = s.dissolve_as("vera", d["priv"].id, root)
+    assert r["ok"] is False and "not_consensus" in r["error"]
+
+
+def test_dissolve_rejects_non_contributor(ws):
+    s, d = ws
+    root = Path(tempfile.mkdtemp())
+    r = s.dissolve_as("mallory", d["cons"].id, root)
+    assert r["ok"] is False and "not a contributor" in r["error"]
+
+
+def test_dissolve_partial_then_unanimous(ws):
+    s, d = ws
+    root = Path(tempfile.mkdtemp())
+    # 第一票：vera，未集齐
+    r1 = s.dissolve_as("vera", d["cons"].id, root)
+    assert r1["dissolved"] is False
+    assert set(r1["remaining"]) == {"trae"}
+    assert d["cons"].id in {m.id for m in s.memories}, "未集齐不应真删"
+    # 第二票：trae，集齐 → 真删
+    r2 = s.dissolve_as("trae", d["cons"].id, root)
+    assert r2["dissolved"] is True
+    assert d["cons"].id not in {m.id for m in s.memories}
+    # 票已清
+    from liquid_loop.workspace import _load_dissolve_votes
+    assert d["cons"].id not in _load_dissolve_votes(root)
+
+
+def test_dissolve_vote_persists_across_instances(ws):
+    """投票状态独立持久化，不依赖 WorkspaceState 内存（重启不丢票）"""
+    from liquid_loop.workspace import _load_dissolve_votes
+    s, d = ws
+    root = Path(tempfile.mkdtemp())
+    s.dissolve_as("vera", d["cons"].id, root)
+    # 重新从磁盘读票（模拟重启）
+    votes = _load_dissolve_votes(root)
+    assert d["cons"].id in votes and "vera" in votes[d["cons"].id]