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

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

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

liquid_loop-0.5.2/liquid_loop/__init__.py

@@ -0,0 +1,9 @@
+"""Liquid Loop — Workspace Cognitive Runtime v0.5.1 (CPE-fused, proactive)"""
+__version__ = "0.5.2"
+
+from .workspace import (
+    WorkspaceState, Anchor, Evidence, Memory, Conflict,
+    AuditChain, CPERegularizer, SelfRefineEngine,
+)
+from .storage import load, save
+from .entropy import calculate, calculate_detail, calculate as calculate_entropy

liquid_loop-0.5.2/liquid_loop/__main__.py

@@ -0,0 +1,5 @@
+"""CLI entry point for liquid"""
+from .cli import main
+
+if __name__ == "__main__":
+    main()

{liquid_loop-0.3.0 → liquid_loop-0.5.2}/liquid_loop/cli.py

@@ -4,10 +4,11 @@ from collections import Counter
 from .workspace import (
     WorkspaceState, Anchor, Evidence, Memory, StateSnapshot,
     AnchorRelation, now, DensityLevel, CognitiveStage, LiquidityLevel,
+    SelfRefineEngine, meta_thinker_evaluate, meta_thinker_advice,
+    CPERegularizer,
 )
 from .storage import load, save, get_audit_chain
-from .entropy import calculate
-from .entropy import calculate
+from .entropy import calculate, calculate_detail
 
 
 WORKSPACE = Path.cwd()
@@ -68,7 +69,7 @@ def _recalc_stability(state: WorkspaceState, anchor_id: str):
 
 @click.group()
 def main():
-    """Liquid Loop — Workspace Cognitive Runtime v0.2"""
+    """Liquid Loop — Workspace Cognitive Runtime v0.5 (CPE-fused)"""
     pass
 
 
@@ -79,21 +80,26 @@ def init():
     if s.anchors or s.evidences:
         click.echo("工作区已初始化，无需重复操作。")
         return
-    s.version = "0.2.0"
+    s.version = "0.5.2"
     _save(s)
-    click.echo(f"✓ Liquid Loop v0.2 工作区已初始化: {WORKSPACE}/.liquid/")
+    click.echo(f"✓ Liquid Loop v0.5.1 工作区已初始化: {WORKSPACE}/.liquid/")
 
 
 @main.command()
 def status():
-    """显示当前认知状态（含四维分类概览）"""
+    """显示当前认知状态（CPE八维熵值）"""
     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}")
+    click.echo(f"CPE干预: {s.cpe_regularization_count}次 | 版本: {s.version}")
+
+    # 八维熵值快速
+    det = calculate_detail(s)
+    click.echo(f"  [原五维] 漂移{det['anchor_drift']:.2f} 冲突{det['conflict_density']:.2f} 碎片{det['evidence_fragmentation']:.2f} 活动{det['activity_gap']:.2f} 价值{det['value_decay']:.2f}")
+    click.echo(f"  [CPE三维] 回顾{det['cpe_retrospective_decay']:.2f} 漂移{det['cpe_behavioral_drift']:.2f} 泛化{det['cpe_generalization_erosion']:.2f}")
 
 
 @main.command()
@@ -116,6 +122,10 @@ def anchor_list():
             f"证据:{ev_count} 价值:{a.value_score:.2f} "
             f"锚定:[{strength_bar}] {a.anchor_strength:.2f}"
         )
+        if ev_count > 0:
+            evs = [e for e in s.evidences if e.anchor_id == a.id]
+            if evs:
+                click.echo(f"     最近证据: {evs[-1].content[:40]}...")
 
 
 @main.command()
@@ -225,18 +235,32 @@ def relation_list():
 
 @main.command()
 def check():
-    """检查工作区熵值（六维）"""
+    """检查工作区熵值（八维）"""
     s = _load()
-    ent = calculate(s)
+    det = calculate_detail(s)
+    ent = det["combined"]
     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}]")
