dsh-biocore 0.3.3 → 0.5.0

package/python/biocore_model/appraisal.py

@@ -26,8 +26,15 @@ import re
 
 DIMS = ("goal", "blame", "control", "certainty", "novelty", "involve", "hit")
 OUTPUTS = ("v", "a", "d", "social", "trust", "stress", "self_esteem")
+# [engineering] per-turn output caps, hand-tuned.
 CAPS = {"v": 0.15, "a": 0.15, "d": 0.10, "social": 0.05,
         "trust": 0.05, "stress": 0.10, "self_esteem": 0.05}
+# appraisal_v2 (default ON): v is goal + an explicit valence signal only.
+# blame goes to trust/conflict, hit to stress/self_esteem, and control /
+# certainty / novelty / involve each keep their own output line. The old 7x7
+# mapping stays reachable with BIOCORE_APPRAISAL_V2=0 or flags["appraisal_v2"].
+SWITCH_KEY = "appraisal_v2"
+ENV_KEY = "BIOCORE_APPRAISAL_V2"
 PROBE_MIN_CONFIDENCE = 0.4
 WHY_MAX = 40
 INVOLVE_GAIN = 0.5
@@ -37,7 +44,9 @@ INVOLVE_GAIN = 0.5
 FACT_MAX_CHARS = 20
 SITUATION_KEYS = ("challenge", "praise", "hurt")
 
-# 7 x 7 W matrix: WEIGHTS[dimension][output] = weight.
+# 7 x 7 W matrix: WEIGHTS[dimension][output] = weight. [engineering] the
+# dimension names follow Scherer 2001 / OCC, but no row below is fitted or
+# transcribed from a paper (see PAPER-MAP.md).
 # goal: -1 blocked .. +1 achieved -> better valence/trust, less stress.
 # blame: 0 self .. 1 other -> conflict, lower self-esteem/trust, more stress.
 # control: 0 powerless .. 1 in control -> dominance/self-esteem, less stress.
@@ -64,6 +73,38 @@ WEIGHTS = {
 }
 DEFAULT_WEIGHTS = {"%s.%s" % (dim, out): weight
                    for dim, row in WEIGHTS.items() for out, weight in row.items()}
