dsh-biocore 0.1.2 → 0.1.4

package/python/mindbase/autonomy_meta.py

@@ -0,0 +1,91 @@
+"""Meta-evolution of the autonomy fitness weights.
+
+The selection criterion is itself mutable.  Outer loop mutates fitness weights;
+inner loop runs quality-diversity over behavior genomes and reports archive
+size / viability / entropy.  This removes the hand-set fitness rule.
+"""
+from __future__ import annotations
+
+import random
+from typing import Dict, List
+
+from .autonomy_bench import run_autonomy
+from .autonomy_evolve import run_qd
+from .config import MindConfig
+from .diversity import js_divergence
+
+
+def normalize(w: Dict[str, float]) -> Dict[str, float]:
+    keys = ("viability", "recovery", "entropy", "spont", "penalty")
+    vals = {k: max(1e-6, float(w.get(k, 0.1))) for k in keys}
+    total = sum(vals.values())
+    return {k: round(v / total, 5) for k, v in vals.items()}
+
+
+def mutate(w: Dict[str, float], rng: random.Random, scale: float = 0.15) -> Dict[str, float]:
+    return normalize({k: float(w.get(k, 0.2)) * (1.0 + rng.gauss(0, scale)) for k in ("viability", "recovery", "entropy", "spont", "penalty")})
+
+
+def _dist(counts: Dict[str, int]) -> Dict[str, float]:
+    total = sum(counts.values())
+    return {k: v / total for k, v in counts.items()} if total else {}
+
+
+def evaluate_weights(w: Dict[str, float], inner_generations: int = 2, population: int = 4,
+                     steps: int = 120, seed: int = 1,
+                     seeds: tuple = (1, 2, 3)) -> Dict[str, object]:
+    out = run_qd(generations=inner_generations, population=population, steps=steps, seed=seed, weights=w)
+    best = out.get("best") or {}
+    descs = out.get("descriptors") or []
+    jsd = 0.0
+    genome = best.get("genome") if isinstance(best, dict) else None
+    if genome:
+        dists = []
+        for s in seeds:
+            cfg = MindConfig(seed=int(s), autonomy_threshold=float(genome.get("autonomy_threshold", 0.9)),
+                             volition_temperature=float(genome.get("volition_temperature", 0.0)),
+                             autonomy_adapt_lr=float(genome.get("autonomy_adapt_lr", 0.004)),
+                             noise_sigma=float(genome.get("noise_sigma", 0.03)))
+            r = run_autonomy(steps=steps, cfg=cfg, perturb=False)
+            dists.append(_dist(r["actions"]))
+        vals = []
+        for i in range(len(dists)):
+            for j in range(i + 1, len(dists)):
+                vals.append(js_divergence(dists[i], dists[j]))
+        jsd = sum(vals) / max(1, len(vals))
+    score = (0.35 * min(1.0, float(out.get("archive_size", 0)) / 25.0)
+             + 0.30 * float(best.get("viability", 0.0))
+             + 0.15 * float(best.get("entropy", 0.0))
+             + 0.15 * min(1.0, jsd * 10.0)
+             + 0.05 * float(best.get("spontaneous", 0.0)))
+    return {"weights": w, "score": round(score, 5), "archive_size": out.get("archive_size", 0),
+            "best": best, "descriptors": descs, "jsd_mean": round(jsd, 5)}
+
+
+def run_meta(generations: int = 4, candidates: int = 4, inner_generations: int = 2,
+             population: int = 4, steps: int = 120, seed: int = 1,
+             seeds: tuple = (1, 2, 3)) -> Dict[str, object]:
+    rng = random.Random(int(seed))
+    initial = [
+        {"viability": 1.0, "recovery": 0.5, "entropy": 0.3, "spont": 0.2, "penalty": 0.5},
+        {"viability": 0.5, "recovery": 0.5, "entropy": 1.0, "spont": 1.0, "penalty": 0.5},
+        {"viability": 2.0, "recovery": 1.0, "entropy": 0.1, "spont": 0.1, "penalty": 1.0},
+        {"viability": 1.0, "recovery": 2.0, "entropy": 0.2, "spont": 0.2, "penalty": 0.5},
+    ]
+    pool = [normalize(w) for w in initial[:max(1, candidates)]]
+    history = []
+    for gen in range(max(1, int(generations))):
+        results = [evaluate_weights(w, inner_generations=inner_generations, population=population,
+                                    steps=steps, seed=seed, seeds=seeds) for w in pool]
+        results.sort(key=lambda x: x["score"], reverse=True)
+        pool = [r["weights"] for r in results[:max(1, min(2, len(results)))]]
+        history.append({"generation": gen + 1, "scores": [r["score"] for r in results],
+                        "archive_sizes": [r["archive_size"] for r in results],
+                        "jsd": [r.get("jsd_mean", 0.0) for r in results],
+                        "weights": pool})
+        while len(pool) < max(1, int(candidates)):
+            pool.append(mutate(rng.choice(pool), rng))
+    final = evaluate_weights(pool[0], inner_generations=inner_generations, population=population,
+                             steps=steps, seed=seed, seeds=seeds)
+    return {"best_weights": final["weights"], "best_score": final["score"],
+            "best": final["best"], "history": history}

