dsh-biocore 0.1.2 → 0.1.4

package/python/mindbase/self_model.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import random
+from typing import Dict
+
+from .noise import clip, ou
+from .types import Appraisal, Event
+
+
+class SelfModel:
+    """Minimal self: agency, continuity, consistency, identity.
+
+    identity is a slow variable: contradictions move it down, coherent
+    experience lets it recover. This is operational, not a consciousness claim.
+    """
+
+    def __init__(self, rng: random.Random):
+        self.rng = rng
+        self.agency = 0.50
+        self.continuity = 0.50
+        self.consistency = 0.80
+        self.identity = 0.70
+        self.value_stability = 1.0
+        self.feedback_expectation = 0.0
+        self.identity_prediction = self.identity
+        self.identity_setpoint_base = 0.70
+        self.prediction_error = 0.0
+        # allostatic self-efficacy: can I reduce the current setpoint error?
+        self.allostatic_self_efficacy = 0.50
+        self.expression_confidence = 0.50
+        self.identity_gain = 1.0
+
+    def on_event(self, ev: Event, ap: Appraisal) -> None:
+        if ev.speaker == "self":
+            self.agency = clip(self.agency + 0.03, 0.0, 1.0)
+            self.continuity = clip(self.continuity + 0.01, 0.0, 1.0)
+        else:
+            self.agency = clip(self.agency - 0.005, 0.0, 1.0)
+            self.continuity = clip(self.continuity + 0.002, 0.0, 1.0)
+        self.consistency = clip(
+            0.95 * self.consistency + 0.05 * (1.0 - abs(ap.valence) * 0.2),
+            0.0,
+            1.0,
+        )
+
+    def on_action(self, action: str, spoke: bool) -> None:
+        target = 1.0 if spoke else 0.35
+        self.agency = ou(self.agency, target, 1.0 / 60.0, 0.05, 1.0, self.rng)
+        self.continuity = clip(self.continuity + (0.002 if spoke else 0.0), 0.0, 1.0)
+        self.identity = clip(self.identity + (0.001 if spoke else -0.0005) * float(getattr(self, "identity_gain", 1.0)), 0.0, 1.0)
+
+    def tick(self, dt: float) -> None:
+        rate = min(1.0, max(0.0, dt) / (7.0 * 86400.0))
+        # value stability recovers when contradictions stop arriving
+        self.value_stability = clip(
+            self.value_stability + (1.0 - self.value_stability) * rate, 0.0, 1.0
+        )
+        target = clip(
+            0.50 * self.continuity + 0.30 * self.consistency + 0.20 * self.value_stability,
+            0.0,
+            1.0,
+        )
+        self.identity = clip(self.identity + (target - self.identity) * rate, 0.0, 1.0)
+        # predictive self: predict before observing, then update from error
+        pred_err = self.identity - self.identity_prediction
+        self.identity_prediction = clip(self.identity_prediction + 0.20 * pred_err, 0.0, 1.0)
+        self.prediction_error = pred_err
+
+    def on_expression(self, metrics: Dict[str, float]) -> None:
+        length = float(metrics.get("length", 0.0))
+        question = float(metrics.get("question", 0.0))
+        diversity = float(metrics.get("diversity", 0.0))
+        novelty = float(metrics.get("novelty", 0.0))
+        quality = clip(0.30 * min(1.0, length / 80.0) + 0.25 * diversity + 0.30 * novelty + 0.15 * question, 0.0, 1.0)
+        self.expression_confidence = clip(0.90 * self.expression_confidence + 0.10 * quality, 0.0, 1.0)
+        self.identity = clip(self.identity + 0.002 * (quality - 0.50) * float(getattr(self, "identity_gain", 1.0)), 0.0, 1.0)
+
+    def on_feedback(self, value_delta: Dict[str, float], conflict: str = "none", signal: float = 0.0) -> None:
+        # Unified RPE: fly DAN and human dopamine both encode reward prediction error.
+        sig = clip(float(signal), -1.0, 1.0)
+        rpe = sig - self.feedback_expectation
+        self.feedback_expectation = clip(self.feedback_expectation + 0.20 * rpe, -1.0, 1.0)
+        # value/identity are slow integrators of the same prediction error
+        self.value_stability = clip(self.value_stability + 0.06 * rpe, 0.0, 1.0)
+        # self-verification: identity is an attractor around a feedback-dependent setpoint
+        self.identity_setpoint = clip(float(getattr(self, "identity_setpoint_base", 0.70)) + 0.25 * self.feedback_expectation, 0.30, 0.92)
+        gain = float(getattr(self, "identity_gain", 1.0))
+        self.identity = clip(self.identity + gain * (0.05 * (self.identity_setpoint - self.identity) + 0.02 * rpe), 0.0, 1.0)
+        # goal conflict is an additional aversive prediction error, not a hand-tuned valence
+        if conflict == "high":
+            self.identity = clip(self.identity - 0.01, 0.0, 1.0)
+
+    def update_allostatic_efficacy(self, load: float, confidence: float, anxiety: float = 0.0, social_load: float = 0.0, physiological_load: float = 0.0, safety_load: float = 0.0, social_support: float = 0.0) -> None:
+        ax = clip(float(anxiety), 0.0, 1.0)
+        # social baseline: social load weighs more under anxious attachment
+        social_weight = (0.40 + 0.40 * ax) * (1.0 - 0.30 * clip(float(social_support), 0.0, 1.0))
+        weighted = 0.40 * float(physiological_load) + social_weight * float(social_load) + 0.40 * float(safety_load)
+        load = clip(max(float(load), weighted), 0.0, 1.0)
+        conf = clip(float(confidence) * (1.0 - 0.30 * ax), 0.0, 1.0)
+        self.ase_components = {"load": round(load, 4), "confidence": round(conf, 4), "anxiety": round(clip(float(anxiety), 0.0, 1.0), 4)}
+        self.allostatic_self_efficacy = clip(conf * (1.0 - load), 0.0, 1.0)
+
+    def snapshot(self) -> Dict[str, float]:
+        return {
+            "agency": round(self.agency, 3),
+            "continuity": round(self.continuity, 3),
+            "consistency": round(self.consistency, 3),
+            "identity": round(self.identity, 3),
+            "value_stability": round(self.value_stability, 3),
+            "feedback_expectation": round(self.feedback_expectation, 3),
+            "identity_setpoint": round(getattr(self, "identity_setpoint", 0.70), 3),
+            "identity_prediction": round(self.identity_prediction, 3),
+            "prediction_error": round(self.prediction_error, 4),
+            "allostatic_self_efficacy": round(self.allostatic_self_efficacy, 3),
+            "ase_components": dict(getattr(self, "ase_components", {})),
+        }

