dsh-biocore 0.1.2 → 0.1.4

package/python/mindbase/addressing.py

@@ -0,0 +1,69 @@
+"""Cheap social-addressing inference.
+
+This is not a semantic world model. It only answers:
+"is this message plausibly aimed at her?"
+Explicit @/name is handled by the bridge; this fills the implicit gap:
+continuations after her reply, second-person questions, backchannels.
+"""
+from __future__ import annotations
+
+import re
+
+ALIASES = ("灰羽", "能天使", "阿能", "小乐", "蕾缪乐")
+_AT = re.compile(r"@[^\s(（]+")
+_SECOND_PERSON = ("你", "您")
+_QUESTION = ("吗", "呢", "怎么", "为什么", "啥", "什么", "哪", "谁", "吗？", "?", "？")
+_CONTINUE = ("然后", "所以", "那", "可是", "但是", "刚才", "继续", "你说", "你觉得", "你看")
+
+
+def infer_addressing(rows, text: str, speaker: str = "") -> dict:
+    t = str(text or "").strip()
+    low = t.lower()
+    score = 0.0
+    reasons = []
+    for a in ALIASES:
+        if a in t:
+            score = 1.0
+            reasons.append("name:" + a)
+            break
+    if score >= 1.0:
+        return {"score": 1.0, "addressed": True, "reasons": reasons}
+    ats = _AT.findall(t)
+    if ats:
+        # @ someone else is a strong negative unless an alias is also present
+        score -= 0.35
+        reasons.append("at_other")
+    prev = {}
+    try:
+        if len(rows) >= 2:
+            prev = rows[-2]
+    except Exception:
+        prev = {}
+    prev_reply = str(prev.get("reply") or "").strip() if isinstance(prev, dict) else ""
+    if prev_reply:
+        score += 0.35
+        reasons.append("after_her_reply")
+    if any(w in t for w in _SECOND_PERSON):
+        score += 0.20
+        reasons.append("second_person")
+    if any(w in t for w in _QUESTION):
+        score += 0.15
+        reasons.append("question")
+    if any(w in t for w in _CONTINUE):
+        score += 0.12
+        reasons.append("continuation")
+    if len(t) <= 8 and t and not ats:
+        score += 0.08
+        reasons.append("short")
+    # previous row spoken by someone else, current speaker is a different person:
+    # this is often a dyadic exchange, not aimed at her.
+    try:
+        if len(rows) >= 2:
+            psp = str(rows[-2].get("speaker") or "")
+            if psp and speaker and psp != speaker:
+                score -= 0.10
+                reasons.append("other_speaker")
+    except Exception:
+        pass
+    score = max(0.0, min(1.0, score))
+    return {"score": round(score, 3), "addressed": bool(score >= 0.55), "reasons": reasons}