+
+# v2 destination table. Every dimension has exactly one home (goal and the
+# explicit valence signal own v); nothing is folded into v a second time.
+V2_WEIGHTS = {
+    "v": {"goal": 0.60, "valence": 0.40},
+    "a": {"novelty": 0.25, "involve": 0.10, "hit": 0.20},
+    "d": {"control": 0.45, "goal": 0.20},
+    "social": {"involve": 0.20, "hit": -0.30},
+    "trust": {"goal": 0.15, "blame": -0.30},
+    "conflict": {"blame": 0.35, "hit": 0.10},
+    "stress": {"blame": 0.15, "hit": 0.30},
+    "self_esteem": {"goal": 0.20, "hit": -0.30},
+}
+V2_OUTPUTS = ("v", "a", "d", "social", "trust", "conflict", "stress",
+              "self_esteem")
+V2_CAPS = dict(CAPS, conflict=0.15)
+
+
+def enabled(flags=None, env=None):
+    """appraisal_v2: explicit flag > nested switches > env > default ON."""
+    import os
+    data = flags if isinstance(flags, dict) else {}
+    if isinstance(data.get(SWITCH_KEY), bool):
+        return data[SWITCH_KEY]
+    switches = data.get("switches") if isinstance(data.get("switches"), dict) else {}
+    if isinstance(switches.get(SWITCH_KEY), bool):
+        return switches[SWITCH_KEY]
+    environ = env if hasattr(env, "get") else os.environ
+    raw = str(environ.get(ENV_KEY) or "").strip().lower()
+    if raw in ("0", "false", "off", "no"):
+        return False
+    return True
 _FEEDBACK_FIELDS = {"v": "valence_delta", "a": "arousal_delta",
                     "d": "dominance_delta", "social": "social_delta",
                     "trust": "trust_delta", "stress": "stress_delta",
@@ -182,8 +223,62 @@ async def probe(text, context, llm_call, timeout=None, core=None, now=None):
         return {}
 
 
-def appraise(dims, confidence=0.5, weights=None):
-    """W·x scaled by confidence, bounded by per-output caps."""
+def _v2_values(dims):
+    """Inputs for the v2 table: the 7 dims plus an optional explicit valence."""
+    dims = dims if isinstance(dims, dict) else {}
+    values = {}
+    for name in DIMS:
+        low = -1.0 if name == "goal" else 0.0
+        values[name] = _clamp(dims.get(name, 0.0), low, 1.0)
+    values["valence"] = _clamp(dims.get("valence", 0.0), -1.0, 1.0)
+    return values
+
+
+def _appraise_v2(dims, confidence=0.5, weights=None):
+    """v2 mapping: (deltas, components). Nothing is added into v twice."""
+    conf = _clamp(confidence, 0.0, 1.0)
+    values = _v2_values(dims)
+    table = {out: dict(row) for out, row in V2_WEIGHTS.items()}
+    if isinstance(weights, dict):
+        for key, value in weights.items():
+            if "." not in key:
+                continue
+            dim, output = key.split(".", 1)
+            number = _num(value)
+            if dim in values and output in table and number is not None:
+                table[output][dim] = number
+    deltas = {}
+    components = {}
+    for output in V2_OUTPUTS:
+        rows = {}
+        total = 0.0
+        for name, weight in (table.get(output) or {}).items():
+            part = float(weight) * values.get(name, 0.0) * conf
+            if abs(part) > 1e-9:
+                rows[name] = round(part, 6)
+            total += part
+        cap = float(V2_CAPS.get(output, 0.2))
+        capped = max(-cap, min(cap, total))
+        components[output] = {"rows": rows, "total": round(total, 6),
+                              "capped": round(capped, 6),
+                              "dropped": round(total - capped, 6)}
+        if abs(capped) > 1e-9:
+            deltas[output] = round(capped, 4)
+    return deltas, components
+
+
+def appraise(dims, confidence=0.5, weights=None, v2=None):
+    """W·x scaled by confidence, bounded by per-output caps.
+
+    v2 (default ON) uses V2_WEIGHTS: v = goal + explicit valence only, blame
+    and hit go to their own outputs. v2=False is the old 7x7 mapping, byte for
+    byte.
+    """
+    if v2 is None:
+        v2 = enabled()
+    if v2:
+        deltas, _components = _appraise_v2(dims, confidence, weights)
+        return deltas
     dims = dims if isinstance(dims, dict) else {}
     conf = _clamp(confidence, 0.0, 1.0)
     w = {dim: dict(row) for dim, row in WEIGHTS.items()}
@@ -214,6 +309,80 @@ def appraise(dims, confidence=0.5, weights=None):
     return out
 
 
+def appraise_detail(dims, confidence=0.5, weights=None, v2=None):
+    """Same numbers as appraise(), plus where each one came from.
+
+    components[output][dim] is that dim's own contribution, so v/a are visible
+    derived readouts instead of a black box that quietly folds blame/hit in.
+    Nothing is merged: the caller can show every source line.
+    """
+    if v2 is None:
+        v2 = enabled()
+    if v2:
+        deltas, components = _appraise_v2(dims, confidence, weights)
+        return {"deltas": deltas, "components": components,
+                "mapping": "v2",
+                "derived": {"v": True, "a": False}}
+    dims = dims if isinstance(dims, dict) else {}
+    conf = _clamp(confidence, 0.0, 1.0)
+    w = {dim: dict(row) for dim, row in WEIGHTS.items()}
+    if isinstance(weights, dict):
+        for key, value in weights.items():
+            if "." not in key:
+                continue
+            dim, output = key.split(".", 1)
+            number = _num(value)
+            if dim in w and output in w[dim] and number is not None:
+                w[dim][output] = number
+    values = {}
+    for name in DIMS:
+        low = -1.0 if name == "goal" else 0.0
+        values[name] = _clamp(dims.get(name, 0.0), low, 1.0)
+    gain = 1.0 + INVOLVE_GAIN * values["involve"]
+    components = {}
+    deltas = {}
+    for output in OUTPUTS:
+        rows = {}
+        total = 0.0
+        for name in DIMS:
+            part = float(w[name].get(output, 0.0)) * values[name] * gain * conf
+            if abs(part) > 1e-9:
+                rows[name] = round(part, 6)
+            total += part
+        cap = float(CAPS[output])
+        capped = max(-cap, min(cap, total))
+        components[output] = {"rows": rows,
+                              "total": round(total, 6),
+                              "capped": round(capped, 6),
+                              "dropped": round(total - capped, 6)}
+        if abs(capped) > 1e-9:
+            deltas[output] = round(capped, 4)
+    return {"deltas": deltas, "components": components,
+            "mapping": "v1", "derived": {key: True for key in ("v", "a")}}
+
+
+def legacy_v(dims, confidence=0.5, weights=None):
+    """The old 7x7 v (v1), kept for comparison only -- never written back."""
+    out = appraise(dims, confidence=confidence, weights=weights, v2=False)
+    return out.get("v")
+
+
+def appraise_with_legacy(dims, confidence=0.5, weights=None, v2=None):
+    """{deltas, v, v_legacy, mapping} for /state.appraisal.
+
+    With v2 on, v_legacy is what the old mapping would have produced, so the
+    two can be compared without changing anything. With v2 off there is no
+    second mapping and v_legacy is None.
+    """
+    if v2 is None:
+        v2 = enabled()
+    deltas = appraise(dims, confidence=confidence, weights=weights, v2=v2)
+    return {"deltas": deltas,
+            "v": deltas.get("v", 0.0),
+            "v_legacy": legacy_v(dims, confidence, weights) if v2 else None,
+            "mapping": "v2" if v2 else "v1"}
+
+
 def appraise_dims(dims, weights=None):
     """Compatibility: full-confidence mapping (no confidence scaling)."""
     return appraise(dims, confidence=1.0, weights=weights)

package/python/biocore_model/bio_tick.py

@@ -10,7 +10,8 @@ Literature
   Craig 2009 (insula interoception), Barrett 2017 (constructed emotion),
   Seth 2013 (interoceptive prediction), Garfinkel 2015 (three dimensions),
   Sterling 2012 (allostasis), Carver & Scheier 1998 (cybernetic control),
-  Powers 1973 (perceptual control), Gross 1998 (regulation strategies).
+  Powers 1973 (perceptual control), Gross 1998 (regulation strategies),
+  Anderson & Schooler 1991 (power-law forgetting, ACT-R activation).
 
 Hard constraints: pure functions, stdlib only, no main import, no network, no
 model call; the clock is injected (now / dt_hours); repeated calls with the same
@@ -32,9 +33,12 @@ DT_CAP_HOURS = 6.0
 DISCOMFORT_TRIGGER = 0.35
 LOG_EVERY = 10
 LOG_ENV = "BIOCORE_BIO_TICK_LOG"
-DEFAULT_VALENCE_DECAY_MINUTES = 120.0
-DEFAULT_AROUSAL_DECAY_MINUTES = 30.0
-DEFAULT_SOCIAL_DECAY_MINUTES = 180.0
+DEFAULT_VALENCE_DECAY_MINUTES = 120.0   # [engineering] hand-tuned
+DEFAULT_AROUSAL_DECAY_MINUTES = 30.0    # [engineering] hand-tuned
+DEFAULT_SOCIAL_DECAY_MINUTES = 180.0    # [engineering] hand-tuned
+# Anderson & Schooler 1991, Psychological Science 2:396-408 (ACT-R activation):
+# forgetting follows a power law, not an exponential; d ~= 0.5 in their fits.
+POWER_LAW_EXPONENT = 0.5
 
 
 def _num(value, default=0.0):
@@ -78,12 +82,36 @@ def _snapshot(core):
     return {}
 
 
-def _half_life_factor(minutes, half_life):
+def _power_law_factor(minutes, half_life, exponent=None):
+    """Anderson & Schooler 1991 power law of forgetting: (1 + t / tau) ** -d.
+
+    tau is solved from the configured half-life (tau = half_life / (2**(1/d)-1))
+    so a caller's half-life still means a half-life, while the tail decays like
+    an activation trace instead of dropping geometrically. d is configurable
+    per core through the decay_exponent attribute.
+    """
     try:
         hl = max(1.0, float(half_life))
     except Exception:
         hl = 120.0
-    return 0.5 ** (max(0.0, float(minutes)) / hl)
+    try:
+        power = POWER_LAW_EXPONENT if exponent is None else float(exponent)
+    except Exception:
+        power = POWER_LAW_EXPONENT
+    d = max(0.05, min(2.0, power))
+    try:
+        span = max(1e-6, 2.0 ** (1.0 / d) - 1.0)
+    except Exception:
+        span = 3.0
+    tau = hl / span
+    try:
+        minutes = max(0.0, float(minutes))
+    except Exception:
+        minutes = 0.0
+    return (1.0 + minutes / tau) ** (-d)
+
+
+_half_life_factor = _power_law_factor   # older callers keep working
 
 
 def _derive(core):
@@ -147,13 +175,15 @@ def _decay(core, dt_hours):
     v_rec = recovery if v < 0 else 1.0
     a_rec = recovery if a > 0.40 else 1.0
     s_rec = recovery if soc < 0.55 else 1.0
-    _put(core, "v", _clip(v * _half_life_factor(minutes, v_hl * emo_factor / v_rec), -1, 1))
-    _put(core, "a", _clip(0.40 + (a - 0.40) * _half_life_factor(
-        minutes, a_hl * max(0.5, emo_factor) / a_rec), 0, 1))
-    _put(core, "d", _clip(0.55 + (d - 0.55) * _half_life_factor(
-        minutes, v_hl * emo_factor), -1, 1))
-    _put(core, "social", _clip(0.55 + (soc - 0.55) * _half_life_factor(
-        minutes, s_hl * emo_factor / s_rec), 0, 1))
+    power = _get(core, "decay_exponent", POWER_LAW_EXPONENT)
+    _put(core, "v", _clip(v * _power_law_factor(
+        minutes, v_hl * emo_factor / v_rec, power), -1, 1))
+    _put(core, "a", _clip(0.40 + (a - 0.40) * _power_law_factor(
+        minutes, a_hl * max(0.5, emo_factor) / a_rec, power), 0, 1))
+    _put(core, "d", _clip(0.55 + (d - 0.55) * _power_law_factor(
+        minutes, v_hl * emo_factor, power), -1, 1))
+    _put(core, "social", _clip(0.55 + (soc - 0.55) * _power_law_factor(
+        minutes, s_hl * emo_factor / s_rec, power), 0, 1))
     _derive(core)
     return True
 

package/python/biocore_model/emotion_geometry.py

@@ -23,6 +23,8 @@ PROTOTYPES = {
     "loneliness": {"v": -0.5, "a": -0.4, "d": -0.3, "social": -0.7, "stress": 0.2},
     "trust": {"v": 0.4, "a": 0.1, "d": 0.2, "social": 0.5, "trust": 0.7},
 }
+# [engineering] six-axis weights and the distance formula have no source;
+# the axis choice echoes Russell 1980 / Mehrabian 1996 (see PAPER-MAP.md).
 WEIGHTS = {"v": 0.35, "a": 0.25, "d": 0.15, "social": 0.15,
            "stress": 0.10, "trust": 0.15}
 CORE_DIMS = ("v", "a", "d", "social", "stress", "trust")
@@ -90,7 +92,14 @@ def classify(state, temperature=0.25):
     coverage = present_weight / total_weight if total_weight > 0 else 1.0
     # Missing dimensions always reduce confidence; neutral fill is not evidence.
     confidence *= max(0.0, min(1.0, coverage))
+    # Raw per-emotion closeness (1 - distance) stays visible; the softmax
+    # probability is a DISPLAY label only, never fed back into a decision.
+    scores = {name: round(max(0.0, 1.0 - distance), 4)
+              for name, distance in distances.items()}
     return {"label": label,
+            "scores": scores,
+            "distances": {name: round(value, 4)
+                          for name, value in distances.items()},
             "probs": {name: round(prob, 4) for name, prob in probs.items()},
             "confidence": round(max(0.0, min(1.0, confidence)), 4),
             "top2": top2,

package/python/biocore_model/envy.py

@@ -113,6 +113,26 @@ def _normalize(signals):
     }
 
 
+def _components(norm):
+    """Every signal behind the intensity, each on its own line.
+
+    intensity is kept as a display readout; the components are the evidence,
+    so "comparison" and "self-threat" are never fused into one number.
+    """
+    norm = norm if isinstance(norm, dict) else {}
+    closeness = _clamp01(norm.get("closeness", 0.5), 0.5)
+    fairness = _clamp01(norm.get("fairness", 0.5), 0.5)
+    third = _clamp01(norm.get("third_party", 0.0), 0.0)
+    self_eval = _clamp01(norm.get("self_evaluation", 0.5), 0.5)
+    return {
+        "comparison": round(third, 4),
+        "relative_deprivation": round(1.0 - fairness, 4),
+        "self_threat": round(1.0 - self_eval, 4),
+        "closeness": round(closeness, 4),
+        "presence": round(third * (0.5 + 0.5 * closeness), 4),
+    }
+
+
 def intensity_of(signals):
     """0..1 comparison intensity; the single number behind the three levels."""
     norm = _normalize(signals)
@@ -163,6 +183,7 @@ def assess(signals, config=None):
         "behavior": "",
         "reason": REASONS[""],
         "signals": norm,
+        "components": _components(norm),
     }
     if not out["enabled"]:
         out["reason"] = REASONS["disabled"]