+    click.echo(f"{icon} 综合熵值: {ent:.4f} [{level}]")
+
+    # 显示各维度贡献
+    click.echo(f"  ── 基础五维 ──")
+    click.echo(f"    锚点漂移:     {det['anchor_drift']:.4f}")
+    click.echo(f"    冲突密度:     {det['conflict_density']:.4f}")
+    click.echo(f"    证据碎片化:   {det['evidence_fragmentation']:.4f}")
+    click.echo(f"    活动间隔:     {det['activity_gap']:.4f}")
+    click.echo(f"    价值衰减:     {det['value_decay']:.4f}")
+    click.echo(f"    锚定强度:     {det['strength']:.4f}")
+    click.echo(f"  ── CPE 三维 ──")
+    click.echo(f"    回顾性衰退:   {det['cpe_retrospective_decay']:.4f}  {'⚠' if det['cpe_retrospective_decay'] > 0.3 else '✓'}")
+    click.echo(f"    策略漂移:     {det['cpe_behavioral_drift']:.4f}  {'⚠' if det['cpe_behavioral_drift'] > 0.3 else '✓'}")
+    click.echo(f"    泛化崩塌:     {det['cpe_generalization_erosion']:.4f}  {'⚠' if det['cpe_generalization_erosion'] > 0.3 else '✓'}")
     if ent >= 0.6:
-        click.echo("建议: 检查锚点漂移、添加新证据或解决冲突。")
+        click.echo("建议: 运行 cpe-scan 检查能力侵蚀详情，或添加新证据降低熵值。")
 
 
 @main.command()
@@ -280,7 +304,8 @@ def audit():
 
 
 @main.command()
-def audit_log():
+@click.option("--tail", "-n", default=None, type=int, help="仅显示最后 N 行日志")
+def audit_log(tail):
     """查看审计日志"""
     ac = get_audit_chain(WORKSPACE)
     path = WORKSPACE / ".liquid" / "audit.log"
@@ -288,7 +313,10 @@ def audit_log():
         click.echo("审计日志为空。")
         return
     with open(path, "r") as f:
-        content = f.read().strip()
+        lines = f.readlines()
+    if tail:
+        lines = lines[-tail:]
+    content = "".join(lines)
     click.echo(content[-2000:] if len(content) > 2000 else content)
 
 
@@ -318,5 +346,178 @@ def anchor_add(name, description, density, stage):
     click.echo(f"✓ 锚点已添加: {name} ({anchor.id}) [{anchor.value_density}/{anchor.cognitive_stage}/{anchor.liquidity}]")
 
 