package/python/mindbase/affect.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import random
+from typing import Dict
+
+from .config import MindConfig
+from .noise import clip, ou
+from .types import Appraisal
+
+
+class Affect:
+    """Fast affect (V/A/stress) + slow mood + neuromodulator scalars."""
+
+    def __init__(self, cfg: MindConfig, rng: random.Random):
+        self.cfg = cfg
+        self.rng = rng
+        self.v = 0.0
+        self.a = 0.5
+        self.dominance = 0.0
+        self.stress = 0.0
+        self.scar = 0.0
+        self.mood = 0.0
+        self.fatigue = 0.0
+        self.da = 0.5
+        self.oa = 0.5
+        self.ht = 0.5
+
+    def update(self, ap: Appraisal, drives, dt: float) -> None:
+        v_target = clip(0.60 * ap.valence + 0.20 * self.mood + 0.20 * ap.social, -1.0, 1.0)
+        a_target = clip(
+            0.40 + 0.30 * ap.novelty + 0.20 * ap.threat + 0.10 * (1.0 - drives.get("energy")),
+            0.0,
+            1.0,
+        )
+        stress_target = clip(
+            0.50 * ap.threat + 0.30 * max(0.0, -ap.valence) + 0.20 * (1.0 - drives.get("safety")),
+            0.0,
+            1.0,
+        )
+        theta_fast = 1.0 / max(self.cfg.affect_tau, 1e-6)
+        theta_stress = 1.0 / max(self.cfg.stress_tau, 1e-6)
+        theta_mood = 1.0 / max(self.cfg.mood_tau, 1e-6)
+        self.v = ou(self.v, v_target, theta_fast, self.cfg.noise_sigma, dt, self.rng)
+        self.a = ou(self.a, a_target, theta_fast, self.cfg.noise_sigma, dt, self.rng)
+        self.stress = ou(self.stress, stress_target, theta_stress, self.cfg.noise_sigma, dt, self.rng)
+        dominance_target = clip(0.5 * ap.agency + 0.25 * ap.control + 0.25 * (1.0 - ap.threat) - 0.2 * self.stress, -1.0, 1.0)
+        self.dominance = ou(self.dominance, dominance_target, theta_fast, self.cfg.noise_sigma * 0.5, dt, self.rng)
+        self.dominance = clip(self.dominance, -1.0, 1.0)
+        mood_target = clip(0.70 * self.v + 0.30 * self.mood, -1.0, 1.0)
+        self.mood = ou(self.mood, mood_target, theta_mood, self.cfg.noise_sigma * 0.5, dt, self.rng)
+        self.v = clip(self.v, -1.0, 1.0)
+        self.a = clip(self.a, 0.0, 1.0)
+        self.stress = clip(self.stress, 0.0, 1.0)
+        # acute load can recover; a slow scar accumulates under chronic stress
+        grow = 0.00002 * dt * max(0.0, self.stress - self.scar)
+        decay = 0.0000002 * dt * self.scar
+        self.scar = clip(self.scar + grow - decay, 0.0, 1.0)
+        self.mood = clip(self.mood, -1.0, 1.0)
+        # neuromodulators: DA tracks RPE, OA tracks arousal, 5-HT tracks patience
+        self.da = clip(self.da + 0.08 * (ap.rpe - 0.10 * self.da), 0.0, 1.0)
+        self.oa = clip(self.oa + 0.08 * (self.a - self.oa), 0.0, 1.0)
+        self.ht = clip(self.ht + 0.03 * ((1.0 - self.stress) - self.ht), 0.0, 1.0)
+
+    def update_structural_load(self, load: float, dt: float) -> None:
+        # crowded/overloaded circuitry adds metabolic fatigue
+        self.fatigue = clip(self.fatigue + 0.002 * max(0.0, float(load)) * (max(0.0, float(dt)) / 3600.0), 0.0, 1.0)
+
+    def update_self_efficacy(self, ase: float, dt: float) -> None:
+        # low allostatic self-efficacy accumulates fatigue
+        target = clip(1.0 - float(ase), 0.0, 1.0)
+        rate = min(1.0, max(0.0, dt) / (6.0 * 3600.0))
+        self.fatigue = clip(self.fatigue + (target - self.fatigue) * rate, 0.0, 1.0)
+
+    def snapshot(self) -> Dict[str, float]:
+        return {
+            "v": round(self.v, 4),
+            "a": round(self.a, 4),
+            "dominance": round(self.dominance, 4),
+            "stress": round(self.stress, 4),
+            "scar": round(self.scar, 4),
+            "mood": round(self.mood, 4),
+            "fatigue": round(self.fatigue, 3),
+            "da": round(self.da, 4),
+            "oa": round(self.oa, 4),
+            "ht": round(self.ht, 4),
+        }

package/python/mindbase/affective.py