package/python/biocore_model/feedback_memory.py

@@ -14,6 +14,7 @@ BOOST = 0.25
 CORE_AFTER = 5
 D = 0.5
 TAU_HOURS = 24.0
+COOLDOWN_SECONDS = 3600.0   # [engineering] one boost per memory per hour
 
 
 def _num(value, default=0.0):
@@ -50,6 +51,58 @@ def touch(entries, event_id, now, kind="recall"):
     return {"entries": items, "deltas": {}, "audit": [], "idempotent": False}
 
 
+def touch_batch(entries, event_ids, now, kind="recall", limit=None):
+    """Touch several recalled memories: one row per entry, never one aggregate.
+
+    Each entry keeps its own old/new/boost row; an entry already touched at or
+    after `now` is skipped (cooldown), and `limit` caps how many may move in
+    one turn. Returns {"entries", "rows", "deltas", "skipped"}.
+    """
+    items = [dict(entry or {}) for entry in (entries or [])]
+    wanted = [str(item) for item in (event_ids or []) if str(item or "")]
+    if limit is None:
+        limit = len(wanted) or 0
+    rows = []
+    skipped = []
+    moved = 0
+    for target in wanted:
+        if moved >= max(0, int(limit)):
+            skipped.append({"id": target, "reason": "turn_cap"})
+            continue
+        found = None
+        for entry in items:
+            if str(entry.get("id")) == target:
+                found = entry
+                break
+        if found is None:
+            skipped.append({"id": target, "reason": "not_found"})
+            continue
+        last_touch = float(found.get("last_touch_ts", 0.0) or 0.0)
+        if last_touch > 0 and float(now) - last_touch < COOLDOWN_SECONDS:
+            skipped.append({"id": target, "reason": "cooldown"})
+            continue
+        old = _num(found.get("strength"), 1.0)
+        found["strength"] = round(min(1.0, old + BOOST), 4)
+        found["recall_count"] = int(found.get("recall_count", 0) or 0) + 1
+        found["last_touched"] = float(now)
+        found["last_decay_ts"] = float(now)
+        found["last_touch_ts"] = float(now)
+        found["last_touch_kind"] = str(kind)
+        if found["recall_count"] > CORE_AFTER:
+            found["core_memory"] = True
+        rows.append({"id": target, "old": round(old, 4),
+                     "new": found["strength"],
+                     "boost": round(found["strength"] - old, 4),
+                     "recall_count": found["recall_count"],
+                     "source": "feedback_memory", "reason": str(kind)})
+        moved += 1
+    deltas = {row["id"]: {"strength": row["new"],
+                          "recall_count": row["recall_count"]}
+              for row in rows}
+    return {"entries": items, "rows": rows, "deltas": deltas,
+            "skipped": skipped, "idempotent": not rows}
+
+
 def decay_all(entries, now, d=D, tau_hours=TAU_HOURS):
     items = []
     forgotten = []