package/python/mindbase/selftest.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from .config import MindConfig
+from .engine import MindBase
+from .types import Event
+
+
+def main() -> None:
+    cfg = MindConfig(seed=7, autonomy_threshold=0.05, abstain_threshold=0.30)
+    mb = MindBase(cfg)
+
+    events = [
+        Event(text="你好", speaker="A", ts=0),
+        Event(text="你今天真棒", speaker="A", ts=60),
+        Event(text="你真废物", speaker="B", ts=120),
+        Event(text="我今天好累", speaker="A", ts=180),
+        Event(text="晚安", speaker="B", ts=240),
+        Event(kind="tick", ts=300),
+        Event(text="在吗", speaker="A", directed=True, ts=360),
+    ]
+    outs = mb.run(events)
+
+    mb.assert_invariants()
+    snap = mb.snapshot()
+    assert "affect" in snap and "drives" in snap and "memory" in snap
+    v = snap["affect"]["v"]
+    a = snap["affect"]["a"]
+    stress = snap["affect"]["stress"]
+    assert -1.0 <= v <= 1.0, v
+    assert 0.0 <= a <= 1.0, a
+    assert 0.0 <= stress <= 1.0, stress
+
+    assert any("废物" in item.text for item in mb.memory.items), "memory did not write"
+    assert len(mb.wm.slots) <= cfg.wm_capacity
+    assert outs[-1].action == "speak" and outs[-1].reason == "directed"
+    assert outs[-1].llm_request is not None and outs[-1].llm_request.mode == "reply"
+
+    # force an endogenous action with no external trigger
+    mb.last_speaker = None
+    mb.autonomy.h = 10.0
+    mb.autonomy.last_spoke = -1e9
+    mb.will.willpower = 1.0
+    proactive = mb.tick(60)
+    assert proactive.action == "speak" and proactive.reason in ("impulse", "intention"), proactive
+    assert proactive.llm_request is not None and proactive.llm_request.mode == "proactive", proactive.llm_request
+
+    # intention can veto impulse when willpower is high
+    mb.intentions.add("stay quiet", action="silence", strength=0.9, commitment=0.9, now=mb.t)
+    mb.will.willpower = 1.0
+    mb.autonomy.h = 10.0
+    mb.autonomy.last_spoke = -1e9
+    veto = mb.tick(60)
+    assert veto.action == "silence" and veto.reason == "intention", veto
+    assert veto.llm_request is None, veto.llm_request
+
+    # depleted willpower gives in to impulse
+    mb.will.willpower = 0.0
+    mb.autonomy.h = 10.0
+    mb.autonomy.last_spoke = -1e9
+    give_in = mb.tick(60)
+    assert give_in.action == "speak" and give_in.reason == "impulse", give_in
+
+    # mushroom body: reward increases prediction; no feedback does not
+    p0, _ = mb.mb.predict("奖励线索")
+    mb.post_reply("奖励线索", feedback=1.0)
+    p1, _ = mb.mb.predict("奖励线索")
+    assert p1 > p0, (p0, p1)
+
+    p2, _ = mb.mb.predict("中性线索")
+    mb.post_reply("中性线索", feedback=None)
+    p3, _ = mb.mb.predict("中性线索")
+    assert abs(p3 - p2) < 1e-9, (p2, p3)
+
+    # two channels: positive feedback -> reward only
+    b = mb.mb.predict_channels("正性线索")
+    mb.post_reply("正性线索", feedback=1.0)
+    a = mb.mb.predict_channels("正性线索")
+    assert a["reward"] > b["reward"], (b, a)
+    assert abs(a["punishment"] - b["punishment"]) < 1e-9, (b, a)
+
+    # negative feedback -> punishment only, value drops
+    b = mb.mb.predict_channels("负性线索")
+    mb.post_reply("负性线索", feedback=-1.0)
+    a = mb.mb.predict_channels("负性线索")
+    assert a["punishment"] > b["punishment"], (b, a)
+    assert a["value"] < b["value"], (b, a)
+
+    # APL feedback loop: repeated high density -> lower gain
+    g0 = mb.mb.apl.step(list(range(64)), mb.mb.kc.n, 0.05)
+    for _ in range(5):
+        g1 = mb.mb.apl.step(list(range(64)), mb.mb.kc.n, 0.05)
+    assert g1 < g0, (g0, g1)
+
+    # homeostatic scaling: total absolute weight bounded
+    mb.mb.mbon_reward.w = [1.0] * mb.mb.kc.n
+    mb.mb.homeostatic(10.0)
+    assert sum(abs(w) for w in mb.mb.mbon_reward.w) <= 10.001
+
+    # habituation: repeated cue -> weaker; negative -> sensitize
+    h0 = mb.mb.hab.response("重复线索")
+    mb.learner.on_event("重复线索", 0.0)
+    h1 = mb.mb.hab.response("重复线索")
+    assert h1 < h0, (h0, h1)
+    mb.learner.on_event("重复线索", -1.0)
+    h2 = mb.mb.hab.response("重复线索")
+    assert h2 > h1, (h1, h2)
+
+    silent = mb.step(Event(kind="self_action", speaker="self", ts=mb.t + 60))
+    assert silent.action == "silence" and silent.llm_request is None, silent
+
+    mb.assert_invariants()
+    print("mindbase selftest: OK")
+    print("events:", len(outs), "| memory items:", len(mb.memory.items), "| wm:", len(mb.wm.slots))
+    print("last state:", mb.prompt_state(proactive.action, proactive.reason))
+
+
+if __name__ == "__main__":
+    main()