@@ -0,0 +1,111 @@
+"""Biological affect injection and empathy hooks.
+
+Emotions can be injected as internal states (not text labels).  A user-emotion
+signal can be mirrored with a learnable empathy gain.  The base remains the
+source of state; the LLM only expresses it.
+"""
+from __future__ import annotations
+
+from typing import Dict, Tuple
+
+from .noise import clip
+from .emotion_schema import PAD_PROTOTYPES, pad_for_emotion, emotion_readout
+
+
+# prototype affect targets: valence, arousal, stress, oxytocin, cortisol
+EMOTION_PROFILES: Dict[str, Dict[str, float]] = {
+    "joy": {"v": 0.8, "a": 0.6, "stress": -0.2, "oxy": 0.2, "cortisol": -0.1},
+    "sadness": {"v": -0.7, "a": 0.25, "stress": 0.3, "oxy": -0.1, "cortisol": 0.1},
+    "fear": {"v": -0.6, "a": 0.8, "stress": 0.7, "oxy": -0.1, "cortisol": 0.3},
+    "anger": {"v": -0.5, "a": 0.75, "stress": 0.6, "oxy": -0.1, "cortisol": 0.2},
+    "surprise": {"v": 0.1, "a": 0.8, "stress": 0.2, "oxy": 0.0, "cortisol": 0.0},
+    "disgust": {"v": -0.6, "a": 0.5, "stress": 0.4, "oxy": -0.1, "cortisol": 0.1},
+    "love": {"v": 0.8, "a": 0.4, "stress": -0.2, "oxy": 0.4, "cortisol": -0.1},
+    "loneliness": {"v": -0.5, "a": 0.3, "stress": 0.4, "oxy": -0.2, "cortisol": 0.1},
+    "calm": {"v": 0.4, "a": 0.2, "stress": -0.4, "oxy": 0.2, "cortisol": -0.2},
+    "anxiety": {"v": -0.4, "a": 0.7, "stress": 0.6, "oxy": -0.1, "cortisol": 0.2},
+    "shame": {"v": -0.5, "a": 0.4, "stress": 0.5, "oxy": -0.1, "cortisol": 0.2},
+    "guilt": {"v": -0.4, "a": 0.4, "stress": 0.4, "oxy": 0.0, "cortisol": 0.15},
+    "pride": {"v": 0.6, "a": 0.5, "stress": -0.1, "oxy": 0.1, "cortisol": 0.0},
+    "gratitude": {"v": 0.7, "a": 0.35, "stress": -0.2, "oxy": 0.3, "cortisol": -0.1},
+    "hope": {"v": 0.5, "a": 0.45, "stress": -0.1, "oxy": 0.1, "cortisol": 0.0},
+    "boredom": {"v": -0.2, "a": 0.15, "stress": 0.1, "oxy": -0.1, "cortisol": 0.0},
+}
+
+
+def inject_emotion(mind, emotion: str, intensity: float = 0.5, blend: float = 0.6) -> Dict[str, object]:
+    """Inject a biological emotion into affect/physiology, not just a label."""
+    name = str(emotion).lower()
+    prof = EMOTION_PROFILES.get(name)
+    if prof is None:
+        return {"injected": None, "emotion": name}
+    k = clip(float(intensity), 0.0, 1.0) * clip(float(blend), 0.0, 1.0)
+    a = mind.affect
+    pad = pad_for_emotion(name)
+    a.v = clip(a.v + k * (pad[0] - a.v), -1.0, 1.0)
+    a.a = clip(a.a + k * (pad[1] - a.a), 0.0, 1.0)
+    if hasattr(a, "dominance"):
+        a.dominance = clip(a.dominance + k * (pad[2] - a.dominance), -1.0, 1.0)
+    a.stress = clip(a.stress + k * (prof["stress"] - a.stress), 0.0, 1.0)
+    try:
+        p = mind.physiology
+        p.oxytocin = clip(p.oxytocin + k * prof["oxy"], 0.0, 1.0)
+        p.cortisol = clip(p.cortisol + k * prof["cortisol"], 0.0, 1.0)
+    except Exception:
+        pass
+    mind.last_injected_emotion = {"emotion": name, "intensity": round(k, 4)}
+    return {"injected": name, "intensity": round(k, 4),
+            "affect": {"v": round(a.v, 4), "a": round(a.a, 4),
+                       "dominance": round(float(getattr(a, "dominance", 0.0)), 4),
+                       "stress": round(a.stress, 4)}}
+
+
+def empathize(mind, user_emotion: str, intensity: float = 0.5,
+              empathy_gain: float = 0.35) -> Dict[str, object]:
+    """Mirror a user emotion with a learnable gain; not a hard rule."""
+    return inject_emotion(mind, user_emotion, intensity=float(intensity) * float(empathy_gain), blend=0.7)
+
+
+def perceive_emotion_lexicon(text: str) -> Tuple[str, float]:
+    """Small deterministic fallback sensor; an LLM/classifier can replace it."""
+    t = str(text or "")
+    table = [
+        ("sadness", ("难过", "伤心", "累", "崩溃", "哭", "失落")),
+        ("anxiety", ("焦虑", "紧张", "担心", "害怕", "慌")),
+        ("anger", ("生气", "愤怒", "烦", "滚", "讨厌")),
+        ("joy", ("开心", "高兴", "笑", "太好了", "喜欢")),
+        ("loneliness", ("孤独", "没人", "一个人", "寂寞")),
+        ("love", ("爱你", "想你", "抱抱", "亲亲")),
+        ("gratitude", ("谢谢", "感谢", "麻烦你")),
+    ]
+    for emotion, words in table:
+        for w in words:
+            if w in t:
+                return emotion, 0.6
+    return "neutral", 0.0
+
+
+def inject_affect(mind, valence: float, arousal: float, dominance: float = 0.0,
+                  intensity: float = 0.8, blend: float = 0.7) -> Dict[str, object]:
+    """Inject a numeric PAD reading. No categorical label is involved."""
+    v = max(-1.0, min(1.0, float(valence)))
+    a = max(0.0, min(1.0, float(arousal)))
+    d = max(-1.0, min(1.0, float(dominance)))
+    k = clip(float(intensity), 0.0, 1.0) * clip(float(blend), 0.0, 1.0)
+    # negativity bias: negative events have a stronger pull than positive ones
+    k *= 1.25 if v < 0 else 0.90
+    aff = mind.affect
+    aff.v = clip(aff.v + k * (v - aff.v), -1.0, 1.0)
+    aff.a = clip(aff.a + k * (a - aff.a), 0.0, 1.0)
+    if hasattr(aff, "dominance"):
+        aff.dominance = clip(aff.dominance + k * (d - aff.dominance), -1.0, 1.0)
+    aff.stress = clip(aff.stress + k * max(0.0, -v) * 0.45, 0.0, 1.0)
+    try:
+        p = mind.physiology
+        p.oxytocin = clip(p.oxytocin + k * max(0.0, v) * 0.03, 0.0, 1.0)
+        p.cortisol = clip(p.cortisol + k * max(0.0, -v) * 0.03, 0.0, 1.0)
+    except Exception:
+        pass
+    return {"valence": round(aff.v, 4), "arousal": round(aff.a, 4),
+            "dominance": round(float(getattr(aff, "dominance", 0.0)), 4),
+            "stress": round(aff.stress, 4)}