package/python/biocore_model/needs_events.py

@@ -108,30 +108,51 @@ def apply(needs, events, scale=1.0):
                    "events": applied, "scale": round(factor, 3)}
 
 
-def behavior_bias(needs, baseline=BASELINE):
-    """Need deficits -> 0..1 behavioural biases (expression/inclination)."""
+def need_biases(needs, baseline=BASELINE):
+    """One row per need: value / deficit / surplus / bias.
+
+    Each need keeps its own bias; nothing is combined into one number, so
+    reading belonging never tells you anything about control.
+    """
     state = needs_state(needs)
     base = _clamp(baseline, 0.0, 1.0)
+    rows = {}
+    for key in NEED_KEYS:
+        deficit = max(0.0, base - state[key])
+        surplus = max(0.0, state[key] - base)
+        rows[key] = {"value": state[key],
+                     "deficit": round(deficit, 4),
+                     "surplus": round(surplus, 4),
+                     "bias": round(surplus - deficit, 4)}
+    return rows
+
+
+def behavior_bias(needs, baseline=BASELINE):
+    """Action inclinations, each read from exactly ONE need (no weighted mix).
+
+    Before this change self_assert summed self_esteem and control, and
+    ask_clarify summed control and meaningful_existence; a deficit in one need
+    could therefore masquerade as a deficit in another.
+    """
+    rows = need_biases(needs, baseline)
 
     def deficit(key):
