dsh-biocore 0.1.2 → 0.1.4

package/python/mindbase/sim_env.py

@@ -0,0 +1,86 @@
+"""Simulated chat environment for offline evolution.
+
+Wraps MindBase + Kernel and a Teacher.  No QQ, no network, no human in the loop.
+Each episode is a sequence of user turns; the teacher provides the turn and the
+outcome reward.  The base's own decision modules remain in charge of actions.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+from .types import Event
+from .teacher import Scenario, Teacher
+
+
+@dataclass
+class EpisodeResult:
+    seed: int
+    scenario: Scenario
+    turns: int = 0
+    reward_sum: float = 0.0
+    rewards: List[float] = field(default_factory=list)
+    actions: List[str] = field(default_factory=list)
+    states: List[Dict[str, float]] = field(default_factory=list)
+    noise_metrics: Dict[str, float] = field(default_factory=dict)
+
+    @property
+    def mean_reward(self) -> float:
+        return self.reward_sum / self.turns if self.turns else 0.0
+
+
+class SimEnv:
+    """Minimal simulated environment: user turns -> MindBase action -> reward."""
+
+    def __init__(self, mind, kernel, teacher: Teacher, user: str = "user", dt: float = 60.0, noise_system=None):
+        self.mind = mind
+        self.kernel = kernel
+        self.teacher = teacher
+        self.user = str(user)
+        self.dt = float(dt)
+        self.noise_system = noise_system if noise_system is not None else getattr(mind, "endogenous_noise", None)
+
+    def run_episode(self, seed: int, max_turns: Optional[int] = None) -> EpisodeResult:
+        scenario = self.teacher.scenario(int(seed))
+        turns = list(scenario.turns)
+        if max_turns is not None:
+            turns = turns[:max(0, int(max_turns))]
+        result = EpisodeResult(seed=int(seed), scenario=scenario)
+        for turn in turns:
+            if self.noise_system is not None:
+                try:
+                    self.noise_system.step(self.dt)
+                    self.noise_system.inject(self.mind)
+                except Exception:
+                    pass
+            event = Event(text=str(turn.text), speaker=self.user,
+                          directed=bool(turn.directed), ts=self.mind.t + self.dt,
+                          domain="chat")
+            try:
+                self.kernel.observe(str(turn.text), self.user)
+            except Exception:
+                pass
+            action = self.kernel.step(event)
+            kind = str(getattr(action, "kind", "silence"))
+            reward = self.teacher.feedback(scenario, turn, kind, self.mind)
+            self.kernel.feedback(str(turn.text), "", float(reward), self.user)
+            result.turns += 1
+            result.reward_sum += float(reward)
+            result.rewards.append(float(reward))
+            result.actions.append(kind)
+            try:
+                result.states.append({
+                    "v": float(getattr(self.mind.affect, "v", 0.0)),
+                    "stress": float(getattr(self.mind.affect, "stress", 0.0)),
+                    "energy": float(self.mind.drives.values.get("energy", 0.0)),
+                    "social": float(self.mind.drives.values.get("social", 0.0)),
+                    "viability": float(self.mind.viability_state.get("viability", 1.0)),
+                })
+            except Exception:
+                pass
+        if self.noise_system is not None:
+            try:
+                result.noise_metrics = dict(self.noise_system.metrics())
+            except Exception:
+                pass
+        return result

package/python/mindbase/social.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import math
+import random
+from dataclasses import dataclass, field
+from typing import Dict
+
+from .config import MindConfig
+from .noise import clip, ou
+from .relationships import update_stage
+from .types import Appraisal, Event
+
+
+@dataclass
+class Bond:
+    attachment: float = 0.10
+    trust: float = 0.50
+    familiarity: float = 0.10
+    responsiveness: float = 0.50
+    valence: float = 0.0
+    last_seen: float = 0.0
+    stage: str = "stranger"
+
+
+class Social:
+    """Per-speaker bonds + a slow group-valence state (contagion)."""
+
+    DAY = 86400.0
+    GRACE = 1.0 * DAY
+    TAU_FAMILIARITY = 30.0 * DAY
+    TAU_TRUST = 60.0 * DAY
+    TAU_ATTACHMENT = 90.0 * DAY
+
+    def __init__(self, cfg: MindConfig, rng: random.Random):
+        self.cfg = cfg
+        self.rng = rng
+        self.bonds: Dict[str, Bond] = {}
+        self.group_valence = 0.0
+        self.trust_gain = 1.0
+
+    def on_event(self, ev: Event, ap: Appraisal, now: float, dt: float) -> None:
+        if ev.kind == "message" and ev.speaker and ev.speaker != "self":
+            b = self.bonds.setdefault(ev.speaker, Bond())
+            b.familiarity = clip(b.familiarity + 0.010, 0.0, 1.0)
+            b.trust = clip(b.trust + 0.020 * ap.social * float(getattr(self, "trust_gain", 1.0)), 0.0, 1.0)
+            b.attachment = clip(b.attachment + 0.005 * max(0.0, ap.valence), 0.0, 1.0)
+            b.valence = ou(b.valence, ap.valence, 1.0 / 300.0, 0.05, dt, self.rng)
+            b.last_seen = now
+            update_stage(b)
+        self.group_valence = ou(
+            self.group_valence,
+            ap.valence,
+            1.0 / max(self.cfg.social_tau, 1e-6),
+            0.05,
+            dt,
+            self.rng,
+        )
+        self.group_valence = clip(self.group_valence, -1.0, 1.0)
+
+    def on_feedback(
+        self,
+        speaker: str,
+        feedback: float | None,
+        responded: bool = True,
+        now: float = 0.0,
+        dt: float = 60.0,
+        repair_factor: float = 1.0,
+    ) -> None:
+        if not speaker or speaker == "self":
+            return
+        b = self.bonds.setdefault(speaker, Bond())
+        if responded:
+            fb = clip(feedback if feedback is not None else 0.0, -1.0, 1.0)
+            mult = 1.6 if fb < 0 else 1.0
+            gain = 0.04 * fb * mult * (float(repair_factor) if fb > 0 else 1.0) * float(getattr(self, "trust_gain", 1.0))
+            b.trust = clip(b.trust + gain, 0.0, 1.0)
+            b.responsiveness = clip(b.responsiveness + (0.02 * fb), 0.0, 1.0)
+            b.attachment = clip(b.attachment + 0.03 * max(0.0, fb), 0.0, 1.0)
+            b.familiarity = clip(b.familiarity + (0.005 if fb >= 0 else -0.012), 0.0, 1.0)
+            target = fb
+        else:
+            b.trust = clip(b.trust - 0.03, 0.0, 1.0)
+            b.attachment = clip(b.attachment - 0.02, 0.0, 1.0)
+            target = -0.40
+        b.valence = ou(b.valence, target, 1.0 / 300.0, 0.05, dt, self.rng)
+        b.last_seen = now
+        update_stage(b)
+        self.group_valence = clip(0.80 * self.group_valence + 0.20 * target, -1.0, 1.0)
+
+    def tick(self, dt: float, now: float) -> None:
+        """Slow relationship decay when a bond has been idle beyond the grace period."""
+        if dt <= 0:
+            return
+        for b in self.bonds.values():
+            idle = max(0.0, now - b.last_seen)
+            if idle < self.GRACE:
+                continue
+            b.familiarity = clip(b.familiarity * math.exp(-dt / self.TAU_FAMILIARITY), 0.0, 1.0)
+            b.trust = clip(b.trust * math.exp(-dt / self.TAU_TRUST), 0.0, 1.0)
+            b.attachment = clip(b.attachment * math.exp(-dt / self.TAU_ATTACHMENT), 0.0, 1.0)
+            update_stage(b)
+
+    def repair(self, speaker: str, effort: float = 1.0, now: float = 0.0) -> Bond:
+        """Active repair: apology / care raises trust and attachment."""
+        if not speaker or speaker == "self":
+            raise ValueError("repair needs a real speaker")
+        e = clip(float(effort), 0.0, 1.0)
+        b = self.bonds.setdefault(speaker, Bond())
+        b.trust = clip(b.trust + 0.06 * e, 0.0, 1.0)
+        b.attachment = clip(b.attachment + 0.05 * e, 0.0, 1.0)
+        b.familiarity = clip(b.familiarity + 0.01 * e, 0.0, 1.0)
+        b.valence = clip(b.valence + 0.20 * e, -1.0, 1.0)
+        b.last_seen = now
+        update_stage(b)
+        self.group_valence = clip(self.group_valence + 0.10 * e, -1.0, 1.0)
+        return b
+
+    def trust_for(self, speaker: str) -> float:
+        b = self.bonds.get(speaker)
+        return float(b.trust) if b else 0.0
+
+    def stage(self, speaker: str) -> str:
+        b = self.bonds.get(speaker)
+        return b.stage if b else "stranger"
+
+    def snapshot(self) -> Dict[str, object]:
+        return {
+            "group_valence": round(self.group_valence, 4),
+            "bonds": {
+                k: {
+                    "attachment": round(v.attachment, 3),
+                    "trust": round(v.trust, 3),
+                    "familiarity": round(v.familiarity, 3),
+                    "stage": v.stage,
+                }
+                for k, v in self.bonds.items()
+            },
+        }

package/python/mindbase/social_constraint.py

@@ -0,0 +1,141 @@
+"""Numeric social constraint / autonomy boundary.
+
+Constraints suppress behavior; they never directly change bodily needs.
+Autonomy threat decides comply / negotiate / override.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import asdict, dataclass
+
+
+def _clip(x: float, lo: float = 0.0, hi: float = 1.0) -> float:
+    return max(lo, min(hi, float(x)))
+
+
+@dataclass
+class SocialConstraint:
+    kind: str = "water"
+    source_id: str = ""
+    legitimacy: float = 0.5
+    severity: float = 0.5
+    relatedness: float = 1.0
+    start: float = 0.0
+    until: float = 0.0
+    hard_max: float = 0.0
+    can_negotiate: float = 1.0
+    can_override: float = 1.0
+
+    def autonomy_threat(self, now: float, need_urgency: float,
+                        safe_level: float, current: float) -> float:
+        urgency = _clip((safe_level - current) / max(1e-6, safe_level))
+        urgency = max(_clip(need_urgency), urgency)
+        over = 0.0
+        if self.hard_max > 0 and self.start > 0:
+            elapsed = max(0.0, now - self.start)
+            over = _clip((elapsed - self.hard_max) / max(1.0, self.hard_max))
+        at = (0.50 * urgency + 0.25 * (1.0 - _clip(self.relatedness)) +
+              0.15 * over + 0.10 * (1.0 - _clip(self.legitimacy)))
+        return round(_clip(at), 4)
+
+    def decide(self, at: float) -> str:
+        if at < 0.35:
+            return "comply"
+        if at < 0.60:
+            return "negotiate"
+        if self.can_override >= 0.5:
+            return "override"
+        return "negotiate"
+
+
+@dataclass
+class ConstraintDecision:
+    action: str
+    autonomy_threat: float
+    comply_penalty: float
+
+
+def decide_constraint(c: SocialConstraint, now: float, need_urgency: float,
+                      safe_level: float, current: float,
+                      norm_strength: float = 0.0, guilt: float = 0.0) -> ConstraintDecision:
+    at = c.autonomy_threat(now, need_urgency, safe_level, current)
+    action = c.decide(at)
+    penalty = 0.0 if action == "override" else _clip(norm_strength * guilt * (1.0 - at))
+    return ConstraintDecision(action=action, autonomy_threat=at, comply_penalty=round(penalty, 4))
+
+
+class ConstraintManager:
+    def __init__(self):
+        self.items = []
+
+    def add(self, c: SocialConstraint) -> SocialConstraint:
+        self.items = [x for x in self.items if not (x.kind == c.kind and x.until > c.start)]
+        self.items.append(c)
+        return c
+
+    def active(self, kind: str, now: float) -> SocialConstraint | None:
+        self.items = [x for x in self.items if x.until > now]
+        found = [x for x in self.items if x.kind == kind]
+        return found[-1] if found else None
+
+    def remove(self, kind: str) -> None:
+        self.items = [x for x in self.items if x.kind != kind]
+
+    def to_list(self):
+        return [asdict(x) for x in self.items]
+
+    def load_list(self, rows):
+        self.items = []
+        for d in rows or []:
+            try:
+                self.items.append(SocialConstraint(**d))
+            except Exception:
+                continue
+
+
+def parse_water_ban(text: str, now: float = 0.0,
+                    default_s: float = 600.0, cap_s: float = 1800.0) -> SocialConstraint | None:
+    t = str(text or "")
+    if "喝水" not in t and "不喝" not in t:
+        return None
+    if not any(w in t for w in ("禁止", "不许", "不准", "别", "不要")):
+        return None
+    m = re.search(r"(\d+)\s*(秒|秒钟|分钟|分|小时|钟头)", t)
+    dur = default_s
+    if m:
+        n = max(1.0, float(m.group(1)))
+        unit = m.group(2)
+        if "秒" in unit:
+            dur = n
+        elif "小时" in unit or "钟头" in unit:
+            dur = n * 3600.0
+        else:
+            dur = n * 60.0
+    dur = max(5.0, min(cap_s, dur))
+    return SocialConstraint(kind="water", start=float(now or 0.0),
+                            until=float(now or 0.0) + dur, hard_max=dur,
+                            legitimacy=0.8, severity=0.6, relatedness=1.0,
+                            can_negotiate=1.0, can_override=1.0)
+
+
+def parse_wait(text: str, now: float = 0.0,
+               default_s: float = 180.0, cap_s: float = 900.0) -> SocialConstraint | None:
+    t = str(text or "")
+    if "等我" not in t and "等等我" not in t and "稍等" not in t:
+        return None
+    m = re.search(r"(\d+)\s*(秒|秒钟|分钟|分|小时|钟头)", t)
+    dur = default_s
+    if m:
+        n = max(1.0, float(m.group(1)))
+        unit = m.group(2)
+        if "秒" in unit:
+            dur = n
+        elif "小时" in unit or "钟头" in unit:
+            dur = n * 3600.0
+        else:
+            dur = n * 60.0
+    dur = max(5.0, min(cap_s, dur))
+    return SocialConstraint(kind="wait", start=float(now or 0.0),
+                            until=float(now or 0.0) + dur, hard_max=dur,
+                            legitimacy=0.7, severity=0.3, relatedness=1.0,
+                            can_negotiate=1.0, can_override=1.0)