package/python/mindbase/semantic_memory.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+import json
+import re
+from typing import Dict, List, Optional
+
+from .types import LLMRequest
+
+
+def _json(text: str) -> Dict[str, object]:
+    text = str(text or "").strip()
+    start, end = text.find("{"), text.rfind("}")
+    if start >= 0 and end > start:
+        text = text[start:end + 1]
+    try:
+        obj = json.loads(text)
+        return obj if isinstance(obj, dict) else {}
+    except Exception:
+        return {}
+
+
+class SemanticMemory:
+    """LLM-based fact extraction / memory question / evidence judge. No keyword tables."""
+
+    def __init__(self, client):
+        self.client = client
+
+    def _ask(self, system: str, user: str, max_tokens: int = 300) -> Dict[str, object]:
+        req = LLMRequest(mode="semantic", urgency=0.5, max_tokens=max_tokens, reason="semantic",
+                         context={"system": system, "user": user})
+        raw = self.client.generate(req)
+        self.last_raw = raw
+        return _json(raw)
+
+    def parse(self, text: str) -> Dict[str, object]:
+        out = self._ask(
+            "你只做信息抽取。只输出 JSON，不要解释。",
+            "用户说：" + str(text) +
+            "\n返回 JSON：{\"is_fact\": true/false, \"fact\": \"关于用户的事实，没有则空\", "
+            "\"is_memory_question\": true/false, \"query\": \"如果是在问记忆，提取查询关键词/实体，否则空\"}",
+            220,
+        )
+        return {
+            "is_fact": bool(out.get("is_fact")),
+            "fact": str(out.get("fact") or "").strip(),
+            "is_memory_question": bool(out.get("is_memory_question")),
+            "query": str(out.get("query") or "").strip(),
+        }
+
+    def reply(self, text: str, memories: List[str], persona: str = "", recent: Optional[List[str]] = None, insight: str = "", state: str = "", diary: str = "", preference: str = "", emotion: str = "", noise: float = 0.0) -> Dict[str, object]:
+        system = (persona.strip() + "\n\n" if persona else "") + (
+            "你在做一次完整的社交回复。只输出 JSON，不要 markdown，不要解释。"
+            "如果对方在问记忆，只能用给出的记忆回答；记忆不支持就诚实说不知道，不要编。"
+        )
+        user = (
+            "最近对话：\n" + "\n".join("- " + str(x) for x in (recent or [])[-4:]) +
+            "\n记忆：\n" + "\n".join("- " + str(m) for m in memories[:6]) +
+            ("\n你现在的身体/情绪状态：" + str(state) if state else "") +
+            ("\n你最近的日记（可参考，不要照念）：" + str(diary)[:400] if diary else "") +
+            ("\n这个用户的表达偏好：" + str(preference) if preference else "") +
+            ("\n你当前的需要和情绪：" + str(emotion) if emotion else "") +
+            ("\n轻微情绪噪声：" + str(round(float(noise), 3)) if noise else "") +
+            ("\n你刚冒出的念头（可自然带出，不强制，不要复述）：" + str(insight) if insight else "") +
+            "\n用户刚说：" + str(text) +
+            "\n返回 JSON：{\"reply\": \"对用户说的一句中文，1-3句\", \"facts\": [\"关于用户的新事实，没有则空数组\"], \"memory_used\": \"用到的记忆，没有则空\", "
+            "\"appraisal\": {\"valence\": -1到1, \"need_delta\": -1到1, \"fear_delta\": -1到1, \"joy_delta\": -1到1, "
+            "\"agency\": 0到1, \"certainty\": 0到1, \"control\": 0到1, \"novelty\": 0到1}}"
+        )
+        raw = ""
+        try:
+            req = LLMRequest(mode="semantic", urgency=0.5, max_tokens=320, reason="semantic_reply",
+                             context={"system": system, "user": user})
+            raw = str(self.client.generate(req) or "")
+            out = _json(raw)
+        except Exception:
+            out = {}
+        reply = str(out.get("reply") or "").strip()
+        if not reply:
+            reply = raw.strip()
+        facts = out.get("facts") or []
+        if isinstance(facts, str):
+            facts = [facts]
+        if not isinstance(facts, list):
+            facts = []
+        appraisal = out.get("appraisal") or {}
+        if not isinstance(appraisal, dict):
+            appraisal = {}
+        return {"reply": reply, "facts": [str(x) for x in facts if str(x).strip()], "memory_used": str(out.get("memory_used") or ""), "appraisal": appraisal}
+
+    def sentiment(self, text: str) -> float:
+        out = self._ask("判断用户这句话的情绪，只输出 JSON。", "用户说：" + str(text) + "\n返回 JSON：{\"sentiment\": -1 到 1 的数}", 300)
+        try:
+            return max(-1.0, min(1.0, float(out.get("sentiment", 0.0))))
+        except Exception:
+            return 0.0
+
+    def judge(self, question: str, memories: List[str]) -> Optional[str]:
+        out = self._ask(
+            "你只根据给出的记忆回答。没有证据就诚实说不知道，不要编。只输出 JSON。",
+            "问题：" + str(question) +
+            "\n记忆：\n" + "\n".join("- " + str(m) for m in memories[:6]) +
+            "\n返回 JSON：{\"supported\": true/false, \"answer\": \"用一句中文回答；supported=false 时写 不知道\"}",
+            240,
+        )
+        if not out.get("supported"):
+            return None
+        answer = str(out.get("answer") or "").strip()
+        return answer or None