package/python/mindbase/base_only.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import Iterable, List, Optional
+
+from .config import MindConfig
+from .engine import MindBase
+from .types import Event, Outcome
+
+
+def run(events: Optional[Iterable[Event]] = None) -> List[Outcome]:
+    """Base-only mode: no LLM, no client, only the base's own decisions."""
+    mb = MindBase(MindConfig(seed=700))
+    evs = list(events or [
+        Event(text="在吗", speaker="A", directed=True, ts=0),
+        Event(text="今天有点累", speaker="A", ts=60),
+        Event(text="老板，出来玩吗", speaker="A", directed=True, ts=120),
+        Event(kind="tick", ts=180),
+    ])
+    return mb.run(evs)
+
+
+def main() -> None:
+    for out in run():
+        print(out.t, out.action, out.reason, out.prompt_state.get("relationship"))
+
+
+if __name__ == "__main__":
+    main()

package/python/mindbase/benchmark.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from typing import Dict
+
+from .grid_world import EmbodiedLoop, GridWorld
+from .relationship_session import RelationshipSession
+
+
+def run(stress: bool = False, extreme: bool = False) -> Dict[str, object]:
+    from . import MindBase, MindConfig
+
+    # 1. autonomy: can it act without being addressed and stay viable?
+    mb1 = MindBase(MindConfig(seed=2000))
+    noise = 0.60 if extreme else (0.40 if stress else 0.10)
+    shock_every = 50 if stress else 100
+    a = EmbodiedLoop(mb1, GridWorld(seed=1, noise=noise)).run(300, shock_every)
+    autonomy = {
+        "initiative": a["autonomy"]["initiative"],
+        "survival": a["energy"],
+        "viability": a["viability"],
+        "pass": a["autonomy"]["initiative"] > 0.5 and a["energy"] > 0.2 and a["viability"] >= 0.6,
+    }
+
+    # 2. long-term memory: cross-day recall
+    mb2 = MindBase(MindConfig(seed=2001))
+    s = RelationshipSession(mb2)
+    s.say("我叫阿明，我喜欢猫", 0.5)
+    s.say("今天有点难过", 0.3)
+    s.day_break(24 * 7 if stress else 24)
+    recall = s.recall("阿明")
+    memory = {"recall": recall, "pass": bool(recall and "阿明" in recall)}
+
+    # 2b. memory interference: newer similar fact must supersede the old one
+    mb2b = MindBase(MindConfig(seed=2002))
+    sb = RelationshipSession(mb2b)
+    sb.say("我的名字是阿明", 0.8)
+    sb.say("我的名字是小华", 0.8)
+    recalled = sb.recall("名字")
+    interference = {"recall": recalled, "pass": bool(recalled and "小华" in recalled and "阿明" not in recalled)}
+
+    # 3. identity persistence: conflict then repair
+    before = mb2.self_model.identity
+    for _ in range(15 if extreme else (5 if stress else 1)):
+        s.say("你根本不懂我", -1.0)
+    low = mb2.self_model.identity
+    s.auto_repair(max_rounds=5 if extreme else 20)
+    after = mb2.self_model.identity
+    identity = {
+        "before": round(before, 3), "after_conflict": round(low, 3), "after_repair": round(after, 3),
+        "pass": after > 0.45 and abs(after - before) < 0.25,
+    }
+
+    # 4. relationship continuity: trust does not collapse after conflict+repair
+    rel = {"trust": round(mb2.social.trust_for("A"), 3), "stage": mb2.social.stage("A")}
+    rel["pass"] = rel["trust"] > 0.3
+
+    checks = [autonomy["pass"], memory["pass"], interference["pass"], identity["pass"], rel["pass"]]
+    return {
+        "autonomy": autonomy, "memory": memory, "interference": interference, "identity": identity, "relationship": rel,
+        "score": round(sum(checks) / len(checks), 3), "pass": all(checks),
+    }