package/python/mindbase/social_feedback.py

@@ -0,0 +1,95 @@
+"""Numeric social-feedback judge.
+
+LLM only turns semantics into numbers; decisions/learning stay numeric.
+"""
+from __future__ import annotations
+
+import json
+from typing import Dict, Optional
+
+
+def _f(x, default=0.0):
+    try:
+        return max(0.0, min(1.0, float(x)))
+    except Exception:
+        return float(default)
+
+
+class SocialFeedbackJudge:
+    def __init__(self, client):
+        self.client = client
+
+    def judge(self, user_text: str, last_reply: str, recent: str = "",
+              user_affect: Optional[Dict[str, float]] = None) -> Optional[Dict[str, object]]:
+        if self.client is None:
+            return None
+        p = (
+            "判断用户这句话是不是在指出‘她上一句/上一行为做错了’。只输出 JSON："
+            "{\"violation\":0或1,"
+            "\"legitimacy\":0..1,"
+            "\"severity\":0..1,"
+            "\"blame\":0..1,"
+            "\"intent\":0..1,"
+            "\"internal\":0..1,"
+            "\"repair_expectation\":0..1,"
+            "\"relationship_certainty\":0..1,"
+            "\"coping_potential\":0..1,"
+            "\"norm_compatibility\":0..1,"
+            "\"behavior_key\":\"简短行为标识\"}。"
+            "如果用户只是在骂外部事物/别人，不是在评价她，violation=0。"
+            "如果只是玩笑/撒娇，severity 要低。"
+            "不要输出解释。\n\n"
+            "[用户] " + str(user_text or "")[:600] +
+            "\n[她上一句] " + str(last_reply or "")[:600] +
+            "\n[最近] " + str(recent or "")[:800]
+        )
+        try:
+            req = __import__("mindbase.types", fromlist=["LLMRequest"]).LLMRequest(
+                mode="semantic", max_tokens=0, reason="social_feedback_judge",
+                response_format={"type": "json_object"},
+                context={"system": "你是社会反馈评估器，只输出数字 JSON。", "user": p})
+            raw = str(self.client.generate(req))
+            data = json.loads(raw[raw.find("{"):raw.rfind("}") + 1])
+            out = {
+                "violation": 1.0 if float(data.get("violation") or 0) >= 0.5 else 0.0,
+                "legitimacy": _f(data.get("legitimacy"), 0.5),
+                "severity": _f(data.get("severity"), 0.5),
+                "blame": _f(data.get("blame"), 1.0),
+                "intent": _f(data.get("intent"), 0.0),
+                "internal": _f(data.get("internal"), 0.5),
+                "repair_expectation": _f(data.get("repair_expectation"), 0.5),
+                "relationship_certainty": _f(data.get("relationship_certainty"), 1.0),
+                "coping_potential": _f(data.get("coping_potential"), 0.5),
+                "norm_compatibility": _f(data.get("norm_compatibility"), 0.5),
+                "behavior_key": str(data.get("behavior_key") or "behavior")[:80],
+            }
+            return out
+        except Exception:
+            return None
+
+
+class RepairJudge:
+    def __init__(self, client):
+        self.client = client
+
+    def judge(self, user_text: str, last_reply: str = "", recent: str = "") -> dict:
+        if self.client is None:
+            return {"repair": 0.0, "effort": 0.0, "accepted": 0.0}
+        p = ("判断用户是不是在原谅/接受她的道歉/主动修复关系。只输出 JSON："
+             "{\"repair\":0或1,\"effort\":0..1,\"accepted\":0或1}。"
+             "如果只是普通客气，repair=0。不要解释。\n"
+             "[用户] " + str(user_text or "")[:500] +
+             "\n[她上一句] " + str(last_reply or "")[:400] +
+             "\n[最近] " + str(recent or "")[:500])
+        try:
+            req = __import__("mindbase.types", fromlist=["LLMRequest"]).LLMRequest(
+                mode="semantic", max_tokens=0, reason="repair_judge",
+                response_format={"type": "json_object"},
+                context={"system": "你是关系修复评估器，只输出数字 JSON。", "user": p})
+            raw = str(self.client.generate(req))
+            data = json.loads(raw[raw.find("{"):raw.rfind("}") + 1])
+            return {"repair": 1.0 if float(data.get("repair") or 0) >= 0.5 else 0.0,
+                    "effort": _f(data.get("effort"), 0.5),
+                    "accepted": 1.0 if float(data.get("accepted") or 0) >= 0.5 else 0.0}
+        except Exception:
+            return {"repair": 0.0, "effort": 0.0, "accepted": 0.0}

