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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liquid-loop
-Version: 2.0.0
+Version: 2.0.2
 Summary: Self-Organizing Cognitive Memory for AI Agents — Liquid Loop theory implementation
 Author: fishbook0001
 Maintainer: fishbook0001
@@ -43,7 +43,7 @@ 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` 为记忆层数据格式版本，独立于包发布版本）。
+> **当前包版本：`2.0.1`**（2026-08-25 零向量召回超越词频基线，详见 [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/)

{liquid_loop-2.0.0 → liquid_loop-2.0.2}/README.md

@@ -4,7 +4,7 @@
 
 > **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` 为记忆层数据格式版本，独立于包发布版本）。
+> **当前包版本：`2.0.1`**（2026-08-25 零向量召回超越词频基线，详见 [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/)

{liquid_loop-2.0.0 → liquid_loop-2.0.2}/liquid_loop/__init__.py

@@ -1,11 +1,11 @@
-"""Liquid Loop — Workspace Cognitive Runtime v2.0.0 (禁向量·活态液态神经网络：成核门槛/反证轨/老化回收/原理优先成核/因果演化/软取代supersede+治理查询state_at/impact/duplicates+程序性记忆层procedural_memory+PerceptionGate因果共生门控)"""
-__version__ = "2.0.0"
+"""Liquid Loop — Workspace Cognitive Runtime v2.0.1 (禁向量·活态液态神经网络：成核门槛/反证轨/老化回收/原理优先成核/因果演化/软取代supersede+治理查询state_at/impact/duplicates+程序性记忆层procedural_memory+PerceptionGate因果共生门控)"""
+__version__ = "2.0.2"
 
 from .workspace import (
     WorkspaceState, Anchor, Evidence, Memory, Conflict,
     AuditChain, CPERegularizer, SelfRefineEngine,
 )
-from .storage import load, save, locked_state
+from .storage import load, save, locked_state, StateRegressionGuardError
 from .entropy import calculate, calculate_detail, calculate as calculate_entropy
 from .selfspin import LiquidSelfSpin
 from .liquid_reweight import LiquidReweight
@@ -16,7 +16,8 @@ from .procedural_memory import (
     ProceduralMemory, ProceduralRegistry, procmem_recall, procmem_admit,
 )
 # 蒸馏落地的公共原语（零侵入，供 cli / server / agent loop 接入）
-from .guard import should_escalate, confirm_gate, CapabilityMenu
+from .guard import should_escalate, confirm_gate, CapabilityMenu, PerceptionGate
+from .dsh_reversible import ReversibleRegistry  # 可逆副作用底座（蒸馏 DeepSeek Harness #204，2026-08-28 接活）
 from .session import SessionState, mark_abort, recover, save_session, load_session
 from .recall_filter import adaptive_recall
 from .rar import RARIndex, build_or_cache  # 公共检索 API（原 workspace 局部 import）