package/python/mindbase/session_store.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+from typing import Dict
+
+from .memory import MemoryItem
+from .social import Bond
+import numpy as np
+from .fly_mb import FlyMushroomBody
+
+
+class SessionStore:
+    """Persist per-user session: facts, turns, identity, drives, affect."""
+
+    def __init__(self, root: Path):
+        self.root = Path(root)
+        self.root.mkdir(parents=True, exist_ok=True)
+
+    def _path(self, user_id: str) -> Path:
+        key = hashlib.sha256(str(user_id).encode("utf-8")).hexdigest()[:16]
+        return self.root / (key + ".json")
+
+    def _fly_path(self, user_id: str) -> Path:
+        key = hashlib.sha256(str(user_id).encode("utf-8")).hexdigest()[:16]
+        return self.root / (key + ".fly.npz")
+
+    def save(self, user_id: str, session) -> None:
+        try:
+            m = session.mind
+            facts = []
+            for item in list(m.memory.semantic.items)[-200:]:
+                facts.append({
+                    "text": item.text,
+                    "importance": float(item.importance),
+                    "t": float(item.t),
+                    "confidence": float(getattr(item, "confidence", 0.5)),
+                })
+            bond = m.social.bonds.get(str(user_id))
+            social = {
+                "trust": float(bond.trust) if bond else 0.5,
+                "attachment": float(bond.attachment) if bond else 0.1,
+                "familiarity": float(bond.familiarity) if bond else 0.1,
+                "responsiveness": float(bond.responsiveness) if bond else 0.5,
+                "stage": str(getattr(bond, "stage", "stranger")) if bond else "stranger",
+            } if bond else {}
+            episodic = []
+            for item in list(m.memory.episodic.items)[-200:]:
+                episodic.append({"text": item.text, "importance": float(item.importance), "t": float(item.t), "confidence": float(getattr(item, "confidence", 0.5))})
+            evolution = None
+            try:
+                for exp in getattr(session, "kernel", None).experiments:
+                    if getattr(exp, "name", "") == "evolution" and hasattr(exp, "state"):
+                        evolution = exp.state()
+                        break
+            except Exception:
+                evolution = None
+            data = {
+                "user_id": str(user_id),
+                "evolution": evolution,
+                "social": social,
+                "episodic": episodic,
+                "t": float(m.t),
+                "identity": float(m.self_model.identity),
+                "drives": {k: float(v) for k, v in m.drives.values.items()},
+                "affect": {
+                    "v": float(getattr(m.affect, "v", 0.0)),
+                    "a": float(getattr(m.affect, "a", 0.0)),
+                    "stress": float(getattr(m.affect, "stress", 0.0)),
+                },
+                "facts": facts,
+                "emotion": session.emotion.snapshot() if hasattr(session, "emotion") else None,
+                "turns": list(session.turns)[-30:],
+            }
+            self._path(user_id).write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
+            fly = getattr(getattr(session.mind, "circuit", None), "fly_mb", None)
+            if fly is not None:
+                np.savez_compressed(self._fly_path(user_id), w_approach=fly.w_approach, w_avoid=fly.w_avoid, trace=fly.trace,
+                                    sparsity=np.array([fly.sparsity]), lr=np.array([fly.lr]), apl_gain=np.array([fly.apl_gain]),
+                                    trace_decay=np.array([fly.trace_decay]), pam_lr=np.array([fly.pam_lr]), ppl1_lr=np.array([fly.ppl1_lr]),
+                                    reward_expectation=np.array([fly.reward_expectation]), punishment_expectation=np.array([fly.punishment_expectation]),
+                                    pam_gamma_ratio=np.array([fly.pam_gamma_ratio]), ppl1_alpha_ratio=np.array([fly.ppl1_alpha_ratio]),
+                                    weight_decay=np.array([fly.weight_decay]),
+                                    gamma=np.array([fly.subregion_gain["gamma"]]), alpha=np.array([fly.subregion_gain["alpha"]]), beta=np.array([fly.subregion_gain["beta"]]),
+                                    age_steps=np.array([fly.age_steps]), plasticity=np.array([fly.plasticity]))
+        except Exception:
+            pass
+
+    def _load_fly(self, user_id: str, session) -> None:
+        fly_path = self._fly_path(user_id)
+        if not fly_path.exists():
+            return
+        try:
+            m = session.mind
+            fly = getattr(getattr(m, "circuit", None), "fly_mb", None)
+            if fly is None:
+                fly = FlyMushroomBody(seed=1)
+                m.circuit.fly_mb = fly
+            z = np.load(fly_path)
+            fly.w_approach = z["w_approach"]
+            fly.w_avoid = z["w_avoid"]
+            fly.trace = z["trace"]
+            fly.sparsity = float(z["sparsity"][0])
+            fly.lr = float(z["lr"][0])
+            fly.apl_gain = float(z["apl_gain"][0])
+            fly.trace_decay = float(z["trace_decay"][0])
+            fly.pam_lr = float(z["pam_lr"][0])
+            fly.ppl1_lr = float(z["ppl1_lr"][0])
+            fly.reward_expectation = float(z["reward_expectation"][0])
+            fly.punishment_expectation = float(z["punishment_expectation"][0])
+            fly.pam_gamma_ratio = float(z["pam_gamma_ratio"][0])
+            fly.ppl1_alpha_ratio = float(z["ppl1_alpha_ratio"][0])
+            fly.weight_decay = float(z["weight_decay"][0])
+            fly.subregion_gain = {"gamma": float(z["gamma"][0]), "alpha": float(z["alpha"][0]), "beta": float(z["beta"][0])}
+        except Exception:
+            pass
+
+    def load(self, user_id: str, session) -> bool:
+        path = self._path(user_id)
+        if not path.exists():
+            return False
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+            m = session.mind
+            m.t = float(data.get("t", m.t))
+            m.self_model.identity = float(data.get("identity", m.self_model.identity))
+            for key, value in (data.get("drives") or {}).items():
+                if key in m.drives.values:
+                    m.drives.values[key] = float(value)
+            aff = data.get("affect") or {}
+            m.affect.v = float(aff.get("v", m.affect.v))
+            m.affect.a = float(aff.get("a", m.affect.a))
+            m.affect.stress = float(aff.get("stress", m.affect.stress))
+            soc = data.get("social") or {}
+            if soc:
+                bond = m.social.bonds.setdefault(str(user_id), Bond())
+                bond.trust = float(soc.get("trust", bond.trust))
+                bond.attachment = float(soc.get("attachment", bond.attachment))
+                bond.familiarity = float(soc.get("familiarity", bond.familiarity))
+                bond.responsiveness = float(soc.get("responsiveness", bond.responsiveness))
+                bond.stage = str(soc.get("stage", bond.stage))
+            for item in data.get("episodic") or []:
+                m.memory.episodic.items.append(MemoryItem(
+                    text=str(item.get("text") or ""),
+                    importance=float(item.get("importance", 0.5)),
+                    t=float(item.get("t", 0.0)),
+                    confidence=float(item.get("confidence", 0.5)),
+                ))
+            for item in data.get("facts") or []:
+                m.memory.semantic.items.append(MemoryItem(
+                    text=str(item.get("text") or ""),
+                    importance=float(item.get("importance", 0.5)),
+                    t=float(item.get("t", 0.0)),
+                    confidence=float(item.get("confidence", 0.5)),
+                ))
+            session.turns = list(data.get("turns") or [])
+            try:
+                if hasattr(session, "emotion") and data.get("emotion"):
+                    session.emotion.load(data.get("emotion"))
+            except Exception:
+                pass
+            evo = data.get("evolution")
+            if evo:
+                try:
+                    for exp in getattr(session, "kernel", None).experiments:
+                        if getattr(exp, "name", "") == "evolution" and hasattr(exp, "load_state"):
+                            exp.load_state(evo)
+                            break
+                except Exception:
+                    pass
+            self._load_fly(user_id, session)
+            return True
+        except Exception:
+            return False