+@main.command()
+@click.option("--evidence", "-e", default=None, help="只探测指定锚点的证据（逗号分隔锚点名）")
+def self_refine(evidence):
+    """后向自进化：探测QA验证 + 证据锚定修复（借鉴MemMA原位自进化）"""
+    s = _load()
+    engine = SelfRefineEngine(s)
+
+    evidence_ids = None
+    if evidence:
+        names = [n.strip() for n in evidence.split(",")]
+        evidence_ids = []
+        for name in names:
+            anchor = next((a for a in s.anchors if a.name == name), None)
+            if anchor:
+                evidence_ids.extend([e.id for e in s.evidences if e.anchor_id == anchor.id])
+
+    result = engine.run(evidence_ids)
+
+    if result.get("message"):
+        click.echo(f"⚠ {result['message']}")
+        return
+
+    click.echo(f"━━━ 后向自进化报告 ━━━")
+    click.echo(f"  探测总数: {result['total']}")
+    click.echo(f"  通过: {result['passed']}")
+    click.echo(f"  失败: {result['failed']}")
+    click.echo(f"  通过率: {result['pass_rate']:.0%}")
+
+    if result.get("repairs"):
+        click.echo(f"\n━━━ 修复操作 ━━━")
+        for r in result["repairs"]:
+            click.echo(f"  {r}")
+
+    if result.get("failed_details"):
+        click.echo(f"\n━━━ 失败明细（前5条）━━━")
+        for d in result["failed_details"]:
+            click.echo(f"  Q: {d['q']}")
+            click.echo(f"  → {d['reason']}")
+
+    # 保存
+    _save(s)
+    click.echo(f"\n✓ 已保存，累计修复: {s.self_refine_repair_count} 次")
+
+
+@main.command()
+def strategy_health():
+    """策略健康度检查（借鉴MemMA Meta-Thinker）"""
+    s = _load()
+    result = meta_thinker_evaluate(s)
+
+    status = "✓ 健康" if result["healthy"] else "✗ 异常"
+    click.echo(f"━━━ 策略健康度: {status} ━━━")
+    click.echo(f"  熵值: {result['entropy']:.4f}")
+
+    if result["issues"]:
+        for issue in result["issues"]:
+            icon = "⚠" if issue["severity"] == "warning" else "✗"
+            click.echo(f"  {icon} [{issue['severity']}] {issue['issue']}")
+            if "anchors" in issue:
+                click.echo(f"    涉及: {', '.join(issue['anchors'])}")
+    else:
+        click.echo("  无问题")
+
+
+@main.command()
+@click.argument("anchor_name")
+@click.argument("new_evidence")
+def strategy_advice(anchor_name, new_evidence):
+    """策略建议：评估新证据是否应该添加到指定锚点（借鉴MemMA Meta-Thinker）"""
+    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
+    result = meta_thinker_advice(anchor, s, new_evidence)
+    click.echo(f"━━━ 策略建议 ━━━")
+    click.echo(f"  锚点: {anchor_name}")
+    click.echo(f"  新证据: {new_evidence[:60]}...")
+    click.echo(f"  建议: [{result['action']}]")
+    click.echo(f"  原因: {result['reason']}")
+    if "suggestion" in result:
+        click.echo(f"  提示: {result['suggestion']}")
+
+
+# ==============================================================================
+# 【v0.5.0】CPE 正则化命令（借鉴 UIUC CPE 论文 arXiv:2605.09315）
+# ==============================================================================
+
+@main.command()
+@click.argument("anchor_name")
+@click.argument("new_evidence")
+@click.option("--force", "-f", is_flag=True, help="强制通过（跳过BLOCK降为FLAG）")
+def cpe_check(anchor_name, new_evidence, force):
+    """CPE 正则化检查：评估新证据对锚点的能力侵蚀风险"""
+    s = _load()
+    regularizer = CPERegularizer(s)
+    result = regularizer.regularize(anchor_name, new_evidence, force=force)
+    action = result["action"]
+    icon = "✓" if action == "PASS" else ("!" if action == "FLAG" else "✗")
+    click.echo(f"━━━ CPE 正则化检查 ━━━")
+    click.echo(f"  锚点: {anchor_name}")
+    click.echo(f"  新证据: {new_evidence[:60]}...")
+    click.echo(f"  判定: [{icon} {action}]  风险评分: {result.get('score', 0):.3f}")
+    if result.get("reasons"):
+        for r in result["reasons"]:
+            click.echo(f"  原因: {r}")
+    if result.get("details"):
+        d = result["details"]
+        click.echo(f"\n  详情:")
+        click.echo(f"    与现有证据最大重叠: {d.get('max_overlap', 0):.3f}")
+        click.echo(f"    与锚点方向偏离: {d.get('drift_score', 0):.3f}")
+        click.echo(f"    保护权重(证据越多越敏感): {d.get('protection_weight', 0):.3f}")
+    _save(s)
+
+
+@main.command()
+def cpe_scan():
+    """CPE 能力侵蚀扫描：检测全工作区的能力侵蚀信号"""
+    s = _load()
+    regularizer = CPERegularizer(s)
+    warnings = regularizer.scan_erosion()
+
+    click.echo(f"━━━ CPE 能力侵蚀扫描 ━━━")
+    if not warnings:
+        click.echo("  无能力侵蚀信号 ✓")
+    else:
+        click.echo(f"  发现 {len(warnings)} 条侵蚀信号:")
+        for w in warnings:
+            icon = "⚠" if w["severity"] == "medium" else "🔴"
+            click.echo(f"  {icon} [{w['type']}] {w['anchor']}: {w['detail']}")
+
+    click.echo(f"\n  正则化累计干预: {s.cpe_regularization_count} 次")
+    if s.blocked_evidences:
+        click.echo(f"  最近拦截记录 ({len(s.blocked_evidences)}):")
+        for b in s.blocked_evidences[-5:]:
+            click.echo(f"    ⛔ {b}")
+    _save(s)
+
+
+@main.command()
+def cpe_status():
+    """CPE 状态概览：显示当前能力保留状态"""
+    s = _load()
+    click.echo(f"━━━ CPE 正则化状态 ━━━")
+    click.echo(f"  正则化累计干预: {s.cpe_regularization_count} 次")
+    click.echo(f"  已通过检查的证据: {len(s.regularized_evidences)}")
+    click.echo(f"  被拦截/标记的证据: {len(s.blocked_evidences)}")
+    if s.cpe_erosion_warnings:
+        click.echo(f"  活跃侵蚀告警: {len(s.cpe_erosion_warnings)} 条")
+        for w in s.cpe_erosion_warnings:
+            icon = "⚠" if w["severity"] == "medium" else "🔴"
+            click.echo(f"    {icon} [{w['type']}] {w['anchor']}: {w['detail']}")
+    else:
+        click.echo(f"  活跃侵蚀告警: 无")
+
+    # 八维熵值详情
+    from .entropy import calculate_detail
+    det = calculate_detail(s)
+    click.echo(f"\n━━━ 八维熵值详情 ━━━")
+    click.echo(f"  综合熵: {det['combined']:.4f}")
+    click.echo(f"  ── 基础五维 ──")
+    click.echo(f"    锚点漂移:           {det['anchor_drift']:.4f}")
+    click.echo(f"    冲突密度:           {det['conflict_density']:.4f}")
+    click.echo(f"    证据碎片化:         {det['evidence_fragmentation']:.4f}")
+    click.echo(f"    活动间隔:           {det['activity_gap']:.4f}")
+    click.echo(f"    价值衰减:           {det['value_decay']:.4f}")
+    click.echo(f"    锚定强度:           {det['strength']:.4f}")
+    click.echo(f"  ── CPE 三维 ──")
+    click.echo(f"    回顾性衰退(CPE):    {det['cpe_retrospective_decay']:.4f}")
+    click.echo(f"    策略漂移(CPE):      {det['cpe_behavioral_drift']:.4f}")
+    click.echo(f"    泛化崩塌(CPE):      {det['cpe_generalization_erosion']:.4f}")
+
+
 if __name__ == "__main__":
     main()