package/python/mindbase/bio_adaptation.py

@@ -0,0 +1,274 @@
+"""Biological parameter adaptation, not prompt/persona iteration.
+
+The LLM can propose small trait deltas from interaction evidence. The bio layer
+clamps them, drifts them, persists them, and feeds the updated numbers back into
+the next prompt. This is the closed loop: language -> bio -> language.
+"""
+from __future__ import annotations
+
+import json
+import math
+import time
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+
+from .noise import clip
+
+TRAITS = (
+    "O", "C", "E", "A", "N",
+    "stress_reactivity", "recovery_rate", "social_baseline",
+    "energy_baseline", "curiosity_baseline", "safety_baseline",
+    "da_baseline", "oa_baseline", "ht_baseline", "autonomy_gain",
+)
+
+
+@dataclass
+class BioProfile:
+    traits: dict = field(default_factory=dict)
+    version: int = 1
+    evidence: int = 0
+    last_update: float = 0.0
+    baseline: dict = field(default_factory=dict)
+    stress_load: float = 0.0
+    last_tick: float = 0.0
+    noise_values: dict = field(default_factory=dict)
+    noise_chaos: float = 0.5
+    last_noise_tick: float = 0.0
+    noise_echo: float = 0.0
+    echo_trace: float = 0.0
+    last_echo_tick: float = 0.0
+    persona_version: str = ""
+
+    def __post_init__(self):
+        if not self.traits:
+            self.traits = {k: 0.5 for k in TRAITS}
+        if not self.baseline:
+            self.baseline = dict(self.traits)
+
+    @classmethod
+    def from_mind(cls, mind) -> "BioProfile":
+        p = getattr(mind, "persona", None)
+        traits = {}
+        for k in TRAITS:
+            try:
+                traits[k] = float(getattr(p, k))
+            except Exception:
+                traits[k] = 0.5
+        return cls(traits=traits, baseline=dict(traits))
+
+    def nudge(self, deltas: dict, confidence: float = 0.5) -> dict:
+        c = clip(confidence, 0.0, 1.0)
+        lr = 0.12 * c
+        for k, dv in dict(deltas or {}).items():
+            if k not in TRAITS:
+                continue
+            try:
+                dv = clip(float(dv), -0.02, 0.02)
+            except Exception:
+                continue
+            self.traits[k] = clip(float(self.traits[k]) + lr * dv, 0.0, 1.0)
+        self.version += 1
+        self.evidence += 1
+        self.last_update = time.time()
+        return dict(self.traits)
+
+    def experience(self, reward: float = 0.5, valence: float = 0.0,
+                   stress: float = 0.2, social: float = 0.5) -> dict:
+        """Slow learning from actual outcomes; LLM proposal is only one input."""
+        r = clip(reward, 0.0, 1.0)
+        v = clip(valence, -1.0, 1.0)
+        st = clip(stress, 0.0, 1.0)
+        so = clip(social, 0.0, 1.0)
+        lr = 0.004
+        # positive + low stress -> recovery/safety/social up
+        if r >= 0.55 and st < 0.65:
+            self.traits["recovery_rate"] = clip(self.traits["recovery_rate"] + lr * (r - 0.5), 0.0, 1.0)
+            self.traits["safety_baseline"] = clip(self.traits["safety_baseline"] + lr * (r - 0.5) * 0.8, 0.0, 1.0)
+            self.traits["social_baseline"] = clip(self.traits["social_baseline"] + lr * (r - 0.5) * 0.6 * (0.4 + so), 0.0, 1.0)
+        elif r < 0.45 and st > 0.6:
+            self.traits["stress_reactivity"] = clip(self.traits["stress_reactivity"] + lr * (0.5 - r) * 0.7, 0.0, 1.0)
+            self.traits["recovery_rate"] = clip(self.traits["recovery_rate"] - lr * (0.5 - r) * 0.4, 0.0, 1.0)
+        if v > 0.2:
+            self.traits["curiosity_baseline"] = clip(self.traits["curiosity_baseline"] + lr * 0.4 * v, 0.0, 1.0)
+        self.version += 1
+        self.last_update = time.time()
+        return dict(self.traits)
+
+    def drift(self, rate: float = 0.002) -> None:
+        for k in TRAITS:
+            self.traits[k] = clip(float(self.traits[k]) + rate * (float(self.baseline[k]) - float(self.traits[k])), 0.0, 1.0)
+
+    def apply_to_mind(self, mind) -> None:
+        p = getattr(mind, "persona", None)
+        if p is None:
+            return
+        for k, v in self.traits.items():
+            if hasattr(p, k):
+                try:
+                    setattr(p, k, clip(float(v), 0.0, 1.0))
+                except Exception:
+                    pass
+        # do not reset current affect/drives; only move their baselines slowly
+        try:
+            mind.drives.values["social"] = clip(0.995 * float(mind.drives.values.get("social", 0.5)) + 0.005 * float(self.traits["social_baseline"]), 0.0, 1.0)
+            mind.drives.values["curiosity"] = clip(0.995 * float(mind.drives.values.get("curiosity", 0.5)) + 0.005 * float(self.traits["curiosity_baseline"]), 0.0, 1.0)
+            mind.drives.values["energy"] = clip(0.995 * float(mind.drives.values.get("energy", 0.5)) + 0.005 * float(self.traits["energy_baseline"]), 0.0, 1.0)
+        except Exception:
+            pass
+
+    def _noise_engine(self):
+        eng = getattr(self, "_noise_eng", None)
+        if eng is None:
+            from .bio_noise import BioNoise
+            eng = BioNoise(2026)
+            eng.values.update({k: float(v) for k, v in (self.noise_values or {}).items()})
+            eng.last_chaos = float(self.noise_chaos or 0.5)
+            self._noise_eng = eng
+        return eng
+
+    def update_echo(self, instant: float, now: float | None = None,
+                    tau_s: float = 180.0) -> float:
+        """Echo propagation with attenuation: e_t = a*e_(t-1) + (1-a)*instant."""
+        now = time.time() if now is None else float(now)
+        if float(self.last_echo_tick or 0.0) <= 0.0:
+            dt = 5.0
+        else:
+            dt = max(0.0, min(600.0, now - float(self.last_echo_tick)))
+        a = math.exp(-dt / max(1.0, float(tau_s)))
+        self.echo_trace = clip(a * float(self.echo_trace or 0.0) + (1.0 - a) * float(instant), -1.0, 1.0)
+        self.noise_echo = self.echo_trace
+        self.last_echo_tick = now
+        return self.echo_trace
+
+    def step_noise(self, now: float | None = None) -> dict:
+        now = time.time() if now is None else float(now)
+        eng = self._noise_engine()
+        if float(self.last_noise_tick or 0.0) <= 0.0:
+            dt = 1.0
+        else:
+            dt = max(0.0, min(30.0, now - float(self.last_noise_tick)))
+        vals = eng.step(dt)
+        self.noise_values = {k: round(float(v), 4) for k, v in vals.items()}
+        self.noise_chaos = round(float(eng.last_chaos), 4)
+        self.last_noise_tick = now
+        return dict(self.noise_values)
+
+    def tick(self, mind, now: float | None = None, noise: bool = True) -> dict:
+        """Stress hysteresis: rise fast, recover slowly. This is the missing inertia."""
+        now = time.time() if now is None else float(now)
+        try:
+            stress = clip(float(getattr(mind.affect, "stress", 0.2)), 0.0, 1.0)
+        except Exception:
+            stress = 0.2
+        if float(self.last_tick or 0.0) <= 0.0:
+            dt = 0.0
+        else:
+            dt = max(0.0, now - float(self.last_tick))
+        # recovery time: 2h base, slower when recovery_rate is low
+        tau_s = 2.0 * 3600.0 + 4.0 * 3600.0 * (1.0 - clip(float(self.traits.get("recovery_rate", 0.5)), 0.0, 1.0))
+        if dt > 0.0:
+            self.stress_load = clip(float(self.stress_load) * math.exp(-dt / tau_s), 0.0, 1.0)
+        # high stress loads immediately; low stress decays slowly
+        self.stress_load = max(float(self.stress_load), stress)
+        self.last_tick = now
+        if noise:
+            self.step_noise(now)
+        return {"stress": round(stress, 4), "stress_load": round(float(self.stress_load), 4),
+                "tau_hours": round(tau_s / 3600.0, 2)}
+
+    def behavior(self, mind, base_threshold: float = 0.74, trust: float = 0.5) -> dict:
+        """Bio state -> hard behavioral consequences, not just prompt text."""
+        energy = 0.5
+        stress = 0.2
+        social = 0.5
+        trust = clip(float(trust), 0.0, 1.0)
+        try:
+            energy = clip(float(mind.drives.values.get("energy", 0.5)), 0.0, 1.0)
+            social = clip(float(mind.drives.values.get("social", 0.5)), 0.0, 1.0)
+            stress = clip(float(getattr(mind.affect, "stress", 0.2)), 0.0, 1.0)
+        except Exception:
+            pass
+        recovery = clip(float(self.traits.get("recovery_rate", 0.5)), 0.0, 1.0)
+        n = dict(self.noise_values or {})
+        echo = clip(float(self.noise_echo or 0.0), -1.0, 1.0)
+        stress_eff = clip(max(stress, float(self.stress_load or 0.0)) + 0.12 * float(n.get("stress", 0.0)), 0.0, 1.0)
+        energy_eff = clip(energy + 0.10 * float(n.get("energy", 0.0)), 0.0, 1.0)
+        # low energy/high stress/low recovery -> harder to join a group
+        threshold = (float(base_threshold) + 0.12 * (1.0 - energy_eff)
+                     + 0.08 * stress_eff - 0.05 * (trust - 0.5)
+                     + 0.04 * float(n.get("attention", 0.0)) - 0.03 * float(n.get("social", 0.0))
+                     + 0.03 * echo
+                     - 0.04 * (social - 0.5) + 0.06 * (0.5 - recovery))
+        threshold = clip(threshold, 0.68, 0.92)
+        # short replies when depleted/stressed; forced replies keep a floor
+        max_chars = int(240.0 * (0.55 + 0.45 * energy_eff) * (1.0 - 0.30 * stress_eff))
+        max_chars = int(max(80, min(260, max_chars)))
+        private_mode = "answer"
+        if energy_eff < 0.22 and stress_eff > 0.75:
+            private_mode = "defer"
+        elif energy_eff < 0.40 or stress_eff > 0.70:
+            private_mode = "brief"
+        warmth = clip(0.50 + 0.20 * trust + 0.20 * float(getattr(mind.affect, "v", 0.0))
+                      - 0.25 * stress_eff, 0.0, 1.0)
+        disclosure = clip(0.20 + 0.55 * trust + 0.15 * energy_eff - 0.25 * stress_eff, 0.0, 1.0)
+        initiative = clip(0.20 + 0.35 * social + 0.25 * energy_eff - 0.30 * stress_eff, 0.0, 1.0)
+        return {"threshold": round(threshold, 4), "max_chars": max_chars,
+                "energy": round(energy, 3), "stress": round(stress, 3),
+                "stress_load": round(stress_eff, 3),
+                "private_mode": private_mode,
+                "warmth": round(warmth, 3),
+                "disclosure": round(disclosure, 3),
+                "initiative": round(initiative, 3),
+                "noise": {k: round(float(v), 3) for k, v in n.items()},
+                "chaos": round(float(self.noise_chaos or 0.5), 3),
+                "echo": round(echo, 3), "echo_trace": round(float(self.echo_trace or 0.0), 3),
+                "echo_tau_s": 180.0,
+                "social": round(social, 3), "trust": round(trust, 3),
+                "recovery": round(recovery, 3)}
+
+    def context(self) -> str:
+        keys = ("stress_reactivity", "recovery_rate", "social_baseline",
+                "curiosity_baseline", "safety_baseline", "energy_baseline")
+        return " ".join("%s=%.2f" % (k, float(self.traits.get(k, 0.5))) for k in keys)
+
+    def snapshot(self) -> dict:
+        return {"version": self.version, "evidence": self.evidence,
+                "last_update": self.last_update,
+                "stress_load": round(float(self.stress_load or 0.0), 4),
+                "noise_values": {k: round(float(v), 4) for k, v in (self.noise_values or {}).items()},
+                "noise_chaos": round(float(self.noise_chaos or 0.5), 4),
+                "last_noise_tick": self.last_noise_tick,
+                "noise_echo": round(float(self.noise_echo or 0.0), 4),
+                "echo_trace": round(float(self.echo_trace or 0.0), 4),
+                "last_echo_tick": self.last_echo_tick,
+                "traits": {k: round(float(v), 4) for k, v in self.traits.items()}}
+
+    def save(self, path: Path | str) -> None:
+        try:
+            p = Path(path)
+            p.parent.mkdir(parents=True, exist_ok=True)
+            p.write_text(json.dumps(asdict(self), ensure_ascii=False, indent=1), encoding="utf-8")
+        except Exception:
+            pass
+
+    @classmethod
+    def load(cls, path: Path | str, mind=None) -> "BioProfile":
+        try:
+            d = json.loads(Path(path).read_text(encoding="utf-8"))
+            obj = cls(traits=dict(d.get("traits") or {}), version=int(d.get("version", 1)),
+                      evidence=int(d.get("evidence", 0)), last_update=float(d.get("last_update", 0.0)),
+                      baseline=dict(d.get("baseline") or {}),
+                      stress_load=float(d.get("stress_load", 0.0) or 0.0),
+                      last_tick=float(d.get("last_tick", 0.0) or 0.0),
+                      noise_values=dict(d.get("noise_values") or {}),
+                      noise_chaos=float(d.get("noise_chaos", 0.5) or 0.5),
+                      last_noise_tick=float(d.get("last_noise_tick", 0.0) or 0.0),
+                      noise_echo=float(d.get("noise_echo", 0.0) or 0.0),
+                      echo_trace=float(d.get("echo_trace", 0.0) or 0.0),
+                      last_echo_tick=float(d.get("last_echo_tick", 0.0) or 0.0),
+                      persona_version=str(d.get("persona_version") or ""))
+            if not obj.traits and mind is not None:
+                return cls.from_mind(mind)
+            return obj
+        except Exception:
+            return cls.from_mind(mind) if mind is not None else cls()