package/python/mindbase/allostasis.py

@@ -0,0 +1,28 @@
+"""Slow allostatic load: chronic stress accumulates and recovers."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+def _clip(x, lo=0.0, hi=1.0):
+    return max(lo, min(hi, float(x)))
+
+
+@dataclass
+class AllostaticLoad:
+    load: float = 0.0
+    tau_recovery_s: float = 12 * 3600.0
+
+    def update(self, dt_s: float, stress: float, fatigue: float,
+               sleep_debt: float, sleep_quality: float = 0.5) -> float:
+        dt = max(0.0, float(dt_s))
+        if dt <= 0:
+            return self.load
+        drive = 0.5 * _clip(stress) + 0.3 * _clip(fatigue) + 0.2 * _clip(sleep_debt)
+        load_up = 0.0025 * max(0.0, drive - 0.25) * (dt / 60.0)
+        recover = (1.0 - _clip(sleep_quality)) * (dt / max(1.0, self.tau_recovery_s)) * 0.20
+        self.load = _clip(self.load + load_up - recover)
+        return round(self.load, 4)
+
+    def stress_bias(self) -> float:
+        return round(0.10 * self.load, 4)

package/python/mindbase/appraisal.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import random
+from collections import deque
+from typing import Deque
+
+from .config import MindConfig
+from .lexicon import text_affect
+from .noise import clip, jaccard
+from .types import Appraisal, Event
+
+
+def occ_emotion(goal_congruence: float, certainty: float, agency: float, coping: float, norm: float) -> str:
+    """OCC-style label; heuristic, not a full OCC implementation."""
+    if goal_congruence >= 0.0:
+        if agency > 0.25:
+            return "pride"
+        if agency < -0.25:
+            return "gratitude" if coping >= 0.45 else "relief"
+        return "joy" if certainty >= 0.55 else "hope"
+    if agency < -0.25:
+        return "anger" if certainty >= 0.60 else "fear"
+    if agency > 0.25:
+        return "shame" if norm < 0.45 else "guilt"
+    return "distress" if coping < 0.40 else "sadness"
+
+
+class Appraiser:
+    """Turns an event into appraisal: novelty, relevance, control, RPE, threat.
+
+    This is deliberately a heuristic. The calibration step later replaces
+    text_affect() with ANEW / NRC-VAD / language-specific norms.
+    """
+
+    def __init__(self, cfg: MindConfig, rng: random.Random):
+        self.cfg = cfg
+        self.rng = rng
+        self.expectation = 0.0
+        self.recent: Deque[str] = deque(maxlen=24)
+
+    def _novelty(self, text: str) -> float:
+        if not text:
+            return 0.3
+        now = set(text)
+        if not self.recent:
+            return 0.55
+        best = 0.0
+        for old in self.recent:
+            best = max(best, jaccard(now, set(old)))
+        return clip(1.0 - best, 0.0, 1.0)
+
+    def appraise(self, ev: Event, state=None, social=None) -> Appraisal:
+        v, a = text_affect(ev.text)
+        if ev.valence is not None:
+            v = clip(ev.valence, -1.0, 1.0)
+        if ev.arousal is not None:
+            a = clip(ev.arousal, 0.0, 1.0)
+        novelty = self._novelty(ev.text)
+        relevance = 0.5 if ev.relevance is None else clip(ev.relevance, 0.0, 1.0)
+        control = 0.5 if ev.control is None else clip(ev.control, 0.0, 1.0)
+        social_sig = 0.0 if ev.social is None else clip(ev.social, -1.0, 1.0)
+        rpe = clip(v - self.expectation, -2.0, 2.0)
+        threat = clip(max(0.0, -v) * (1.0 - control), 0.0, 1.0)
+        goal_relevance = relevance
+        goal_congruence = clip(v, -1.0, 1.0)
+        if ev.kind == "self_action" or ev.speaker in ("self", "me"):
+            agency = 1.0
+        elif ev.kind in ("tick", "observation"):
+            agency = 0.0
+        else:
+            agency = -1.0
+        certainty = clip(1.0 - 0.6 * novelty, 0.0, 1.0)
+        willpower = 0.5
+        energy = 0.5
+        if state is not None:
+            will = getattr(state, "will", None)
+            willpower = float(getattr(will, "willpower", 0.5))
+            drives = getattr(state, "drives", {})
+            energy = float(getattr(drives, "energy", 0.5))
+        coping = clip(0.5 * control + 0.3 * willpower + 0.2 * energy, 0.0, 1.0)
+        norm = clip(1.0 - 0.5 * threat - 0.3 * max(0.0, -social_sig), 0.0, 1.0)
+        self.expectation = 0.85 * self.expectation + 0.15 * v
+        if ev.text:
+            self.recent.append(ev.text)
+        return Appraisal(
+            novelty=novelty,
+            relevance=relevance,
+            control=control,
+            rpe=rpe,
+            social=social_sig,
+            threat=threat,
+            valence=v,
+            arousal=a,
+            goal_relevance=goal_relevance,
+            goal_congruence=goal_congruence,
+            agency=agency,
+            certainty=certainty,
+            coping_potential=coping,
+            norm_compliance=norm,
+            occ_emotion=occ_emotion(goal_congruence, certainty, agency, coping, norm),
+        )

package/python/mindbase/attachment.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from typing import Dict
+
+from .noise import clip
+
+
+class Attachment:
+    """Two-axis attachment: anxiety (fear of abandonment) and avoidance (distance)."""
+
+    def __init__(self):
+        self.trait_anxiety = 0.30
+        self.trait_avoidance = 0.30
+        self.anxiety = 0.30
+        self.avoidance = 0.30
+        self.lr = 0.02
+
+    def update(self, social_signal: float, prediction_error: float, dt: float, fatigue: float = 0.0, scar: float = 0.0) -> None:
+        sig = float(social_signal)
+        pe = abs(float(prediction_error))
+        rate = min(1.0, max(0.0, dt) / 600.0)
+        # negative social signal and unpredictable care raise anxiety
+        self.anxiety = clip(self.anxiety + self.lr * rate * (max(0.0, -sig) + 0.20 * pe + 0.10 * float(fatigue) + 0.10 * float(scar)), 0.0, 1.0)
+        # repeated negative/unpredictable care also raises avoidance
+        self.avoidance = clip(self.avoidance + self.lr * rate * (max(0.0, -sig) + 0.10 * pe + 0.08 * float(fatigue) + 0.15 * float(scar)), 0.0, 1.0)
+        # positive, predictable care slowly repairs both
+        if sig > 0:
+            self.anxiety = clip(self.anxiety - self.lr * rate * sig, self.trait_anxiety, 1.0)
+            self.avoidance = clip(self.avoidance - self.lr * rate * sig, self.trait_avoidance, 1.0)
+
+    def action_kind(self) -> str:
+        return {"secure": "communicate", "anxious": "seek_help", "avoidant": "avoid", "fearful": "protect"}[self.style()]
+
+    def memory_bias(self) -> float:
+        # anxious attachment prioritizes relational/threat cues
+        return 1.0 + 0.30 * float(self.anxiety)
+
+    def initiation_bias(self) -> float:
+        return {"secure": 1.0, "anxious": 1.20, "avoidant": 0.70, "fearful": 0.85}[self.style()]
+
+    def style(self) -> str:
+        a, v = self.anxiety >= 0.55, self.avoidance >= 0.55
+        if a and v: return "fearful"
+        if a: return "anxious"
+        if v: return "avoidant"
+        return "secure"
+
+    def snapshot(self) -> Dict[str, object]:
+        return {"anxiety": round(self.anxiety, 3), "avoidance": round(self.avoidance, 3), "style": self.style()}

package/python/mindbase/attention.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import Dict
+
+from .noise import clip
+from .types import Appraisal, Event
+
+
+class Attention:
+    """A minimal salience gate: what reaches working memory / focus."""
+
+    def __init__(self):
+        self.focus: str | None = None
+        self.last_score = 0.0
+
+    def update(self, ev: Event, ap: Appraisal, drives) -> float:
+        score = (
+            0.25 * ap.novelty
+            + 0.25 * ap.relevance
+            + 0.20 * ap.threat
+            + 0.20 * abs(ap.valence)
+            + 0.10 * abs(ap.social)
+        )
+        self.last_score = clip(score, 0.0, 1.0)
+        if self.last_score >= 0.45 and ev.speaker:
+            self.focus = ev.speaker
+        return self.last_score
+
+    def snapshot(self) -> Dict[str, object]:
+        return {"focus": self.focus, "last_score": round(self.last_score, 4)}

package/python/mindbase/autonomy.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import math
+import random
+from typing import Dict
+
+from .config import MindConfig
+from .noise import clip
+
+
+class Autonomy:
+    """Endogenous accumulator: no external trigger required to act."""
+
+    def __init__(self, cfg: MindConfig, rng: random.Random):
+        self.cfg = cfg
+        self.rng = rng
+        self.h = 0.0
+        self.last_spoke = -1e9
+        self.gain = 1.0
+        # learned meta-gain, not a hand-tuned rule
+        self.allostatic_gain = 0.05
+        self.gain_lr = 0.01
+        # learned impulse threshold, initialized from config
+        self.threshold = cfg.autonomy_threshold
+        self.threshold_lr = 0.002
+        self.tau = cfg.autonomy_tau
+        self.cooldown = cfg.autonomy_cooldown
+        self.tau_lr = 0.005
+        self.activity_ema = 0.0
+        self.adapt_lr = float(getattr(cfg, "autonomy_adapt_lr", 0.004))
+        self.viability_target = float(getattr(cfg, "autonomy_viability_target", 0.90))
+        self.social_target = float(getattr(cfg, "autonomy_social_target", 0.50))
+        self.activity_target = float(getattr(cfg, "autonomy_activity_target", 0.30))
+
+    def tick(self, dt: float, clock, drives, mood: float, allostatic: float = 0.0, fatigue: float = 0.0, attachment_bias: float = 1.0) -> None:
+        if dt <= 0:
+            return
+        brake = max(0.2, 1.0 - 0.5 * float(fatigue))
+        drive = brake * float(attachment_bias) * self.gain * (clock.drive + 0.20 * drives.get("social") + 0.20 * max(0.0, mood) + self.allostatic_gain * float(allostatic))
+        tau = max(self.tau, 1e-6)
+        noise = self.rng.gauss(0.0, 0.01) * math.sqrt(dt / tau)
+        self.h = self.h * math.exp(-dt / tau) + drive * (dt / tau) + noise
+
+    def due(self, now: float, asleep: bool) -> bool:
+        if asleep:
+            return False
+        return self.h > self.threshold and (now - self.last_spoke) > self.cooldown
+
+    def adapt(self, now: float, viability: float, social_need: float, stress: float,
+              spoke: bool, dt: float) -> float:
+        """Intrinsic homeostatic adaptation of the impulse threshold. No external labels."""
+        if dt <= 0:
+            return self.threshold
+        spoke_f = 1.0 if spoke else 0.0
+        self.activity_ema += 0.02 * (spoke_f - self.activity_ema)
+        # low viability -> raise threshold (be conservative); high social need -> lower
+        err = (self.viability_target - float(viability)) - 0.5 * (float(social_need) - self.social_target)
+        err += 0.15 * (self.activity_target - self.activity_ema)
+        rate = self.adapt_lr * min(1.0, max(0.1, float(dt) / 60.0))
+        self.threshold = clip(self.threshold + rate * err, 0.20, 2.0)
+        return self.threshold
+
+    def on_speak(self, now: float) -> None:
+        self.h *= 0.30
+        self.last_spoke = now
+
+    def learn_from_feedback(self, rpe: float, allostatic: float) -> None:
+        # RPE meta-gradient: raise/lower allostatic sensitivity from outcome
+        self.allostatic_gain = clip(
+            self.allostatic_gain + self.gain_lr * float(rpe) * float(allostatic), 0.0, 0.5
+        )
+        # outcome learning of the impulse threshold
+        self.threshold = clip(
+            self.threshold - self.threshold_lr * float(rpe) * min(1.0, abs(self.h)), 0.35, 2.0
+        )
+        # positive outcome -> faster accumulation / shorter cooldown
+        self.tau = clip(self.tau * (1.0 - self.tau_lr * float(rpe)), 60.0, 7200.0)
+        self.cooldown = clip(self.cooldown - 20.0 * float(rpe), 10.0, 3600.0)
+
+    def snapshot(self) -> Dict[str, float]:
+        return {"h": round(self.h, 4), "last_spoke": round(self.last_spoke, 1), "allostatic_gain": round(self.allostatic_gain, 4), "threshold": round(self.threshold, 4), "tau": round(self.tau, 1), "cooldown": round(self.cooldown, 1), "viability_target": round(self.viability_target, 4), "social_target": round(self.social_target, 4), "activity_target": round(self.activity_target, 4), "activity_ema": round(self.activity_ema, 4)}