liquid_loop-0.5.2/liquid_loop/entropy.py

@@ -0,0 +1,212 @@
+from datetime import datetime, timezone, timedelta
+from .workspace import WorkspaceState
+
+
+def anchor_drift(state: WorkspaceState) -> float:
+    """所有 Anchor 的 stability 偏离 1.0 的均值。0=全稳, 1=全漂"""
+    if not state.anchors:
+        return 0.0
+    return sum(1.0 - a.stability for a in state.anchors) / len(state.anchors)
+
+
+def conflict_density(state: WorkspaceState) -> float:
+    """冲突密度。0=无冲突, 1=每锚点一个冲突"""
+    if not state.anchors:
+        return 0.0
+    return min(len(state.conflicts) / len(state.anchors), 1.0)
+
+
+def evidence_fragmentation(state: WorkspaceState) -> float:
+    """孤立 Evidence 占比。0=全部有同伴, 1=全部孤立"""
+    if not state.evidences:
+        return 0.0
+    groups: dict[str, int] = {}
+    for e in state.evidences:
+        groups[e.anchor_id] = groups.get(e.anchor_id, 0) + 1
+    orphaned = sum(1 for count in groups.values() if count == 1)
+    return orphaned / len(groups) if groups else 0.0
+
+
+def activity_gap(state: WorkspaceState) -> float:
+    """距最新 Evidence 的天数。0=今天有活动, 1=超过7天无活动"""
+    if not state.evidences:
+        return 1.0
+    latest = max(e.timestamp for e in state.evidences)
+    try:
+        latest_dt = datetime.fromisoformat(latest)
+    except ValueError:
+        return 1.0
+    gap = datetime.now(timezone.utc) - latest_dt
+    return min(gap / timedelta(days=7), 1.0)
+
+
+# 【借鉴KFG】四维熵值分量
+
+def value_decay_entropy(state: WorkspaceState) -> float:
+    """锚点价值衰减熵。0=全部高价值, 1=全部低价值 — 纯函数，不改 state"""
+    if not state.anchors:
+        return 0.0
+    scores = []
+    for a in state.anchors:
+        evs = [e for e in state.evidences if e.anchor_id == a.id]
+        # 快照+还原，保证不修改 state
+        orig_score = a.value_score
+        orig_strength = a.anchor_strength
+        score = a.decay_value(evidence_count=len(evs))
+        a.value_score = orig_score
+        a.anchor_strength = orig_strength
+        scores.append(score)
+    return 1.0 - (sum(scores) / len(scores))
+
+
+def strength_entropy(state: WorkspaceState) -> float:
+    """锚定强度熵。0=全部强锚定, 1=全部弱锚定 — 纯函数，不改 state"""
+    if not state.anchors:
+        return 0.0
+    strengths = [a.anchor_strength for a in state.anchors]
+    return 1.0 - (sum(strengths) / len(strengths))
+
+
+# ==============================================================================
+# 【新增 v0.5.0】CPE 能力侵蚀检测 — 借鉴 UIUC CPE 论文 (arXiv:2605.09315)
+#
+# CPE 能力侵蚀三大表现（§1）：
+#   1. 回顾性衰退（Retrospective decay）：新证据覆盖旧锚点 → value_score 断崖
+#   2. 策略漂移（Behavioral drift）：锚点属性突变 → stability 在单次更新中大幅波动
+#   3. 泛化崩塌（Generalization erosion）：证据之间一致性下降 → cognitive_stage 降级
+# ==============================================================================
+
+def retrospective_decay_entropy(state: WorkspaceState) -> float:
+    """回顾性衰退熵。0=无衰退, 1=大规模衰退（CPE §1: Retrospective decay）
+
+    纯函数快照，不改 state。每锚点计算最新 vs 次新证据的 value_score 变化比。
+    """
+    if not state.anchors or not state.evidences:
+        return 0.0
+    decay_scores = []
+    for a in state.anchors:
+        evs = sorted(
+            [e for e in state.evidences if e.anchor_id == a.id],
+            key=lambda x: x.timestamp, reverse=True
+        )
+        if len(evs) < 2:
+            continue
+        # 快照原始值
+        orig_score = a.value_score
+        orig_strength = a.anchor_strength
+        # 最新证据时的 score
+        new_score = a.decay_value(evidence_count=len(evs))
+        new_score_val = a.value_score
+        # 少一条证据时的 score（传参模式，不依赖 state 缓存）
+        old_score = a.decay_value(evidence_count=len(evs) - 1)
+        # 还原 state
+        a.value_score = orig_score
+        a.anchor_strength = orig_strength
+        if old_score > 0:
+            ratio = max(0, 1 - new_score_val / old_score)
+            decay_scores.append(ratio)
+    return sum(decay_scores) / len(decay_scores) if decay_scores else 0.0
+
+
+def behavioral_drift_entropy(state: WorkspaceState) -> float:
+    """策略漂移熵。0=无漂移, 1=剧烈漂移（CPE §1: Behavioral policy drift）
+
+    纯函数快照，不改 state。测量锚点 stability 在最近一次更新中的变化幅度。
+    """
+    if not state.anchors:
+        return 0.0
+    drifts = []
+    for a in state.anchors:
+        evs = [e for e in state.evidences if e.anchor_id == a.id]
+        if len(evs) < 2:
+            continue
+        evs_sorted = sorted(evs, key=lambda x: x.timestamp, reverse=True)
+        # 快照原始值
+        orig_strength = a.anchor_strength
+        # 模拟有/无最新证据时的 stability 差
+        old_count = len(evs_sorted) - 1
+        new_count = len(evs_sorted)
+        old_strength = a.recalc_strength(old_count)
+        new_strength = a.recalc_strength(new_count)
+        drifts.append(abs(new_strength - old_strength))
+        # 还原
+        a.anchor_strength = orig_strength
+    return sum(drifts) / len(drifts) if drifts else 0.0
+
+
+def generalization_erosion_entropy(state: WorkspaceState) -> float:
+    """泛化崩塌熵。0=一致性高, 1=完全不一致（CPE §1: Generalization erosion）
+
+    测量逻辑：同锚点下证据之间的关键词重叠度越低→一致性越差→崩塌风险越高。
+    """
+    if not state.anchors:
+        return 0.0
+    erosion_scores = []
+    for a in state.anchors:
+        evs = [e for e in state.evidences if e.anchor_id == a.id]
+        if len(evs) < 2:
+            continue
+        # 两两计算重叠度
+        overlaps = []
+        for i in range(len(evs)):
+            for j in range(i + 1, len(evs)):
+                if evs[i].content and evs[j].content:
+                    from .workspace import _keyword_overlap
+                    overlaps.append(_keyword_overlap(evs[i].content, evs[j].content))
+        if overlaps:
+            avg_overlap = sum(overlaps) / len(overlaps)
+            # 重叠度越低 → 崩塌熵越高
+            erosion_scores.append(1.0 - avg_overlap)
+    return sum(erosion_scores) / len(erosion_scores) if erosion_scores else 0.0
+
+
+def cpe_dimension_entropy(state: WorkspaceState) -> dict:
+    """CPE 三维能力侵蚀熵汇总。"""
+    return {
+        "retrospective_decay": retrospective_decay_entropy(state),
+        "behavioral_drift": behavioral_drift_entropy(state),
+        "generalization_erosion": generalization_erosion_entropy(state),
+    }
+
+
+# ==============================================================================
+# 综合熵值（八维加权 — CPE三维 + 原六维去重后五维 = 八维）
+# ==============================================================================
+
+def calculate(state: WorkspaceState,
+              w_drift: float = 0.15, w_conflict: float = 0.10,
+              w_frag: float = 0.10, w_gap: float = 0.10,
+              w_decay: float = 0.10, w_strength: float = 0.10,
+              w_retro: float = 0.15, w_behavior: float = 0.10,
+              w_generalize: float = 0.10) -> float:
+    """综合熵值 0.0-1.0（八维加权 — 新增CPE三维）
+
+    CPE 三维权重合计 0.35，与原五维（0.65）形成均衡。
+    """
+    return (
+        w_drift * anchor_drift(state) +
+        w_conflict * conflict_density(state) +
+        w_frag * evidence_fragmentation(state) +
+        w_gap * activity_gap(state) +
+        w_decay * value_decay_entropy(state) +
+        w_strength * strength_entropy(state) +
+        w_retro * retrospective_decay_entropy(state) +
+        w_behavior * behavioral_drift_entropy(state) +
+        w_generalize * generalization_erosion_entropy(state)
+    )
+
+
+def calculate_detail(state: WorkspaceState) -> dict:
+    """返回八维详细熵值（用于 display 和诊断）"""
+    return {
+        "anchor_drift": anchor_drift(state),
+        "conflict_density": conflict_density(state),
+        "evidence_fragmentation": evidence_fragmentation(state),
+        "activity_gap": activity_gap(state),
+        "value_decay": value_decay_entropy(state),
+        "strength": strength_entropy(state),
+        "cpe_retrospective_decay": retrospective_decay_entropy(state),
+        "cpe_behavioral_drift": behavioral_drift_entropy(state),
+        "cpe_generalization_erosion": generalization_erosion_entropy(state),
+        "combined": calculate(state),
+    }

{liquid_loop-0.3.0 → liquid_loop-0.5.2}/liquid_loop/storage.py

@@ -36,13 +36,15 @@ def load(workspace_root: Path) -> WorkspaceState:
 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",
+    audit_hash = audit.append("state_save",
         f"anchors={len(state.anchors)}_evidences={len(state.evidences)}"
         f"_memories={len(state.memories)}_relations={len(state.relations)}"
     )
+    state.audit_prev_hash = state.audit_chain_hash
+    state.audit_chain_hash = audit_hash
+    data = asdict(state)
     with open(path, "w", encoding="utf-8") as f:
         json.dump(data, f, indent=2, ensure_ascii=False)
 
@@ -55,8 +57,11 @@ def _from_dict(data: dict) -> WorkspaceState:
         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"),
+        version=data.get("version", "0.4.0"),
         updated_at=data.get("updated_at", ""),
         audit_chain_hash=data.get("audit_chain_hash", "genesis"),
         audit_prev_hash=data.get("audit_prev_hash", ""),
+        self_refine_probes=data.get("self_refine_probes", []),
+        self_refine_results=data.get("self_refine_results", []),
+        self_refine_repair_count=data.get("self_refine_repair_count", 0),
     )