package/python/mindbase/bio_noise.py

@@ -0,0 +1,39 @@
+"""Multi-channel chaotic noise for the bio layer.
+
+Not physics. A Lorenz field drives several bounded OU channels; each channel
+has a different time constant and gain, so stress/energy/social/attention
+perturbations arrive out of phase instead of as one random number.
+"""
+from __future__ import annotations
+
+import random
+
+from .noise import clip
+from .quantum_chaos import ChaosField
+
+CHANNELS = ("stress", "energy", "social", "attention", "valence")
+
+
+class BioNoise:
+    def __init__(self, seed: int = 2026):
+        self.field = ChaosField(seed)
+        self.rng = random.Random(seed + 7)
+        self.values = {k: 0.0 for k in CHANNELS}
+        self.last_chaos = 0.5
+
+    def step(self, dt: float = 1.0) -> dict:
+        steps = max(1, min(40, int(abs(float(dt or 1.0)) * 10)))
+        self.last_chaos = float(self.field.step(steps=steps).get("value", 0.5))
+        for i, k in enumerate(CHANNELS):
+            theta = 0.10 + 0.025 * i
+            sigma = 0.018 + 0.004 * i
+            x = float(self.values.get(k, 0.0))
+            x += theta * (0.0 - x)
+            x += sigma * (self.last_chaos - 0.5)
+            x += sigma * (self.rng.random() - 0.5)
+            self.values[k] = clip(x, -0.15, 0.15)
+        return dict(self.values)
+
+    def snapshot(self) -> dict:
+        return {"values": {k: round(float(v), 4) for k, v in self.values.items()},
+                "chaos": round(self.last_chaos, 4)}