-        return max(0.0, base - state[key])
+        return _clamp(rows.get(key, {}).get("deficit"), 0.0, 1.0)
 
     def surplus(key):
-        return max(0.0, state[key] - base)
+        return _clamp(rows.get(key, {}).get("surplus"), 0.0, 1.0)
 
     return {
         "seek_contact": round(_clamp(3.0 * deficit("belonging"), 0.0, 1.0), 3),
-        "self_assert": round(_clamp(2.0 * surplus("self_esteem")
-                                    + 1.5 * deficit("control"), 0.0, 1.0), 3),
-        "ask_clarify": round(_clamp(2.0 * deficit("control")
-                                    + 1.0 * deficit("meaningful_existence"),
-                                    0.0, 1.0), 3),
+        "self_assert": round(_clamp(2.0 * surplus("self_esteem"), 0.0, 1.0), 3),
+        "ask_clarify": round(_clamp(2.0 * deficit("control"), 0.0, 1.0), 3),
         "share_meaning": round(_clamp(2.5 * surplus("meaningful_existence"),
                                       0.0, 1.0), 3),
     }
 
 
 def summary(needs):
-    """Bounded row for logs/panel."""
+    """Bounded row for logs/panel: the four actions plus every need line."""
     state = needs_state(needs)
-    return {"needs": state, "behavior": behavior_bias(state)}
+    return {"needs": state, "behavior": behavior_bias(state),
+            "bias": need_biases(state)}