liquid_loop-2.0.2/liquid_loop/dsh_reversible.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+dsh_reversible.py — Cordis 可逆副作用（Disposable Pattern）零依赖原语
+==============================================================================
+蒸馏自 DeepSeek Harness #204（2026-08-14 一手核验），2026-08-28 接活进液环运行时。
+
+Cordis 的核心机制（Koishi/Shigma 元框架，DeepSeek vendored + 北大联合扩展）：
+  - 每个插件运行在一个 Context 里，凡是它"占用的东西"都挂在 Context 上
+  - dispose 时按"子先于父、注册逆序"自动撤销全部副作用
+  - 副作用全追踪、卸载自动回滚、生命周期包含（provider 比 consumer 活得久）
+
+本原语把它极简成可被液环/vera 脚本 import 的通用"可回滚状态变更"底座：
+  register() 登记一个副作用 + 其撤销函数 → dispose() 时自动按序回滚。
+
+与液环同构：append-only + supersede/tombstone（软删除可回滚）↔ 可逆副作用；
+  "no privileged core" ↔ 本原语无特权对象，全部副作用一视同仁可回滚。
+与 Vera 红线#1 safe_rm 同构：删除/移动先登记 undo，dispose 时 mv 回原位即无损回滚。
+
+依赖：仅 Python 标准库。零外部依赖。
+接活范式（08-12 三段式）：挂模块 + __init__ 暴露 + 自测 → server 经 liquid_loop 包 import。
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable, List
+
+
+@dataclass
+class _Effect:
+    """一个已登记的副作用：apply 时的动作名 + 撤销回调。"""
+    label: str
+    undo: Callable[[], None]
+
+
+class ReversibleRegistry:
+    """
+    可逆副作用注册表（Cordis Context 的最小实现）。
+
+    语义：
+      - register(label, undo) 登记副作用；dispose() 按注册逆序回滚。
+      - child() 派生子作用域；父 dispose 前先 dispose 全部子作用域（子先于父）。
+      - require(other) 声明"我依赖 other"（生命周期包含）：
+        被依赖方 dispose 前，先 dispose 依赖它的注册表（provider 活得比 consumer 久）。
+      - dispose() 幂等；重复调用安全。
+      - 无特权对象：本类不做任何"特殊保护"，一切副作用同等可回滚。
+
+    设计约束（蒸馏铁律）：
+      - 只处理"可逆副作用"，不实现事件总线/依赖注入容器——那是 Cordis 的其余部分，
+        需要时另行蒸馏。保持单文件、零依赖、可独立测试。
+    """
+
+    def __init__(self, name: str = "root") -> None:
+        self.name = name
+        self._effects: List[_Effect] = []
+        self._children: List["ReversibleRegistry"] = []
+        self._dependents: List["ReversibleRegistry"] = []  # 依赖我的注册表
+        self._disposed = False
+
+    # ---- 登记与派生 ----
+
+    def register(self, label: str, undo: Callable[[], None]) -> None:
+        """登记一个副作用及其撤销回调。dispose 时按注册逆序调用 undo。"""
+        self._ensure_alive()
+        self._effects.append(_Effect(label=label, undo=undo))
+
+    def child(self, name: str) -> "ReversibleRegistry":
+        """派生子作用域。父 dispose 前先 dispose 全部子作用域（子先于父）。"""
+        self._ensure_alive()
+        c = ReversibleRegistry(name=f"{self.name}/{name}")
+        self._children.append(c)
+        return c
+
+    def require(self, provider: "ReversibleRegistry") -> None:
+        """
+        生命周期包含：本注册表依赖 provider。
+        provider 被 dispose 前，会先 dispose 所有声明依赖它的注册表（consumer）。
+        避免"提供者已卸载、消费者还在调用"的悬空引用。
+        """
+        self._ensure_alive()
+        provider._dependents.append(self)
+
+    # ---- 回滚 ----
+
+    def dispose(self) -> None:
+        """按顺序回滚：依赖我的（consumer）→ 子作用域 → 自身副作用（注册逆序）。幂等。"""
+        if self._disposed:
+            return
+        self._disposed = True
+        for dep in reversed(self._dependents):
+            dep.dispose()
+        for c in reversed(self._children):
+            c.dispose()
+        for e in reversed(self._effects):
+            try:
+                e.undo()
+            except Exception as exc:  # 单条撤销失败不阻断整体回滚
+                print(f"[{self.name}] undo({e.label}) 失败: {exc!r}")
+        self._effects.clear()
+
+    def _ensure_alive(self) -> None:
+        if self._disposed:
+            raise RuntimeError(f"registry '{self.name}' 已 dispose，禁止再登记副作用")
+
+    # ---- 上下文管理（with 语句自动回滚） ----
+
+    def __enter__(self) -> "ReversibleRegistry":
+        return self
+
+    def __exit__(self, *exc) -> None:
+        self.dispose()
+
+    # ---- 只读状态 ----
+
+    @property
+    def disposed(self) -> bool:
+        return self._disposed
+
+    @property
+    def effect_count(self) -> int:
+        return len(self._effects)
+
+    def __repr__(self) -> str:
+        return (f"ReversibleRegistry(name={self.name!r}, effects={len(self._effects)}, "
+                f"children={len(self._children)}, disposed={self._disposed})")
+
+
+# ---------------------------------------------------------------------------
+# 自测（运行时验证）
+# ---------------------------------------------------------------------------
+def _selftest() -> None:
+    log: List[str] = []
+
+    # 1. 基本可逆：注册逆序回滚
+    r = ReversibleRegistry("base")
+    r.register("a", lambda: log.append("undo-a"))
+    r.register("b", lambda: log.append("undo-b"))
+    r.dispose()
+    assert log == ["undo-b", "undo-a"], f"逆序回滚失败: {log}"
+    r.dispose()  # 幂等
+    print("✓ 基本可逆 + 幂等")
+
+    # 2. 子先于父
+    log.clear()
+    r = ReversibleRegistry("root")
+    r.register("root-e", lambda: log.append("undo-root"))
+    c = r.child("sub")
+    c.register("sub-e", lambda: log.append("undo-sub"))
+    r.dispose()
+    assert log == ["undo-sub", "undo-root"], f"子先于父失败: {log}"
+    print("✓ 子先于父回滚")
+
+    # 3. 生命周期包含：provider 先卸 consumer
+    log.clear()
+    provider = ReversibleRegistry("provider")
+    consumer = ReversibleRegistry("consumer")
+    consumer.require(provider)  # consumer 依赖 provider
+    provider.register("p", lambda: log.append("undo-provider"))
+    consumer.register("c", lambda: log.append("undo-consumer"))
+    provider.dispose()
+    assert log == ["undo-consumer", "undo-provider"], f"生命周期包含失败: {log}"
+    print("✓ 生命周期包含（consumer 先于 provider 回滚）")
+
+    # 4. with 语句自动回滚
+    log.clear()
+    with ReversibleRegistry("ctx") as ctx:
+        ctx.register("x", lambda: log.append("undo-x"))
+    assert log == ["undo-x"], f"with 自动回滚失败: {log}"
+    print("✓ with 语句自动回滚")
+
+    # 5. 单条撤销失败不阻断整体
+    log.clear()
+    r = ReversibleRegistry("faulty")
+    r.register("bad", lambda: (_ for _ in ()).throw(RuntimeError("boom")))
+    r.register("ok", lambda: log.append("undo-ok"))
+    r.dispose()
+    assert log == ["undo-ok"], f"失败隔离失败: {log}"
+    print("✓ 单条撤销失败不阻断整体")
+
+    print("SELFTEST ALL GREEN")
+
+
+if __name__ == "__main__":
+    _selftest()