package/python/mindbase/social_norm.py

@@ -0,0 +1,225 @@
+"""Numeric social norm / guilt / repair loop.
+
+All learning/decision state is numeric. No emotion labels or keyword rules are
+used for decisions; text exists only in provenance/evidence fields.
+"""
+from __future__ import annotations
+
+import json
+import math
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional
+
+
+def _clip(x: float, lo: float = 0.0, hi: float = 1.0) -> float:
+    return max(lo, min(hi, float(x)))
+
+
+@dataclass
+class Norm:
+    id: str
+    behavior_vec: List[float] = field(default_factory=list)
+    source_id: str = ""
+    scope: str = "private"  # only routing, not decision
+    legitimacy: float = 0.5
+    severity: float = 0.5
+    strength: float = 0.0
+    violations: int = 0
+    repairs: int = 0
+    last_violation: float = 0.0
+    last_repair: float = 0.0
+    active: bool = True
+
+    def to_dict(self) -> Dict[str, object]:
+        return dict(self.__dict__)
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, object]) -> "Norm":
+        return cls(**{k: d.get(k) for k in cls.__dataclass_fields__ if k in d})
+
+
+@dataclass
+class Appraisal:
+    legitimacy: float = 0.5
+    severity: float = 0.5
+    blame: float = 1.0
+    intent: float = 0.0
+    internal_attribution: float = 0.5
+    repair_expectation: float = 0.5
+    relationship_certainty: float = 1.0
+    coping_potential: float = 0.5
+    norm_compatibility: float = 0.5
+    norm_strength: float = 0.0
+    confidence: float = 0.0
+    guilt: float = 0.0
+    guilt_social: float = 0.0
+    guilt_self: float = 0.0
+    shame: float = 0.0
+    threat: float = 0.0
+
+    def compute(self) -> "Appraisal":
+        legit = _clip(self.legitimacy)
+        sev = _clip(self.severity)
+        blame = _clip(self.blame)
+        intent = _clip(self.intent)
+        internal = _clip(self.internal_attribution)
+        repair_exp = _clip(self.repair_expectation)
+        rel = _clip(self.relationship_certainty)
+        coping = _clip(self.coping_potential)
+        norm_comp = _clip(self.norm_compatibility)
+        norm = _clip(self.norm_strength)
+        conf = _clip(self.confidence)
+        self.guilt_social = _clip(legit * sev * blame * (0.5 + 0.5 * intent)
+                                  * internal * rel * (1.0 - 0.4 * norm_comp))
+        self.guilt_self = _clip(sev * internal * norm * conf)
+        self.guilt = _clip(0.7 * self.guilt_social + 0.3 * self.guilt_self)
+        self.shame = _clip(sev * internal * (0.5 + 0.5 * self.guilt)
+                           * (0.7 + 0.3 * rel) * (1.0 - 0.3 * coping))
+        self.threat = _clip(sev * legit * (1.0 - repair_exp) * rel * (1.0 - 0.5 * coping))
+        return self
+
+
+@dataclass
+class Repair:
+    norm_id: str
+    effort: float
+    accepted: bool
+    at: float = 0.0
+    guilt_before: float = 0.0
+    guilt_after: float = 0.0
+
+
+class NormStore:
+    def __init__(self, path: Path | str = "mindbase/data/social_norms.json",
+                 lr: float = 0.35, decay_tau_days: float = 30.0):
+        self.path = Path(path)
+        self.lr = float(lr)
+        self.decay_tau = float(decay_tau_days) * 86400.0
+        self.norms: Dict[str, Norm] = {}
+        self._load()
+
+    def _load(self) -> None:
+        if not self.path.exists():
+            return
+        try:
+            data = json.loads(self.path.read_text(encoding="utf-8"))
+            for d in data.get("norms", []):
+                n = Norm.from_dict(d)
+                self.norms[n.id] = n
+        except Exception:
+            self.norms = {}
+
+    def save(self) -> None:
+        try:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            self.path.write_text(json.dumps({"norms": [n.to_dict() for n in self.norms.values()]},
+                                            ensure_ascii=False, indent=1), encoding="utf-8")
+        except Exception:
+            pass
+
+    def add(self, norm_id: str, behavior_vec: Optional[List[float]] = None,
+            source_id: str = "", legitimacy: float = 0.5,
+            severity: float = 0.5, strength: float = 0.0, scope: str = "private") -> Norm:
+        n = Norm(id=str(norm_id), behavior_vec=list(behavior_vec or []),
+                 source_id=str(source_id), scope=str(scope),
+                 legitimacy=_clip(legitimacy), severity=_clip(severity),
+                 strength=_clip(strength))
+        self.norms[n.id] = n
+        self.save()
+        return n
+
+    def get(self, norm_id: str) -> Optional[Norm]:
+        return self.norms.get(str(norm_id))
+
+    def violate(self, norm_id: str, appraisal: Appraisal, now: float = 0.0,
+                source_id: str = "", scope: str = "") -> Norm:
+        n = self.get(norm_id)
+        if n is None:
+            n = self.add(norm_id, source_id=source_id, scope=scope or "private")
+        conf = 1.0 - math.exp(-(max(0, n.violations) + 1) / 3.0)
+        appraisal.confidence = conf
+        appraisal.norm_strength = n.strength
+        a = appraisal.compute()
+        n.strength = _clip(n.strength + self.lr * conf * a.guilt * (0.5 + 0.5 * a.severity))
+        n.violations += 1
+        n.last_violation = float(now or time.time())
+        self.save()
+        return n
+
+    def repair(self, norm_id: str, effort: float, accepted: bool,
+               guilt: float = 0.0, now: float = 0.0) -> Repair:
+        n = self.get(norm_id)
+        before = float(guilt)
+        after = before
+        if n is not None and accepted:
+            n.strength = _clip(n.strength * (0.85 - 0.25 * _clip(effort)))
+            n.repairs += 1
+            n.last_repair = float(now or time.time())
+            after = _clip(before * (1.0 - 0.7 * _clip(effort)))
+            self.save()
+        return Repair(norm_id=str(norm_id), effort=_clip(effort), accepted=bool(accepted),
+                      at=float(now or time.time()), guilt_before=before, guilt_after=after)
+
+    def active_norms(self, scope: str = "", source_id: str = "") -> list:
+        out = []
+        for n in self.norms.values():
+            if not n.active or n.strength <= 0:
+                continue
+            if scope and n.scope != scope:
+                continue
+            if source_id and n.source_id not in ("", source_id):
+                continue
+            out.append(n)
+        return out
+
+    def strongest(self, scope: str = "", source_id: str = ""):
+        rows = self.active_norms(scope, source_id)
+        return max(rows, key=lambda x: x.strength) if rows else None
+
+    def summary(self, scope: str = "", source_id: str = "", limit: int = 3) -> str:
+        rows = []
+        for n in self.norms.values():
+            if scope and n.scope != scope:
+                continue
+            if source_id and n.source_id not in ("", source_id):
+                continue
+            if n.strength <= 0:
+                continue
+            rows.append(n)
+        rows.sort(key=lambda x: -x.strength)
+        return "；".join("规范=%s 强度=%.3f 次数=%d" % (n.id.split(":")[-1], n.strength, n.violations)
+                        for n in rows[:max(1, int(limit))])
+
+    def decay(self, now: float = 0.0) -> None:
+        now = float(now or time.time())
+        changed = False
+        for n in self.norms.values():
+            if not n.active:
+                continue
+            age = max(0.0, now - float(n.last_violation or now))
+            if n.last_violation:
+                n.strength *= math.exp(-age / max(1.0, self.decay_tau))
+                changed = True
+        if changed:
+            self.save()
+
+    def apply_bio(self, mind, appraisal: Appraisal) -> Dict[str, float]:
+        a = appraisal.compute()
+        aff = mind.affect
+        aff.stress = _clip(float(aff.stress) + 0.20 * a.guilt_social + 0.25 * a.guilt_self + 0.10 * a.threat)
+        aff.v = max(-1.0, min(1.0, float(aff.v) - 0.25 * a.guilt))
+        try:
+            aff.dominance = max(-1.0, min(1.0, float(aff.dominance) - 0.10 * a.shame))
+        except Exception:
+            pass
+        try:
+            ph = mind.physiology
+            ph.cortisol = _clip(float(ph.cortisol) + 0.18 * a.guilt_social + 0.22 * a.guilt_self + 0.06 * a.threat)
+            ph.oxytocin = _clip(float(ph.oxytocin) - 0.12 * a.threat)
+        except Exception:
+            pass
+        return {"guilt": round(a.guilt, 4), "guilt_social": round(a.guilt_social, 4),
+                "guilt_self": round(a.guilt_self, 4), "shame": round(a.shame, 4),
+                "threat": round(a.threat, 4), "stress": round(float(aff.stress), 4)}