package/python/biocore_model/regulation_strategies.py

@@ -228,6 +228,11 @@ def profile(strategy, state=None, event=None, relationship=None):
         "cost": round(cost, 3),
         "effect": round(effect, 3),
         "score": round(score, 3),
+        # never a ratio: effect and cost keep their own numbers, the score is
+        # only the display order the caller sorts by
+        "score_parts": {"fit": round(fit, 3), "effect": round(effect, 3),
+                        "cost": round(cost, 3)},
+        "score_is_display": True,
         "coping_tier": TIER_OF[strategy],
         "reason": REASONS[strategy],
         "self_talk": SELF_TALK[strategy],

package/python/biocore_model/repair_after_boundary.py

@@ -30,6 +30,7 @@ STAGES = ("cold", "state", "record", "turn_page")
 LABELS = {"cold": "冷处理", "state": "明说", "record": "记账",
           "turn_page": "翻页"}
 
+# [engineering] stage durations and the forgive floor are hand-tuned.
 COLD_SECONDS = 300.0       # cold -> state
 STATE_SECONDS = 1800.0     # state -> record
 RECORD_SECONDS = 7200.0    # record -> turn_page

package/python/biocore_model/self_esteem.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 BASELINE = 0.55
 REGRESS = 0.05
 EVENT_DELTAS = {"praised": 0.06, "replied": 0.06, "ignored": -0.05, "insulted": -0.05}