liquid_loop-2.0.2/liquid_loop/guard.py

@@ -0,0 +1,324 @@
+"""蒸馏 #197 + #198 守卫原语：能力菜单 + 升级刹车 + 确认闸。
+
+#197 MCP 安全边界：能力描述/标签只是提示语，不是沙箱；隔离靠部署层。
+      → CapabilityMenu：声明带名字/参数/风险等级的能力；高危调用前插确认闸。
+#198 Agent 停下问人：升级条件 = 低置信 ∨ 不可逆 ∨ 超预算；审批=方向盘。
+      → should_escalate(confidence, irreversible, over_budget) + confirm_gate。
+
+液环 cli 已有 --force 确认雏形（cpe_check）；本模块提供通用原语，供破坏性操作接入，
+让「动作前问人」成为可配置策略而非散落各处的硬编码。零依赖：仅标准库。
+"""
+from __future__ import annotations
+
+RISK_LEVELS = ("low", "medium", "high")
+
+
+def validate_content(content: str) -> str | None:
+    """内容质量 ValidationRule（08-18 审计补盲）：挡无意义/垃圾写入。
+
+    返回拒绝原因字符串；通过返回 None。
+    规则（纯规则零依赖，只挡"无意义"，不评"价值"）：
+      1) 空内容；
+      2) 无字母/汉字 且 过短(<8) 的纯占位/符号噪音（如 "1"、"!"、"!!!"）；
+      3) 字符多样性过低(熵代理)的重复噪音（如 "aaaaaa"、"111111"）。
+    单点维护：server ll_remember 与 workspace.add_evidence 共用本函数。
+    """
+    c = (content or "").strip()
+    if not c:
+        return "content 为空: 疑似无意义写入"
+    has_text = any(not ch.isdigit() and ch.isalnum() for ch in c)
+    if not has_text and len(c) < 8:
+        return "content 无文字内容且过短: 疑似占位噪音"
+    if len(set(c)) / len(c) < 0.2:
+        return "content 字符多样性过低(熵代理): 疑似重复噪音"
+    return None
+
+
+# ── 反绝对化词表（m60 DeepTutor 借鉴落地 · 2026-08-29）──
+# DeepTutor 训练师提示词要求"避免绝对化、过度自信表述"（不/不要/绝不/总是/完全/彻底/
+# 专家/热爱/恨 等），并配引用池约束（结论必须能锚定到已蒸馏引文）。
+# 液环落地为「警告级」检测：只标记、不拒绝——液环允许主体自由表达，但把过度概括
+# 显式暴露给写入方（og_flags），供上层蒸馏/内化时复核真实性，而非静默放行。
+OVERGEN_TERMS: tuple[tuple[str, str], ...] = (
+    # (命中词, 类别)
+    ("总是", "absolute"), ("从来不", "absolute"), ("从不", "absolute"), ("永远", "absolute"),
+    ("所有", "absolute"), ("全部", "absolute"), ("一切", "absolute"), ("任何", "absolute"),
+    ("完全", "absolute"), ("彻底", "absolute"), ("绝对", "absolute"), ("一定", "absolute"),
+    ("必须", "prescriptive"), ("禁止", "prescriptive"), ("绝不", "absolute"),
+    ("专家", "claim"), ("大师", "claim"), ("完美", "claim"), ("精通", "claim"),
+    ("热爱", "claim"), ("深爱", "claim"), ("憎恨", "claim"), ("讨厌", "claim"),
+    ("always", "absolute"), ("never", "absolute"), ("every", "absolute"),
+    ("all", "absolute"), ("none", "absolute"), ("completely", "absolute"),
+    ("totally", "absolute"), ("absolutely", "absolute"), ("perfectly", "claim"),
+    ("expert", "claim"), ("master", "claim"), ("perfect", "claim"),
+    ("love", "claim"), ("hate", "claim"), ("passion", "claim"),
+    ("fully understands", "claim"), ("deeply", "claim"), ("truly", "claim"),
+)
+
+
+def overgeneralization_flags(content: str) -> list[dict]:
+    """反绝对化词表检测（m60 建议2 落地）：返回命中的过度概括表述。
+
+    返回 [{term, category}]，按出现顺序去重；无命中返回 []。
+    只标记不拒绝（警告级）：液环允许自由表达，但显式暴露给上层复核。
+    零依赖，纯规则，与 validate_content 同一风格。
+    """
+    c = (content or "").lower()
+    flags: list[dict] = []
+    seen: set = set()
+    for term, cat in OVERGEN_TERMS:
+        if term in c and term not in seen:
+            seen.add(term)
+            flags.append({"term": term, "category": cat})
+    return flags
+
+
+def should_escalate(confidence: float = 1.0, irreversible: bool = False,
+                    over_budget: bool = False) -> bool:
+    """升级刹车：命中任一红线即交回人。低置信 ∨ 不可逆 ∨ 超预算。
+
+    全自动不是高级，敢于在关键时刻说"我需要你"才是设计出来的安全网。
+    """
+    return (confidence < 0.5) or bool(irreversible) or bool(over_budget)
+
+
+class CapabilityMenu:
+    """能力菜单：声明带风险等级的能力，隔离靠部署层而非标签。"""
+
+    def __init__(self):
+        self._caps: dict = {}
+
+    def declare(self, name: str, risk: str = "low", description: str = "",
+                 params: list | None = None) -> None:
+        if risk not in RISK_LEVELS:
+            raise ValueError(f"risk 必须是 {RISK_LEVELS}，收到 {risk!r}")
+        self._caps[name] = {
+            "risk": risk,
+            "description": description,
+            "params": params or [],
+        }
+
+    def risk_of(self, name: str) -> str | None:
+        cap = self._caps.get(name)
+        return cap["risk"] if cap else None
+
+    def requires_confirm(self, name: str) -> bool:
+        """high 风险能力调用前必须确认（对齐液环确认闸门）。"""
+        return self.risk_of(name) == "high"
+
+    def as_menu(self) -> dict:
+        """供协议层展示的菜单（提示语，非沙箱）。"""
+        return dict(self._caps)
+
+
+def confirm_gate(action: str, risk: str = "high", auto_approve: bool = False) -> bool:
+    """确认闸：high 风险且未 auto 确认 → 返回 False（拦截，交回人）。
+
+    auto_approve=True 用于 dry-run / 测试；真实高危操作应默认拦截。
+    返回 True=放行，False=拦截（需人工确认）。
+    """
+    if risk not in RISK_LEVELS:
+        risk = "high"  # 未知风险按最高处置
+    if risk == "high" and not auto_approve:
+        return False
+    return True
+
+
+class PerceptionGate:
+    """门控-液环因果共生环的胶水层（“单终端机器人”概念落地件）。
+
+    设计定位（克制原则：精选 4 模块，不重新膨胀）：
+      - 输入候选感知动作 + 预算余量 + 灵敏度，输出 allow / degrade / block + 理由。
+      - 内部消费：
+          1) guard.should_escalate —— 不可逆变 + 低置信 → 交回人（block）。
+          2) 因果边（workspace.causal：enables/causes/contradicts）→ 「因果核心永饿死」
+             豁免：命中因果核心的动作即便超预算也放行，保证液环主链路不被闸饿死。
+          3) adaptive_recall 的负载双模（load<0.5 冗余验证 / ≥0.5 分工扩容）→
+             超预算时按当前认知负载决定 degrade（省算力）还是 allow（精度优先）。
+          4) build_or_cache（rar 本地索引缓存）→ 本地算力溶解「重建索引」成本，
+             使高载降级 skip 无后顾之忧（详见测试 test_perception_gate.py）。
+          5) env_anchor_probe（v3.2 环境锚时效门，可选）→ 涉及环境类断言的动作
+             使用前强制重取证（curl/ps/ipconfig/hostname 正对照），返回 stale 即 block，
+             把"认知基线纪律"升为机制强制步；无注入则跳过（零影响）。
+
+    零依赖：真实因果边 / 负载 / 环境锚重取证来自 liquid-loop 的 workspace / recall_filter / rar
+    或调用方注入，由 adapter 注入（causal_core_predicate / load_probe / env_anchor_probe），
+    不在本模块 import 重型依赖。这样门控成为「可配置策略」，而非把整套液环塞进门里的膨胀方案。
+    """
+
+    def __init__(self, budget: float = 1.0, sensitivity: str = "normal",
+                 causal_core_predicate=None, load_probe=None, env_anchor_probe=None):
+        self.budget = float(budget)
+        self.sensitivity = sensitivity
+        self._spent = 0.0
+        # 默认谓词：无注入时一律非因果核心（保守，闸正常生效）
+        self.causal_core_predicate = causal_core_predicate or (lambda action: False)
+        # 默认负载探测器：无注入时返回 0.0（低载，精度优先路径）
+        self.load_probe = load_probe or (lambda: 0.0)
+        # v3.2 环境锚时效门：无注入时返回 None（跳过，零影响现有门）
+        self.env_anchor_probe = env_anchor_probe
+
+    def decide(self, action, cost: float = 0.0, confidence: float = 1.0,
+               irreversible: bool = False) -> dict:
+        """对一条候选感知动作做门控裁决。
+
+        返回 dict: {"decision": allow|degrade|block, "reason": str, ...}
+          - block    : 需人工确认（交回人），不消耗预算。
+          - allow    : 放行（因果核心豁免 / 正常 / 低载精度优先）。
+          - degrade  : 超预算 + 高载 → 降采样 / 跳过，省算力；不消耗预算。
+        """
+        # 0) v3.2 环境锚时效门（最高优先）：涉及环境类断言须先重取证，stale 即拦截
+        if self.env_anchor_probe is not None:
+            try:
+                _ap = self.env_anchor_probe(action)
+            except Exception:
+                _ap = None  # 重取证异常 fail-open，不误伤（零爆破半径）
+            if _ap is True or (isinstance(_ap, dict) and _ap.get("stale")):
+                return {
+                    "decision": "block",
+                    "reason": f"环境锚时效门: 须重取证 ({_ap.get('detail','') if isinstance(_ap, dict) else ''})",
+                    "env_anchor_stale": True,
+                }
+
+        # 1) 不可逆变 + 低置信 → 交回人（should_escalate 红线）
+        if should_escalate(confidence=confidence, irreversible=irreversible):
+            return {
+                "decision": "block",
+                "reason": "irreversible+low_confidence→需人工确认",
+                "escalate": True,
+            }
+
+        # 2) 因果核心 → 永放行（never starve causal core）
+        if self.causal_core_predicate(action):
+            return {
+                "decision": "allow",
+                "reason": "因果核心动作永放行（保护液环主链路）",
+                "causal_core": True,
+            }
+
+        # 3) 预算检查
+        remaining = self.budget - self._spent
+        if cost > remaining:
+            load = float(self.load_probe())
+            if load >= 0.5:
+                # 高载：降级 skip / 降采样，省算力
+                # （rar.build_or_cache 已本地化索引重建成本，skip 无后顾之忧）
+                return {
+                    "decision": "degrade",
+                    "reason": f"超预算+高载({load:.2f})→降采样/跳过省算力",
+                    "load": load,
+                    "over_budget": True,
+                }
+            # 低载：冗余验证，精度优先（仍消耗预算）
+            self._spent += cost
+            return {
+                "decision": "allow",
+                "reason": f"超预算+低载({load:.2f})→冗余验证精度优先",
+                "load": load,
+                "over_budget": True,
+            }
+
+        # 4) 正常放行
+        self._spent += cost
+        return {
+            "decision": "allow",
+            "reason": "正常放行",
+            "load": float(self.load_probe()),
+        }
+
+    def remaining(self) -> float:
+        """剩余预算。"""
+        return self.budget - self._spent
+
+
+# ── 评估准则：延迟跃变防误判（m69 过度递归衰减 + m65 世界模型自演化 蒸馏落地 · 2026-08-29）──
+# 自演化系统最危险的评估错误是「过早判失败」：机制的效果常表现为延迟跃变
+# （先震荡/持平，积累到阈值后跳变），若在跃变前按短期指标关停，就永远等不到
+# 跃变。本准则供上层评测门控（如 SoMEval 接入的评估门）作为独立校验函数使用：
+# 对某机制给出「是否继续运行」建议时，先检查评估窗口是否足以覆盖延迟跃变期。
+EVAL_MIN_WINDOW_DAYS = 7      # 机制效果最小评估窗口（天）
+EVAL_RECENCY_WEIGHT = 0.5     # 近端窗口权重阈值：近端占比过高说明评估窗口过短
+
+
+def eval_patience_check(
+    history: list[dict] | None = None,
+    window_days: float = EVAL_MIN_WINDOW_DAYS,
+    recency_weight: float = EVAL_RECENCY_WEIGHT,
+) -> dict:
+    """评估准则：防「过早判失败」的延迟跃变检查。
+
+    入参 history: [{"ts": 秒级时间戳, "metric": float}, ...]（按时间升序）。
+    无历史/历史过短 → 返回 verdict="insufficient"（建议延长窗口再判）。
+    返回:
+      {
+        "verdict": "ok" | "insufficient" | "too_short_window",
+        "reason": str,
+        "window_days": float,        # 覆盖的实际时间跨度（天）
+        "recency_ratio": float | None,  # 近 1/3 窗口指标占整体比重（不稳定时显式暴露）
+        "trend": "rising"|"flat"|"declining"|"unknown",
+      }
+    设计要点（蒸馏自 m69 过度递归衰减 / m65 世界模型自演化）：
+      - 机制的自演化收益是延迟跃变而非线性累积 → 评估窗口必须覆盖跃变期；
+      - 近端比重过高 = 评估窗口过短，直接建议延长而非判失败；
+      - 本函数只做「评估是否充分」的裁决，不代替业务指标计算，保持零依赖纯函数。
+    """
+    if not history or len(history) < 3:
+        return {
+            "verdict": "insufficient",
+            "reason": "评估历史不足(需≥3个采样点)，无法判断延迟跃变",
+            "window_days": 0.0,
+            "recency_ratio": None,
+            "trend": "unknown",
+        }
+    try:
+        ts0 = float(history[0]["ts"])
+        ts1 = float(history[-1]["ts"])
+        span_days = (ts1 - ts0) / 86400.0
+    except (KeyError, TypeError, ValueError):
+        return {
+            "verdict": "insufficient",
+            "reason": "历史采样点缺 ts/metric 字段，无法计算评估窗口",
+            "window_days": 0.0,
+            "recency_ratio": None,
+            "trend": "unknown",
+        }
+    if span_days < window_days:
+        return {
+            "verdict": "too_short_window",
+            "reason": f"评估窗口 {span_days:.1f} 天 < 建议最小 {window_days} 天，延迟跃变未到观察期，禁止判失败",
+            "window_days": span_days,
+            "recency_ratio": None,
+            "trend": "unknown",
+        }
+    # 近端 1/3 采样点指标均值 vs 整体均值：近端占比过高 → 窗口仍在跃变爬升期
+    n = len(history)
+    recent = history[max(0, n - max(1, n // 3)):]
+    try:
+        avg_all = sum(float(h["metric"]) for h in history) / n
+        avg_recent = sum(float(h["metric"]) for h in recent) / len(recent)
+        ratio = (avg_recent / avg_all) if avg_all else 1.0
+    except (KeyError, TypeError, ValueError):
+        ratio = None
+    trend = "unknown"
+    if ratio is not None:
+        if ratio > 1.05:
+            trend = "rising"
+        elif ratio < 0.95:
+            trend = "declining"
+        else:
+            trend = "flat"
+    if ratio is not None and ratio > (1.0 + recency_weight):
+        return {
+            "verdict": "too_short_window",
+            "reason": f"近端指标占比 {ratio:.2f} 过高(>1+{recency_weight})，机制处于跃变爬升期，须延长窗口",
+            "window_days": span_days,
+            "recency_ratio": ratio,
+            "trend": trend,
+        }
+    return {
+        "verdict": "ok",
+        "reason": f"评估窗口 {span_days:.1f} 天覆盖延迟跃变期，可正常评估",
+        "window_days": span_days,
+        "recency_ratio": ratio,
+        "trend": trend,
+    }