liquid-loop 0.1.2__tar.gz → 0.3.0__tar.gz

{liquid_loop-0.1.2 → liquid_loop-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liquid-loop
-Version: 0.1.2
+Version: 0.3.0
 Summary: Self-Organizing Cognitive Memory for AI Agents — Liquid Loop theory implementation
 Author: fishbook0001
 Maintainer: fishbook0001
@@ -123,27 +123,24 @@ save(state, Path("."))
 # 初始化工作区（创建 .liquid/state.json）
 liquid-loop init
 
-# 添加锚点
+# 添加锚点（支持自动四维分类）
 liquid-loop anchor_add "项目目标" "完成液环论文与开源"
 
 # 注入证据
 liquid-loop evidence_add "项目目标" "已完成 11 轮实验与 4 个实证包"
 
-# 查看状态
+# 查看状态（含审计链哈希）
 liquid-loop status
-# 输出:
-# ╭──────────────────────────────────────────────╮
-# │ Liquid Loop 认知状态                          │
-# ├──────────┬──────┬────────┬────────┬────────┬──┤
-# │ 锚点     │ 证据 │ 结晶   │ 冲突   │ 熵值   │  │
-# ├──────────┼──────┼────────┼────────┼────────┼──┤
-# │ 项目目标 │ 3    │ 1      │ 0      │ 0.2760 │ 🟢│
-# ╰──────────┴──────┴────────┴────────┴────────┴──╯
-# 锚点稳定性: 项目目标=0.88
 
 # 列出所有记忆结晶
 liquid-loop memory_list
 
+# 审计：验证链式哈希完整性
+liquid-loop audit
+
+# 查看审计日志（最近 20 条）
+liquid-loop audit-log --tail 20
+
 # 快照（记录当前认知基线）
 liquid-loop snapshot
 ```
@@ -194,10 +191,10 @@ Liquid Loop 是唯一完全自组织 + 零 LLM 管理的系统。
 liquid-loop/
 ├── liquid_loop/
 │   ├── __init__.py      # 公共 API 导出
-│   ├── workspace.py     # 核心数据模型
-│   ├── storage.py       # JSON 持久化
+│   ├── workspace.py     # 核心数据模型 + AuditChain + auto_classify + decay
+│   ├── storage.py       # JSON 持久化 + 审计链写入
 │   ├── entropy.py       # 四维熵值计算
-│   └── cli.py           # Click CLI (9 命令)
+│   └── cli.py           # Click CLI (11 命令)
 ├── examples/
 │   └── quickstart.py
 ├── tests/               # 待补充

{liquid_loop-0.1.2 → liquid_loop-0.3.0}/README.md

@@ -84,27 +84,24 @@ save(state, Path("."))
 # 初始化工作区（创建 .liquid/state.json）
 liquid-loop init
 
-# 添加锚点
+# 添加锚点（支持自动四维分类）
 liquid-loop anchor_add "项目目标" "完成液环论文与开源"
 
 # 注入证据
 liquid-loop evidence_add "项目目标" "已完成 11 轮实验与 4 个实证包"
 
-# 查看状态
+# 查看状态（含审计链哈希）
 liquid-loop status
-# 输出:
-# ╭──────────────────────────────────────────────╮
-# │ Liquid Loop 认知状态                          │
-# ├──────────┬──────┬────────┬────────┬────────┬──┤
-# │ 锚点     │ 证据 │ 结晶   │ 冲突   │ 熵值   │  │
-# ├──────────┼──────┼────────┼────────┼────────┼──┤
-# │ 项目目标 │ 3    │ 1      │ 0      │ 0.2760 │ 🟢│
-# ╰──────────┴──────┴────────┴────────┴────────┴──╯
-# 锚点稳定性: 项目目标=0.88
 
 # 列出所有记忆结晶
 liquid-loop memory_list
 
+# 审计：验证链式哈希完整性
+liquid-loop audit
+
+# 查看审计日志（最近 20 条）
+liquid-loop audit-log --tail 20
+
 # 快照（记录当前认知基线）
 liquid-loop snapshot
 ```
@@ -155,10 +152,10 @@ Liquid Loop 是唯一完全自组织 + 零 LLM 管理的系统。
 liquid-loop/
 ├── liquid_loop/
 │   ├── __init__.py      # 公共 API 导出
-│   ├── workspace.py     # 核心数据模型
-│   ├── storage.py       # JSON 持久化
+│   ├── workspace.py     # 核心数据模型 + AuditChain + auto_classify + decay
+│   ├── storage.py       # JSON 持久化 + 审计链写入
 │   ├── entropy.py       # 四维熵值计算
-│   └── cli.py           # Click CLI (9 命令)
+│   └── cli.py           # Click CLI (11 命令)
 ├── examples/
 │   └── quickstart.py
 ├── tests/               # 待补充

liquid_loop-0.3.0/liquid_loop/__init__.py

@@ -0,0 +1,2 @@
+"""Liquid Loop — Workspace Cognitive Runtime v0.3.0"""
+__version__ = "0.3.0"  # KFG补强版

liquid_loop-0.3.0/liquid_loop/cli.py

@@ -0,0 +1,322 @@
+import click
+from pathlib import Path
+from collections import Counter
+from .workspace import (
+    WorkspaceState, Anchor, Evidence, Memory, StateSnapshot,
+    AnchorRelation, now, DensityLevel, CognitiveStage, LiquidityLevel,
+)
+from .storage import load, save, get_audit_chain
+from .entropy import calculate
+from .entropy import calculate
+
+
+WORKSPACE = Path.cwd()
+
+
+def _load():
+    return load(WORKSPACE)
+
+
+def _save(state: WorkspaceState):
+    state.updated_at = now()
+    save(state, WORKSPACE)
+
+
+# Memory Nucleation: 同一 Anchor 下 >= 2 条一致 Evidence 成核
+def _nucleate(state: WorkspaceState, anchor_id: str):
+    group = [e for e in state.evidences if e.anchor_id == anchor_id]
+    if len(group) < 2:
+        return
+    content_counts = Counter(e.content for e in group)
+    for content, count in content_counts.items():
+        if count >= 2:
+            existing = [m for m in state.memories if m.content == content]
+            if existing:
+                continue
+            evidence_ids = [e.id for e in group if e.content == content]
+            confidence = min(count / len(group), 1.0)
+            memory = Memory(
+                content=content,
+                evidence_ids=evidence_ids,
+                confidence=confidence,
+            )
+            state.memories.append(memory)
+
+
+def _decay_evidence(state: WorkspaceState, anchor_id: str):
+    for e in state.evidences:
+        if e.anchor_id == anchor_id:
+            e.weight = max(e.weight * 0.95, 0.1)
+
+
+def _recalc_stability(state: WorkspaceState, anchor_id: str):
+    group = [e for e in state.evidences if e.anchor_id == anchor_id]
+    if not group:
+        return
+    avg_weight = sum(e.weight for e in group) / len(group)
+    for a in state.anchors:
+        if a.id == anchor_id:
+            a.stability = avg_weight
+            # 刷新价值衰减 + 锚定强度 + 自动分类
+            evidence_count = len(group)
+            a.decay_value(evidence_count=evidence_count)
+            a.recalc_strength(evidence_count)
+            a.auto_classify(evidence_count)
+
+
+# --- CLI ---
+
+@click.group()
+def main():
+    """Liquid Loop — Workspace Cognitive Runtime v0.2"""
+    pass
+
+
+@main.command()
+def init():
+    """初始化 Liquid Loop 工作区"""
+    s = _load()
+    if s.anchors or s.evidences:
+        click.echo("工作区已初始化，无需重复操作。")
+        return
+    s.version = "0.2.0"
+    _save(s)
+    click.echo(f"✓ Liquid Loop v0.2 工作区已初始化: {WORKSPACE}/.liquid/")
+
+
+@main.command()
+def status():
+    """显示当前认知状态（含四维分类概览）"""
+    s = _load()
+    ent = calculate(s)
+    level = "GREEN" if ent < 0.3 else ("YELLOW" if ent < 0.6 else "RED")
+    latest_ev = max((e.timestamp for e in s.evidences), default="无活动")
+    click.echo(f"锚点: {len(s.anchors)} | 证据: {len(s.evidences)} | 记忆: {len(s.memories)} | 冲突: {len(s.conflicts)} | 关系: {len(s.relations)}")
+    click.echo(f"熵值: {ent:.4f} [{level}] | 最新活动: {latest_ev}")
+    click.echo(f"版本: {s.version}")
+
+
+@main.command()
+def anchor_list():
+    """列出所有锚点（含四维分类 + 价值衰减）"""
+    s = _load()
+    if not s.anchors:
+        click.echo("暂无锚点。使用 liquid anchor add <名称> <描述> 添加。")
+        return
+    for a in s.anchors:
+        a.decay_value()
+        bar = "█" * int(a.stability * 10) + "░" * (10 - int(a.stability * 10))
+        strength_bar = "■" * int(a.anchor_strength * 10) + "□" * (10 - int(a.anchor_strength * 10))
+        ev_count = len([e for e in s.evidences if e.anchor_id == a.id])
+        click.echo(
+            f"[{a.stability:.2f}] {bar}  {a.name}: {a.description[:50]}"
+        )
+        click.echo(
+            f"     分类: [{a.value_density}/{a.cognitive_stage}/{a.liquidity}] "
+            f"证据:{ev_count} 价值:{a.value_score:.2f} "
+            f"锚定:[{strength_bar}] {a.anchor_strength:.2f}"
+        )
+
+
+@main.command()
+@click.argument("anchor_name")
+@click.argument("content")
+@click.option("--quality", "-q", default="normal", help="证据质量: strong/normal/weak")
+def evidence_add(anchor_name, content, quality):
+    """为锚点添加证据"""
+    s = _load()
+    anchor = next((a for a in s.anchors if a.name == anchor_name), None)
+    if not anchor:
+        click.echo(f"锚点 '{anchor_name}' 不存在。请先创建。")
+        return
+    evidence = Evidence(
+        anchor_id=anchor.id,
+        content=content,
+        quality=quality if quality in ("strong", "normal", "weak") else "normal",
+    )
+    s.evidences.append(evidence)
+    anchor.evidence_ids.append(evidence.id)
+    _decay_evidence(s, anchor.id)
+    _recalc_stability(s, anchor.id)
+    _nucleate(s, anchor.id)
+    _save(s)
+    click.echo(f"✓ 证据已添加: [{anchor_name}] {content[:40]}... quality={evidence.quality}")
+
+
+@main.command()
+@click.option("--anchor", "-a", default=None, help="按锚点名称过滤")
+@click.option("--quality", "-q", default=None, help="按质量过滤: strong/normal/weak")
+def evidence_list(anchor, quality):
+    """列出证据"""
+    s = _load()
+    evs = s.evidences
+    if anchor:
+        a = next((x for x in s.anchors if x.name == anchor), None)
+        if not a:
+            click.echo(f"锚点 '{anchor}' 不存在。")
+            return
+        evs = [e for e in evs if e.anchor_id == a.id]
+        click.echo(f"--- {anchor} ---")
+    if quality:
+        evs = [e for e in evs if e.quality == quality]
+        click.echo(f"--- quality={quality} ---")
+    if not evs:
+        click.echo("暂无证据。")
+        return
+    for e in sorted(evs, key=lambda x: x.timestamp, reverse=True):
+        anchor_name = next((a.name for a in s.anchors if a.id == e.anchor_id), "?")
+        click.echo(f"[{e.weight:.2f}|{e.quality}] {e.timestamp[:19]} [{anchor_name}] {e.content}")
+
+
+@main.command()
+def memory_list():
+    """列出已形成的记忆"""
+    s = _load()
+    if not s.memories:
+        click.echo("暂无记忆。当同一锚点下有 2 条以上一致证据时自动成核。")
+        return
+    for m in sorted(s.memories, key=lambda x: x.confidence, reverse=True):
+        click.echo(f"[conf={m.confidence:.2f}] {m.formed_at[:19]} {m.content}")
+
+
+@main.command()
+@click.argument("source")
+@click.argument("target")
+@click.option("--type", "-t", "rel_type", default="relates_to",
+              help="关系类型: depends_on/relates_to/supersedes/conflicts_with")
+@click.option("--weight", "-w", default=1.0, help="关系强度 0.0~1.0")
+def relate(source, target, rel_type, weight):
+    """在两个锚点之间建立关系"""
+    s = _load()
+    src = next((a for a in s.anchors if a.name == source), None)
+    tgt = next((a for a in s.anchors if a.name == target), None)
+    if not src or not tgt:
+        click.echo("源或目标锚点不存在。")
+        return
+    # 去重
+    for r in s.relations:
+        if r.source_id == src.id and r.target_id == tgt.id:
+            click.echo(f"关系已存在: {source} → {target} [{r.relation_type}]")
+            return
+    rel = AnchorRelation(
+        source_id=src.id,
+        target_id=tgt.id,
+        relation_type=rel_type,
+        weight=min(max(weight, 0.0), 1.0),
+    )
+    s.relations.append(rel)
+    _save(s)
+    click.echo(f"✓ 关系已建立: {source} --[{rel_type}]--> {target}")
+
+
+@main.command()
+def relation_list():
+    """列出所有锚点关系"""
+    s = _load()
+    if not s.relations:
+        click.echo("暂无关系。使用 liquid relate 建立。")
+        return
+    name_map = {a.id: a.name for a in s.anchors}
+    for r in s.relations:
+        src = name_map.get(r.source_id, "?")
+        tgt = name_map.get(r.target_id, "?")
+        click.echo(f"{src} --[{r.relation_type}:{r.weight:.1f}]--> {tgt}")
+
+
+@main.command()
+def check():
+    """检查工作区熵值（六维）"""
+    s = _load()
+    ent = calculate(s)
+    if ent < 0.3:
+        level, icon = "GREEN", "✓"
+    elif ent < 0.6:
+        level, icon = "YELLOW", "⚠"
+    else:
+        level, icon = "RED", "✗"
+    click.echo(f"{icon} 熵值: {ent:.4f} [{level}]")
+    if ent >= 0.6:
+        click.echo("建议: 检查锚点漂移、添加新证据或解决冲突。")
+
+
+@main.command()
+def snapshot():
+    """保存当前状态快照"""
+    s = _load()
+    ent = calculate(s)
+    snap = StateSnapshot(
+        entropy=ent,
+        anchor_count=len(s.anchors),
+        evidence_count=len(s.evidences),
+        memory_count=len(s.memories),
+        conflict_count=len(s.conflicts),
+    )
+    s.snapshots.append(snap)
+    _save(s)
+    click.echo(f"✓ 快照已保存 (熵值: {ent:.4f})")
+
+
+@main.command()
+def snapshots():
+    """列出历史快照"""
+    s = _load()
+    if not s.snapshots:
+        click.echo("暂无快照。使用 liquid snapshot 保存。")
+        return
+    for i, snap in enumerate(s.snapshots):
+        click.echo(f"[{i}] {snap.timestamp[:19]}  熵={snap.entropy:.4f}  "
+                    f"A:{snap.anchor_count} E:{snap.evidence_count} "
+                    f"M:{snap.memory_count} C:{snap.conflict_count}")
+
+
+@main.command()
+def audit():
+    """查看审计链状态"""
+    s = _load()
+    ac = get_audit_chain(WORKSPACE)
+    click.echo(f"审计根哈希: {ac.root}")
+    click.echo(f"链长度: {len(ac._chain)}")
+    click.echo(f"当前state快照校验: anchors={len(s.anchors)} evidence={len(s.evidences)}")
+
+
+@main.command()
+def audit_log():
+    """查看审计日志"""
+    ac = get_audit_chain(WORKSPACE)
+    path = WORKSPACE / ".liquid" / "audit.log"
+    if not path.exists():
+        click.echo("审计日志为空。")
+        return
+    with open(path, "r") as f:
+        content = f.read().strip()
+    click.echo(content[-2000:] if len(content) > 2000 else content)
+
+
+@main.command()
+@click.argument("name")
+@click.argument("description")
+@click.option("--density", "-d", default="medium", help="价值密度: high/medium/low")
+@click.option("--stage", "-s", default="raw", help="认知阶段: raw/wip/crystallized/tooling")
+def anchor_add(name, description, density, stage):
+    """添加锚点（手动指定分类，支持 auto_classify 自动刷新）"""
+    s = _load()
+    if any(a.name == name for a in s.anchors):
+        click.echo(f"锚点 '{name}' 已存在。")
+        return
+    anchor = Anchor(
+        name=name,
+        description=description,
+        value_density=density if density in ("high", "medium", "low") else "medium",
+        cognitive_stage=stage if stage in ("raw", "wip", "crystallized", "tooling") else "raw",
+    )
+    # 自动分类：基于名称+描述
+    anchor.auto_classify(0)
+    s.anchors.append(anchor)
+    ac = get_audit_chain(WORKSPACE)
+    ac.append("anchor_add", f"{anchor.id}:{name}")
+    _save(s)
+    click.echo(f"✓ 锚点已添加: {name} ({anchor.id}) [{anchor.value_density}/{anchor.cognitive_stage}/{anchor.liquidity}]")
+
+
+if __name__ == "__main__":
+    main()

liquid_loop-0.3.0/liquid_loop/storage.py

@@ -0,0 +1,62 @@
+import json
+import os
+from pathlib import Path
+from dataclasses import asdict
+from .workspace import (
+    WorkspaceState, Anchor, Evidence, Memory,
+    Conflict, StateSnapshot, AnchorRelation, AuditChain, now,
+)
+
+
+LIQUID_DIR = ".liquid"
+STATE_FILE = "state.json"
+AUDIT_FILE = "audit.log"
+
+
+def _ensure_dir(workspace_root: Path) -> Path:
+    d = workspace_root / LIQUID_DIR
+    d.mkdir(exist_ok=True)
+    return d
+
+
+def get_audit_chain(workspace_root: Path) -> AuditChain:
+    """获取审计链实例"""
+    return AuditChain(str(_ensure_dir(workspace_root) / AUDIT_FILE))
+
+
+def load(workspace_root: Path) -> WorkspaceState:
+    path = _ensure_dir(workspace_root) / STATE_FILE
+    if not path.exists():
+        return WorkspaceState()
+    with open(path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    return _from_dict(data)
+
+
+def save(state: WorkspaceState, workspace_root: Path):
+    state.updated_at = now()
+    path = _ensure_dir(workspace_root) / STATE_FILE
+    data = asdict(state)
+    # 审计：每次保存记录state快照哈希
+    audit = get_audit_chain(workspace_root)
+    audit.append("state_save",
+        f"anchors={len(state.anchors)}_evidences={len(state.evidences)}"
+        f"_memories={len(state.memories)}_relations={len(state.relations)}"
+    )
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2, ensure_ascii=False)
+
+
+def _from_dict(data: dict) -> WorkspaceState:
+    return WorkspaceState(
+        anchors=[Anchor(**a) for a in data.get("anchors", [])],
+        evidences=[Evidence(**e) for e in data.get("evidences", [])],
+        memories=[Memory(**m) for m in data.get("memories", [])],
+        conflicts=[Conflict(**c) for c in data.get("conflicts", [])],
+        relations=[AnchorRelation(**r) for r in data.get("relations", [])],
+        snapshots=[StateSnapshot(**s) for s in data.get("snapshots", [])],
+        version=data.get("version", "0.3.0"),
+        updated_at=data.get("updated_at", ""),
+        audit_chain_hash=data.get("audit_chain_hash", "genesis"),
+        audit_prev_hash=data.get("audit_prev_hash", ""),
+    )

liquid_loop-0.3.0/liquid_loop/workspace.py

@@ -0,0 +1,248 @@
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Optional
+import uuid
+import hashlib
+import json
+import os
+
+
+def now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def uid() -> str:
+    return uuid.uuid4().hex[:12]
+
+
+# ========== 链式哈希审计（借鉴 KFG MemoryGovernance）==========
+
+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 append(self, event_type: str, data: str) -> str:
+        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:
+        """验证某条完整日志行是否匹配链中记录
+
+        格式: timestamp|chain_hash|event_type|data|prev_hash
+        """
+        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
+
+
+# --- 四维分类（借鉴 KFG 4D Classifier）---
+
+# 价值密度等级
+DensityLevel = str  # "high" | "medium" | "low"
+
+# 认知阶段
+CognitiveStage = str  # "raw" | "wip" | "crystallized" | "tooling"
+
+# 流动性等级
+LiquidityLevel = str  # "hot" | "warm" | "cold" | "frozen"
+
+
+@dataclass
+class Anchor:
+    id: str = field(default_factory=uid)
+    name: str = ""
+    description: str = ""
+    created_at: str = field(default_factory=now)
+
+    # 稳定性（原）
+    stability: float = 1.0       # 0.0=完全漂移, 1.0=完全稳定
+    evidence_ids: list[str] = field(default_factory=list)
+
+    # 【新增】四维分类标签（借鉴 KFG）
+    value_density: str = "medium"  # high | medium | low
+    cognitive_stage: str = "raw"   # raw | wip | crystallized | tooling
+    liquidity: str = "warm"        # hot | warm | cold | frozen
+
+    # 【新增】价值衰减指标（借鉴 KFG Factor.value 计算）
+    access_count: int = 0          # 被引用/访问次数
+    last_accessed: str = ""        # 最后访问时间
+    value_score: float = 1.0       # 衰减后价值（0.0~1.0）
+
+    # 【新增】锚定强度（基于证据支持度 + 访问活跃度）
+    anchor_strength: float = 1.0   # 0.0~1.0
+
+    def decay_value(self, factor: float = 0.95, evidence_count: int = 0) -> float:
+        """价值衰减计算（双因模型，借鉴 KFG MemoryGovernance.check_decay）
+
+        公式: score = freq_score × 0.4 + time_score × 0.6
+        - freq_score: 使用频率（证据数+访问次数），上限1.0
+        - time_score: 时间衰减（30天从1.0→0.0）
+        """
+        if not self.created_at:
+            return 0.0
+        try:
+            created = datetime.fromisoformat(self.created_at)
+        except ValueError:
+            return 0.0
+        now_dt = datetime.now(timezone.utc)
+        days = (now_dt - created).days
+
+        # 双因模型
+        freq_score = min((evidence_count * 0.12 + self.access_count * 0.08), 1.0)
+        time_score = max(0.0, 1.0 - days / 30)
+        raw = (freq_score * 0.4 + time_score * 0.6) * (factor ** max(days, 0))
+        self.value_score = max(0.0, min(1.0, raw))
+        return self.value_score
+
+    def recalc_strength(self, evidence_count: int) -> float:
+        """锚定强度 = 证据支持度 × 活跃度"""
+        evidence_factor = min(evidence_count / 5, 1.0)  # 5条证据满
+        activity = self.value_score
+        self.anchor_strength = evidence_factor * 0.6 + activity * 0.4
+        self.anchor_strength = max(0.0, min(1.0, self.anchor_strength))
+        return self.anchor_strength
+
+    def auto_classify(self, evidence_count: int) -> dict:
+        """自动推断四维分类标签（借鉴 KFG 4D Classifier 逻辑）
+
+        根据证据数量、锚定强度、活跃度自动调整：
+        - 价值密度: evidence多+强锚定 → high, 否则 low
+        - 认知阶段: 强锚定+高价值 → crystallized, 弱→raw
+        - 流动性: 最近有活动→hot, 否则→cold/frozen
+        """
+        self.decay_value(evidence_count=evidence_count)
+        self.recalc_strength(evidence_count)
+
+        # 价值密度
+        if self.anchor_strength > 0.8 and evidence_count >= 3:
+            self.value_density = "high"
+        elif self.anchor_strength > 0.4 or evidence_count >= 1:
+            self.value_density = "medium"
+        else:
+            self.value_density = "low"
+
+        # 认知阶段
+        if self.value_score > 0.7 and self.anchor_strength > 0.7:
+            self.cognitive_stage = "crystallized"
+        elif self.value_score > 0.4:
+            self.cognitive_stage = "wip"
+        elif evidence_count == 0:
+            self.cognitive_stage = "raw"
+        else:
+            self.cognitive_stage = "wip"
+
+        # 流动性
+        if self.last_accessed:
+            try:
+                last = datetime.fromisoformat(self.last_accessed)
+                gap_hours = (datetime.now(timezone.utc) - last).total_seconds() / 3600
+                if gap_hours < 24:
+                    self.liquidity = "hot"
+                elif gap_hours < 168:
+                    self.liquidity = "warm"
+                elif gap_hours < 720:
+                    self.liquidity = "cold"
+                else:
+                    self.liquidity = "frozen"
+            except ValueError:
+                pass
+
+        return {
+            "value_density": self.value_density,
+            "cognitive_stage": self.cognitive_stage,
+            "liquidity": self.liquidity,
+        }
+
+
+@dataclass
+class Evidence:
+    id: str = field(default_factory=uid)
+    anchor_id: str = ""
+    content: str = ""
+    timestamp: str = field(default_factory=now)
+    weight: float = 1.0          # 证据权重, 默认1.0
+
+    # 【新增】证据质量标签
+    quality: str = "normal"      # strong | normal | weak
+
+
+@dataclass
+class Memory:
+    id: str = field(default_factory=uid)
+    content: str = ""
+    formed_at: str = field(default_factory=now)
+    evidence_ids: list[str] = field(default_factory=list)  # 成核来源
+    confidence: float = 0.0      # 0.0-1.0, 基于证据一致性
+
+
+@dataclass
+class Conflict:
+    anchor_a: str = ""
+    anchor_b: str = ""
+    description: str = ""
+    detected_at: str = field(default_factory=now)
+    severity: float = 0.0        # 0.0-1.0
+
+
+# 【新增】锚点关系（借鉴 KFG Relation + 传递闭包）
+@dataclass
+class AnchorRelation:
+    source_id: str = ""
+    target_id: str = ""
+    relation_type: str = "relates_to"  # depends_on | relates_to | supersedes | conflicts_with
+    weight: float = 1.0               # 0.0~1.0
+    created_at: str = field(default_factory=now)
+
+
+@dataclass
+class StateSnapshot:
+    timestamp: str = field(default_factory=now)
+    entropy: float = 0.0
+    anchor_count: int = 0
+    evidence_count: int = 0
+    memory_count: int = 0
+    conflict_count: int = 0
+
+
+@dataclass
+class WorkspaceState:
+    anchors: list[Anchor] = field(default_factory=list)
+    evidences: list[Evidence] = field(default_factory=list)
+    memories: list[Memory] = field(default_factory=list)
+    conflicts: list[Conflict] = field(default_factory=list)
+    snapshots: list[StateSnapshot] = field(default_factory=list)
+    # 【新增】锚点关系
+    relations: list[AnchorRelation] = field(default_factory=list)
+    # 【新增】审计链哈希（每次 save 自动更新）
+    audit_chain_hash: str = "genesis"
+    audit_prev_hash: str = ""
+    version: str = "0.3.0"
+    updated_at: str = field(default_factory=now)

{liquid_loop-0.1.2 → liquid_loop-0.3.0}/liquid_loop.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liquid-loop
-Version: 0.1.2
+Version: 0.3.0
 Summary: Self-Organizing Cognitive Memory for AI Agents — Liquid Loop theory implementation
 Author: fishbook0001
 Maintainer: fishbook0001
@@ -123,27 +123,24 @@ save(state, Path("."))
 # 初始化工作区（创建 .liquid/state.json）
 liquid-loop init
 
-# 添加锚点
+# 添加锚点（支持自动四维分类）
 liquid-loop anchor_add "项目目标" "完成液环论文与开源"
 
 # 注入证据
 liquid-loop evidence_add "项目目标" "已完成 11 轮实验与 4 个实证包"
 
-# 查看状态
+# 查看状态（含审计链哈希）
 liquid-loop status
-# 输出:
-# ╭──────────────────────────────────────────────╮
-# │ Liquid Loop 认知状态                          │
-# ├──────────┬──────┬────────┬────────┬────────┬──┤
-# │ 锚点     │ 证据 │ 结晶   │ 冲突   │ 熵值   │  │
-# ├──────────┼──────┼────────┼────────┼────────┼──┤
-# │ 项目目标 │ 3    │ 1      │ 0      │ 0.2760 │ 🟢│
-# ╰──────────┴──────┴────────┴────────┴────────┴──╯
-# 锚点稳定性: 项目目标=0.88
 
 # 列出所有记忆结晶
 liquid-loop memory_list
 
+# 审计：验证链式哈希完整性
+liquid-loop audit
+
+# 查看审计日志（最近 20 条）
+liquid-loop audit-log --tail 20
+
 # 快照（记录当前认知基线）
 liquid-loop snapshot
 ```
@@ -194,10 +191,10 @@ Liquid Loop 是唯一完全自组织 + 零 LLM 管理的系统。
 liquid-loop/
 ├── liquid_loop/
 │   ├── __init__.py      # 公共 API 导出
-│   ├── workspace.py     # 核心数据模型
-│   ├── storage.py       # JSON 持久化
+│   ├── workspace.py     # 核心数据模型 + AuditChain + auto_classify + decay
+│   ├── storage.py       # JSON 持久化 + 审计链写入
 │   ├── entropy.py       # 四维熵值计算
-│   └── cli.py           # Click CLI (9 命令)
+│   └── cli.py           # Click CLI (11 命令)
 ├── examples/
 │   └── quickstart.py
 ├── tests/               # 待补充

{liquid_loop-0.1.2 → liquid_loop-0.3.0}/pyproject.toml

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

liquid_loop-0.1.2/liquid_loop/__init__.py

@@ -1,72 +0,0 @@
-"""
-Liquid Loop — Self-Organizing Cognitive Memory for AI Agents
-
-A zero-LLM-dependency cognitive runtime implementing the Liquid Loop theory:
-Anchor → Evidence → Memory Nucleation with four-dimensional entropy monitoring.
-
-Core Concepts:
-- Anchor: Cognitive focus points with stability tracking
-- Evidence: Observations that accumulate under anchors (exponential decay)
-- Memory: Crystallized knowledge from 2+ consistent evidences
-- Entropy: Four-dimensional cognitive health metric (drift/conflict/fragmentation/gap)
-
-Usage:
-    from liquid_loop import WorkspaceState, Anchor, Evidence, Memory
-    from liquid_loop import load, save, calculate_entropy
-    from liquid_loop.cli import main as cli_main
-
-    # Quick start
-    state = WorkspaceState()
-    anchor_id = state.add_anchor("核心使命", "系统的核心目标")
-    state.add_evidence(anchor_id, "用户偏好简洁输出")
-    state.add_evidence(anchor_id, "用户偏好简洁输出")  # 2次一致 -> 结晶
-    print(f"结晶记忆: {len(state.memories)} 条")
-
-CLI:
-    python -m liquid_loop init
-    python -m liquid_loop anchor_add "项目目标" "完成液环论文"
-    python -m liquid_loop evidence_add "项目目标" "已完成实证数据收集"
-    python -m liquid_loop status
-"""
-
-from liquid_loop.workspace import (
-    WorkspaceState,
-    Anchor,
-    Evidence,
-    Memory,
-    Conflict,
-    StateSnapshot,
-)
-
-from liquid_loop.storage import load, save, LIQUID_DIR, STATE_FILE
-
-from liquid_loop.entropy import calculate_entropy
-
-__version__ = "0.1.0"
-__author__ = "Fei Ge"
-__license__ = "MIT"
-
-__all__ = [
-    # Core data models
-    "WorkspaceState",
-    "Anchor",
-    "Evidence",
-    "Memory",
-    "Conflict",
-    "StateSnapshot",
-    # Persistence
-    "load",
-    "save",
-    "LIQUID_DIR",
-    "STATE_FILE",
-    # Entropy
-    "calculate_entropy",
-    "EntropyComponents",
-    # CLI
-    "cli_main",
-]
-
-# Lazy import CLI to avoid click dependency at import time
-def cli_main():
-    from liquid_loop.cli import main
-    return main()

liquid_loop-0.1.2/liquid_loop/cli.py

@@ -1,182 +0,0 @@
-import click
-from pathlib import Path
-from .workspace import (
-    WorkspaceState, Anchor, Evidence, Memory, StateSnapshot, now,
-    _nucleate, _decay_evidence, _recalc_stability,
-)
-from .storage import load, save
-from .entropy import calculate as calculate_entropy
-
-
-WORKSPACE = Path.cwd()
-
-
-def _load():
-    return load(WORKSPACE)
-
-
-def _save(state: WorkspaceState):
-    state.updated_at = now()
-    save(state, WORKSPACE)
-
-
-# --- CLI ---
-
-@click.group()
-def main():
-    """Liquid Loop — Workspace Cognitive Runtime"""
-    pass
-
-
-@main.command()
-def init():
-    """初始化 Liquid Loop 工作区"""
-    s = _load()
-    if s.anchors or s.evidences:
-        click.echo("工作区已初始化，无需重复操作。")
-        return
-    s.version = "0.1.0"
-    _save(s)
-    click.echo(f"✓ Liquid Loop 工作区已初始化: {WORKSPACE}/.liquid/")
-
-
-@main.command()
-def status():
-    """显示当前认知状态"""
-    s = _load()
-    ent = calculate_entropy(s)
-    level = "GREEN" if ent < 0.3 else ("YELLOW" if ent < 0.6 else "RED")
-    latest_ev = max((e.timestamp for e in s.evidences), default="无活动")
-    click.echo(f"锚点: {len(s.anchors)} | 证据: {len(s.evidences)} | 记忆: {len(s.memories)} | 冲突: {len(s.conflicts)}")
-    click.echo(f"熵值: {ent:.4f} [{level}] | 最新活动: {latest_ev}")
-
-
-@main.command()
-@click.argument("name")
-@click.argument("description")
-def anchor_add(name, description):
-    """添加锚点"""
-    s = _load()
-    # 同名检查
-    if any(a.name == name for a in s.anchors):
-        click.echo(f"锚点 '{name}' 已存在。")
-        return
-    anchor = Anchor(name=name, description=description)
-    s.anchors.append(anchor)
-    _save(s)
-    click.echo(f"✓ 锚点已添加: {name} ({anchor.id})")
-
-
-@main.command()
-def anchor_list():
-    """列出所有锚点"""
-    s = _load()
-    if not s.anchors:
-        click.echo("暂无锚点。使用 liquid anchor add <名称> <描述> 添加。")
-        return
-    for a in s.anchors:
-        bar = "█" * int(a.stability * 10) + "░" * (10 - int(a.stability * 10))
-        click.echo(f"[{a.stability:.2f}] {bar}  {a.name}: {a.description}")
-
-
-@main.command()
-@click.argument("anchor_name")
-@click.argument("content")
-def evidence_add(anchor_name, content):
-    """为锚点添加证据"""
-    s = _load()
-    anchor = next((a for a in s.anchors if a.name == anchor_name), None)
-    if not anchor:
-        click.echo(f"锚点 '{anchor_name}' 不存在。请先创建。")
-        return
-    evidence = Evidence(anchor_id=anchor.id, content=content)
-    s.evidences.append(evidence)
-    anchor.evidence_ids.append(evidence.id)
-    # 衰减 + 重算 + 成核
-    _decay_evidence(s, anchor.id)
-    _recalc_stability(s, anchor.id)
-    _nucleate(s, anchor.id)
-    _save(s)
-    click.echo(f"✓ 证据已添加: [{anchor_name}] {content[:40]}... ({evidence.id})")
-
-
-@main.command()
-@click.option("--anchor", "-a", default=None, help="按锚点名称过滤")
-def evidence_list(anchor):
-    """列出证据"""
-    s = _load()
-    evs = s.evidences
-    if anchor:
-        a = next((x for x in s.anchors if x.name == anchor), None)
-        if not a:
-            click.echo(f"锚点 '{anchor}' 不存在。")
-            return
-        evs = [e for e in evs if e.anchor_id == a.id]
-        click.echo(f"--- {anchor} ---")
-    if not evs:
-        click.echo("暂无证据。")
-        return
-    for e in sorted(evs, key=lambda x: x.timestamp, reverse=True):
-        anchor_name = next((a.name for a in s.anchors if a.id == e.anchor_id), "?")
-        click.echo(f"[{e.weight:.2f}] {e.timestamp[:19]} [{anchor_name}] {e.content}")
-
-
-@main.command()
-def memory_list():
-    """列出已形成的记忆"""
-    s = _load()
-    if not s.memories:
-        click.echo("暂无记忆。当同一锚点下有 2 条以上一致证据时自动成核。")
-        return
-    for m in sorted(s.memories, key=lambda x: x.confidence, reverse=True):
-        click.echo(f"[conf={m.confidence:.2f}] {m.formed_at[:19]} {m.content}")
-
-
-@main.command()
-def check():
-    """检查工作区熵值"""
-    s = _load()
-    ent = calculate_entropy(s)
-    if ent < 0.3:
-        level, icon = "GREEN", "✓"
-    elif ent < 0.6:
-        level, icon = "YELLOW", "⚠"
-    else:
-        level, icon = "RED", "✗"
-    click.echo(f"{icon} 熵值: {ent:.4f} [{level}]")
-    if ent >= 0.6:
-        click.echo("建议: 检查锚点漂移、添加新证据或解决冲突。")
-
-
-@main.command()
-def snapshot():
-    """保存当前状态快照"""
-    s = _load()
-    ent = calculate_entropy(s)
-    snap = StateSnapshot(
-        entropy=ent,
-        anchor_count=len(s.anchors),
-        evidence_count=len(s.evidences),
-        memory_count=len(s.memories),
-        conflict_count=len(s.conflicts),
-    )
-    s.snapshots.append(snap)
-    _save(s)
-    click.echo(f"✓ 快照已保存 (熵值: {ent:.4f})")
-
-
-@main.command()
-def snapshots():
-    """列出历史快照"""
-    s = _load()
-    if not s.snapshots:
-        click.echo("暂无快照。使用 liquid snapshot 保存。")
-        return
-    for i, snap in enumerate(s.snapshots):
-        click.echo(f"[{i}] {snap.timestamp[:19]}  熵={snap.entropy:.4f}  "
-                    f"A:{snap.anchor_count} E:{snap.evidence_count} "
-                    f"M:{snap.memory_count} C:{snap.conflict_count}")
-
-
-if __name__ == "__main__":
-    main()

liquid_loop-0.1.2/liquid_loop/storage.py

@@ -1,44 +0,0 @@
-import json
-import os
-from pathlib import Path
-from dataclasses import asdict
-from .workspace import WorkspaceState, Anchor, Evidence, Memory, Conflict, StateSnapshot
-
-
-LIQUID_DIR = ".liquid"
-STATE_FILE = "state.json"
-
-
-def _ensure_dir(workspace_root) -> Path:
-    if isinstance(workspace_root, str):
-        workspace_root = Path(workspace_root)
-    d = workspace_root / LIQUID_DIR
-    d.mkdir(exist_ok=True)
-    return d
-
-
-def load(workspace_root) -> WorkspaceState:
-    path = _ensure_dir(workspace_root) / STATE_FILE
-    if not path.exists():
-        return WorkspaceState()
-    with open(path, "r", encoding="utf-8") as f:
-        data = json.load(f)
-    return _from_dict(data)
-
-
-def save(state: WorkspaceState, workspace_root):
-    path = _ensure_dir(workspace_root) / STATE_FILE
-    with open(path, "w", encoding="utf-8") as f:
-        json.dump(asdict(state), f, indent=2, ensure_ascii=False)
-
-
-def _from_dict(data: dict) -> WorkspaceState:
-    return WorkspaceState(
-        anchors=[Anchor(**a) for a in data.get("anchors", [])],
-        evidences=[Evidence(**e) for e in data.get("evidences", [])],
-        memories=[Memory(**m) for m in data.get("memories", [])],
-        conflicts=[Conflict(**c) for c in data.get("conflicts", [])],
-        snapshots=[StateSnapshot(**s) for s in data.get("snapshots", [])],
-        version=data.get("version", "0.1.0"),
-        updated_at=data.get("updated_at", ""),
-    )

liquid_loop-0.1.2/liquid_loop/workspace.py

@@ -1,130 +0,0 @@
-from dataclasses import dataclass, field
-from datetime import datetime, timezone
-from typing import Optional
-import uuid
-from collections import Counter
-
-
-def now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-def uid() -> str:
-    return uuid.uuid4().hex[:12]
-
-
-# ── Liquid Loop Core Chain ──────────────────────────────────
-
-def _nucleate(state: "WorkspaceState", anchor_id: str):
-    """检查指定 Anchor 下的 Evidence，2+ 条则成核为 Memory"""
-    group = [e for e in state.evidences if e.anchor_id == anchor_id]
-    if len(group) < 2:
-        return
-    content_counts = Counter(e.content for e in group)
-    for content, count in content_counts.items():
-        if count >= 2:
-            existing = [m for m in state.memories if m.content == content]
-            if existing:
-                continue
-            evidence_ids = [e.id for e in group if e.content == content]
-            confidence = min(count / len(group), 1.0)
-            memory = Memory(
-                content=content,
-                evidence_ids=evidence_ids,
-                confidence=confidence,
-            )
-            state.memories.append(memory)
-
-
-def _decay_evidence(state: "WorkspaceState", anchor_id: str):
-    """Stability decay: 每次添加 Evidence 时，同 Anchor 下的旧 Evidence 权重衰减"""
-    for e in state.evidences:
-        if e.anchor_id == anchor_id:
-            e.weight = max(e.weight * 0.95, 0.1)
-
-
-def _recalc_stability(state: "WorkspaceState", anchor_id: str):
-    """基于证据权重更新 Anchor 稳定性"""
-    anchor = next((a for a in state.anchors if a.id == anchor_id), None)
-    if not anchor:
-        return
-    evs = [e for e in state.evidences if e.anchor_id == anchor_id]
-    if not evs:
-        anchor.stability = 1.0
-        return
-    # 稳定性 = 平均权重（权重越高越稳定）
-    anchor.stability = sum(e.weight for e in evs) / len(evs)
-
-
-@dataclass
-class Anchor:
-    id: str = field(default_factory=uid)
-    name: str = ""
-    description: str = ""
-    created_at: str = field(default_factory=now)
-    stability: float = 1.0       # 0.0=完全漂移, 1.0=完全稳定
-    evidence_ids: list[str] = field(default_factory=list)
-
-
-@dataclass
-class Evidence:
-    id: str = field(default_factory=uid)
-    anchor_id: str = ""
-    content: str = ""
-    timestamp: str = field(default_factory=now)
-    weight: float = 1.0          # 证据权重, 默认1.0
-
-
-@dataclass
-class Memory:
-    id: str = field(default_factory=uid)
-    content: str = ""
-    formed_at: str = field(default_factory=now)
-    evidence_ids: list[str] = field(default_factory=list)  # 成核来源
-    confidence: float = 0.0      # 0.0-1.0, 基于证据一致性
-
-
-@dataclass
-class Conflict:
-    anchor_a: str = ""
-    anchor_b: str = ""
-    description: str = ""
-    detected_at: str = field(default_factory=now)
-    severity: float = 0.0        # 0.0-1.0
-
-
-@dataclass
-class StateSnapshot:
-    timestamp: str = field(default_factory=now)
-    entropy: float = 0.0
-    anchor_count: int = 0
-    evidence_count: int = 0
-    memory_count: int = 0
-    conflict_count: int = 0
-
-
-@dataclass
-class WorkspaceState:
-    anchors: list[Anchor] = field(default_factory=list)
-    evidences: list[Evidence] = field(default_factory=list)
-    memories: list[Memory] = field(default_factory=list)
-    conflicts: list[Conflict] = field(default_factory=list)
-    snapshots: list[StateSnapshot] = field(default_factory=list)
-    version: str = "0.1.0"
-    updated_at: str = field(default_factory=now)
-
-    def add_anchor(self, name: str, description: str = "") -> str:
-        """添加锚点，返回 anchor_id"""
-        anchor = Anchor(name=name, description=description)
-        self.anchors.append(anchor)
-        return anchor.id
-
-    def add_evidence(self, anchor_id: str, content: str) -> str:
-        """添加证据到指定锚点，触发液环自动链：成核→衰减→稳定性重算"""
-        evidence = Evidence(anchor_id=anchor_id, content=content)
-        self.evidences.append(evidence)
-        # Liquid Loop 自动链
-        _nucleate(self, anchor_id)
-        _decay_evidence(self, anchor_id)
-        _recalc_stability(self, anchor_id)
-        return evidence.id