+EVENT_KEEP = 24
 
 
 def clamp(value):
@@ -22,9 +23,16 @@ def initial(now=0.0):
 def update(state, event_type, now):
     data = dict(state or initial(now))
     delta = EVENT_DELTAS.get(str(event_type or ""), 0.0)
-    data["value"] = round(clamp(float(data.get("value", BASELINE)) + delta), 4)
+    before = clamp(float(data.get("value", BASELINE)))
+    data["value"] = round(clamp(before + delta), 4)
     data["last_event"] = str(event_type or "")
     data["last_event_ts"] = float(now)
+    # every event keeps its own row; "value" is only the running aggregate
+    events = [row for row in (data.get("events") or []) if isinstance(row, dict)]
+    events.append({"event": str(event_type or ""), "delta": round(delta, 4),
+                   "before": round(before, 4), "after": data["value"],
+                   "ts": float(now)})
+    data["events"] = events[-EVENT_KEEP:]
     return data
 
 
@@ -46,5 +54,9 @@ def confidence_delta(value):
 def view(state):
     data = dict(state or initial())
     value = round(clamp(float(data.get("value", BASELINE))), 3)
-    return {"value": value, "baseline": BASELINE, "last_event": str(data.get("last_event") or ""),
+    return {"value": value, "baseline": BASELINE,
+            "last_event": str(data.get("last_event") or ""),
+            "events": [dict(row) for row in (data.get("events") or [])
+                       if isinstance(row, dict)],
+            "value_is_aggregate": True,
             "confidence_delta": confidence_delta(value)}

package/python/biocore_model/self_intent.py

@@ -26,8 +26,10 @@ from __future__ import annotations
 import math
 
 NEED_KEYS = ("belonging", "self_esteem", "control", "meaningful_existence")
-NEED_WEIGHTS = {"belonging": 0.30, "self_esteem": 0.25,
-                "control": 0.20, "meaningful_existence": 0.25}
+# Deci & Ryan 2000, Psychological Inquiry 11(4):227-268: the basic needs have
+# equal standing, so every slot weighs the same instead of .30/.25/.20/.25.
+NEED_WEIGHTS = {"belonging": 0.25, "self_esteem": 0.25,
+                "control": 0.25, "meaningful_existence": 0.25}
 KINDS = ("要你陪", "自己待着", "拒绝话题", "顺着你", "说真话")
 
 # Expectations start near the "just fine" line and drift with experience.
@@ -40,8 +42,8 @@ DEFAULT_EXPECTED = {
 EXPECTED_RATE = 0.03          # per-call drift, never a jump
 SELF_WEIGHT_FLOOR = 0.10
 SELF_WEIGHT_CEIL = 0.90
-MIN_WEIGHT = 0.15             # intents below this are dropped
-MAX_INTENTS = 2
+MIN_WEIGHT = 0.15             # [engineering] intents below this are dropped
+MAX_INTENTS = 2               # [engineering]
 MAX_CANDIDATES = 4
 SELF_HANDLE_URGE = 0.35       # below this she tends to handle it herself
 OPEN_UP_URGE = 0.50           # above this she tends to ask / speak up