package/python/mindbase/bio_semantic.py

@@ -0,0 +1,138 @@
+"""Translate biological state into compact semantic intent.
+
+Not raw numbers, not a persona script. Fields separate:
+emotion / need / distance / tone / expression / intensity.
+"""
+from __future__ import annotations
+
+
+def _f(x, default=0.0):
+    try:
+        return float(x)
+    except Exception:
+        return float(default)
+
+
+def translate(mind, behavior=None, ripple_outputs=None, trust=None, emotion=None, event=None) -> dict:
+    b = dict(behavior or {})
+    ro = dict(ripple_outputs or {})
+    emo = dict(emotion or {})
+    try:
+        v = _f(getattr(mind.affect, "v", 0.0))
+        a = _f(getattr(mind.affect, "a", 0.5))
+        stress = _f(getattr(mind.affect, "stress", 0.2))
+    except Exception:
+        v, a, stress = 0.0, 0.5, 0.2
+    try:
+        energy = _f(mind.drives.values.get("energy", 0.5))
+    except Exception:
+        energy = 0.5
+    if trust is None:
+        try:
+            trust = _f(mind.social.trust_for(""), 0.5)
+        except Exception:
+            trust = 0.5
+    trust = _f(trust, 0.5)
+
+    # emotion: keep the strongest 7-dim signal, not only PAD/stress
+    dims = {k: _f(emo.get(k), 0.0) for k in
+            ("joy", "sadness", "fear", "anger", "surprise", "trust", "loneliness")}
+    ev = dict(event or {})
+    if ev:
+        _v = _f(ev.get("valence"), 0.0)
+        if _v < -0.10:
+            dims["sadness"] = max(dims["sadness"], min(1.0, -_v * 0.8))
+        elif _v > 0.10:
+            dims["joy"] = max(dims["joy"], min(1.0, _v * 0.8))
+        if _f(ev.get("threat"), 0.0) > 0.15:
+            dims["fear"] = max(dims["fear"], min(1.0, _f(ev.get("threat"))))
+        if _f(ev.get("connection_delta"), 0.0) > 0.10:
+            dims["trust"] = max(dims["trust"], min(1.0, 0.45 + _f(ev.get("connection_delta"))))
+    top = max(dims, key=lambda k: dims[k]) if dims else "neutral"
+    top_val = dims.get(top, 0.0)
+    if top_val < 0.08:
+        top = ("sadness" if v < -0.15 else ("joy" if v > 0.15 else "neutral"))
+        top_val = abs(v)
+    emotion_tag = top if top != "neutral" else "neutral"
+    intensity_tag = "high" if max(top_val, abs(v), a) > 0.62 else ("low" if max(top_val, abs(v), a) < 0.28 else "medium")
+
+    energy_tag = "low" if energy < 0.38 else ("high" if energy > 0.72 else "normal")
+    stress_tag = "overloaded" if stress > 0.60 else ("tense" if stress > 0.30 else "calm")
+    if emotion_tag in ("sadness", "loneliness"):
+        need = "be_heard"
+    elif emotion_tag in ("fear", "anger"):
+        need = "space" if emotion_tag == "fear" else "vent"
+    elif emotion_tag in ("joy", "trust"):
+        need = "share"
+    elif stress_tag == "overloaded" or energy_tag == "low":
+        need = "space"
+    else:
+        need = "talk"
+
+    if emotion_tag in ("fear", "anger", "sadness", "loneliness") or trust < 0.32:
+        distance = "far"
+    elif emotion_tag in ("joy", "trust") and trust > 0.45:
+        distance = "near"
+    else:
+        distance = "neutral"
+
+    if emotion_tag in ("sadness", "fear"):
+        tone = "soft"
+    elif emotion_tag == "anger":
+        tone = "blunt"
+    elif emotion_tag in ("joy", "surprise"):
+        tone = "playful"
+    elif emotion_tag == "loneliness":
+        tone = "quiet"
+    else:
+        tone = "neutral"
+
+    if stress_tag == "overloaded" or energy_tag == "low":
+        intent = "withdraw"
+    elif need == "share" and stress_tag != "overloaded":
+        intent = "approach"
+    elif emotion_tag in ("joy", "trust") and energy_tag != "low":
+        intent = "approach"
+    elif energy_tag == "high" and trust > 0.62 and stress_tag == "calm":
+        intent = "approach"
+    elif need == "be_heard" and energy_tag != "low":
+        intent = "hold"
+    else:
+        intent = "hold"
+    expression = "short" if intent == "withdraw" or stress_tag == "overloaded" else (
+        "open" if intent == "approach" and energy_tag != "low" else "normal")
+    q_budget = 1 if (expression == "open" and intent == "approach") or (
+        need in ("be_heard", "share") and expression != "short" and energy_tag != "low") else 0
+    proactive = 0.0
+    if intent == "approach":
+        proactive = 0.10 + 0.10 * max(0.0, _f(ro.get("engage_bias")))
+    elif intent == "withdraw":
+        proactive = -0.15
+    mode = str(b.get("private_mode") or "answer")
+    if intent == "withdraw" and mode == "answer":
+        mode = "brief"
+    return {
+        "emotion": emotion_tag,
+        "intensity": intensity_tag,
+        "need": need,
+        "distance": distance,
+        "tone": tone,
+        "intent": intent,
+        "energy": energy_tag,
+        "stress": stress_tag,
+        "expression": expression,
+        "question_budget": q_budget,
+        "proactive_bias": round(proactive, 3),
+        "mode": mode,
+        "valence": "positive" if v > 0.12 else ("negative" if v < -0.12 else "neutral"),
+    }
+
+
+def context(semantic: dict) -> str:
+    s = dict(semantic or {})
+    return ("emotion=%s intensity=%s need=%s distance=%s tone=%s "
+            "intent=%s expression=%s mode=%s" % (
+                s.get("emotion", "neutral"), s.get("intensity", "medium"),
+                s.get("need", "talk"), s.get("distance", "neutral"),
+                s.get("tone", "neutral"), s.get("intent", "hold"),
+                s.get("expression", "normal"), s.get("mode", "answer")))