package/python/mindbase/session_window.py

@@ -0,0 +1,31 @@
+"""Cold / active / warm session window, inspired by Animus heartbeat sessions."""
+from __future__ import annotations
+
+
+class SessionWindow:
+    def __init__(self, warmth_s: float = 900.0):
+        self.warmth_s = float(warmth_s)
+        self.state = "cold"
+        self.last_active = 0.0
+        self.warm_until = 0.0
+
+    def touch(self, now: float) -> bool:
+        was_warm = self.state == "warm" and float(now) <= self.warm_until
+        self.state = "active"
+        self.last_active = float(now)
+        return bool(was_warm)
+
+    def finish(self, now: float) -> None:
+        self.state = "warm"
+        self.warm_until = float(now) + self.warmth_s
+
+    def tick(self, now: float) -> None:
+        if self.state == "warm" and float(now) > self.warm_until:
+            self.state = "cold"
+
+    def hint(self, now: float) -> str:
+        if self.state == "cold":
+            return ""
+        if self.state == "warm" and float(now) <= self.warm_until:
+            return "处于连续对话中，接着刚才说；不要重新自我介绍，不要重复问已经知道的信息。"
+        return ""

package/python/mindbase/shadow_eval.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import Dict, List
+
+from . import MindBase, MindConfig
+from .persona import Persona
+from .relationship_session import RelationshipSession
+
+
+def replay_numeric(texts: List[str], profile: Dict[str, float], seed: int = 1) -> Dict[str, float]:
+    mb = MindBase(MindConfig(seed=seed))
+    try:
+        Persona.from_profile(profile, seed=seed).apply_to(mb)
+    except Exception:
+        pass
+    s = RelationshipSession(mb)
+    for text in texts:
+        s.say(str(text), 0.2)
+    return {
+        "trust": round(float(mb.social.trust_for(s.user)), 4),
+        "identity": round(float(mb.self_model.identity), 4),
+        "social": round(float(mb.drives.values.get("social", 0.0)), 4),
+        "stress": round(float(mb.affect.stress), 4),
+        "memory": len(mb.memory.semantic.items) + len(mb.memory.episodic.items),
+    }
+
+
+def shadow_compare(texts: List[str], base: Dict[str, float], delta: Dict[str, float], seed: int = 1) -> Dict[str, object]:
+    from .character_profile import merge
+    a = replay_numeric(texts, base, seed=seed)
+    b = replay_numeric(texts, merge(base, delta), seed=seed)
+    return {
+        "n": len(texts),
+        "base": a,
+        "candidate": b,
+        "diff": {k: round(float(b[k]) - float(a[k]), 4) for k in a},
+    }
+
+
+def audit_user(base, delta, episodes, n: int = 10) -> dict:
+    texts = [str(x.get("text") or "") for x in episodes[-n:] if x.get("text")]
+    return shadow_compare(texts, base, delta) if texts else {"n": 0}