dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_feedback_flow.py

@@ -0,0 +1,185 @@
+# -*- coding: utf-8 -*-
+"""FB-5 feedback_flow tests: three channels, guard-only writes, idempotency."""
+import re
+import unittest
+from pathlib import Path
+
+from biocore_model import feedback_flow as ff
+
+
+class FakeCore:
+    def __init__(self, state=None):
+        self._snapshot = dict(state or {"v": 0.0, "a": 0.4, "stress": 0.1,
+                                        "self_esteem": 0.5, "social": 0.5})
+        self.loaded = []
+
+    def snapshot(self):
+        return dict(self._snapshot)
+
+    def load_state(self, state):
+        self.loaded.append(dict(state))
+        self._snapshot.update(state)
+
+
+class StrictCore(FakeCore):
+    """Forbids direct affect writes: only the guard-produced load_state path."""
+
+    ALLOWED = {"_snapshot", "loaded", "_state"}
+
+    def __setattr__(self, name, value):
+        if name in self.ALLOWED or name.startswith("_"):
+            object.__setattr__(self, name, value)
+            return
+        raise AssertionError("direct core attribute write: " + name)
+
+
+class Base(unittest.TestCase):
+    def setUp(self):
+        ff.reset_seen()
+        self.core = FakeCore()
+
+    def tearDown(self):
+        ff.reset_seen()
+
+
+class LlmChannelTest(Base):
+    def test_struct_and_summary(self):
+        out = ff.apply_llm({"v": 0.9, "a": 0.9, "stress": 0.9}, self.core, now=1000.0)
+        self.assertIn("v", out["deltas"])
+        self.assertIsInstance(out["rejected"], list)
+        self.assertIsInstance(out["audit"], list)
+        self.assertEqual(set(out["summary"]), set(ff.SUMMARY_FIELDS))
+        for field in ff.SUMMARY_FIELDS:
+            self.assertEqual(set(out["summary"][field]), {"old", "new", "delta"})
+        self.assertGreater(out["summary"]["v"]["new"], out["summary"]["v"]["old"])
+        self.assertEqual(self.core.loaded[-1]["v"], out["summary"]["v"]["new"])
+
+    def test_whitelist_rejection(self):
+        out = ff.apply_llm({"nope": 1.0}, self.core, now=1001.0)
+        self.assertEqual(out["deltas"], {})
+        self.assertIn("nope", out["rejected"])
+
+    def test_idempotent_same_payload_now(self):
+        first = ff.apply_llm({"v": 0.3}, self.core, now=1002.0)
+        snapshot = self.core.snapshot()
+        loaded = len(self.core.loaded)
+        second = ff.apply_llm({"v": 0.3}, self.core, now=1002.0)
+        self.assertTrue(second["idempotent"])
+        self.assertEqual(second["deltas"], {})
+        self.assertEqual(self.core.snapshot(), snapshot)
+        self.assertEqual(len(self.core.loaded), loaded)
+        self.assertEqual(second["summary"]["v"]["old"], second["summary"]["v"]["new"])
+        self.assertGreater(first["summary"]["v"]["new"], first["summary"]["v"]["old"])
+
+    def test_new_now_applies_again(self):
+        ff.apply_llm({"v": 0.3}, self.core, now=1003.0)
+        again = ff.apply_llm({"v": 0.3}, self.core, now=1004.0)
+        self.assertFalse(again["idempotent"])
+        self.assertGreater(again["summary"]["v"]["new"], again["summary"]["v"]["old"])
+
+    def test_caps_come_from_feedback_llm(self):
+        out = ff.apply_llm({"v": 1.0}, FakeCore({"v": 0.0}), now=1005.0)
+        self.assertLessEqual(out["deltas"].get("v", 0.0), 0.15 + 1e-9)
+
+
+class UserChannelTest(Base):
+    def test_struct_and_summary(self):
+        out = ff.apply_user({"kind": "praise", "id": "m1", "ts": 1.0},
+                            self.core, now=2000.0)
+        self.assertIn("self_esteem", out["deltas"])
+        self.assertEqual(set(out["summary"]), set(ff.SUMMARY_FIELDS))
+        self.assertGreater(out["summary"]["self_esteem"]["new"],
+                           out["summary"]["self_esteem"]["old"])
+
+    def test_invalid_kind_rejected(self):
+        out = ff.apply_user({"kind": "not_a_kind"}, self.core, now=2001.0)
+        self.assertEqual(out["deltas"], {})
+        self.assertIn("not_a_kind", out["rejected"])
+        self.assertEqual(self.core.loaded, [])
+
+    def test_idempotent_same_meta_now(self):
+        meta = {"kind": "reply", "id": "m2", "ts": 2.0}
+        ff.apply_user(meta, self.core, now=2002.0)
+        snapshot = self.core.snapshot()
+        again = ff.apply_user(meta, self.core, now=2002.0)
+        self.assertTrue(again["idempotent"])
+        self.assertEqual(again["deltas"], {})
+        self.assertEqual(self.core.snapshot(), snapshot)
+
+
+class MemoryChannelTest(Base):
+    def _entries(self):
+        return [
+            {"id": "old1", "strength": 0.10, "last_decay_ts": 100.0},
+            {"id": "old2", "strength": 0.50, "last_decay_ts": 100.0},
+            {"id": "e1", "strength": 0.50},
+        ]
+
+    def test_decay_and_forgotten(self):
+        out = ff.apply_memory(self._entries(), now=100.0 + 48 * 3600, kind="decay")
+        strengths = {row["id"]: row["strength"] for row in out["entries"]}
+        self.assertLess(strengths["old2"], 0.5)
+        self.assertIn("old1", out["forgotten"])
+        self.assertEqual(out["kind"], "decay")
+
+    def test_recall_touch_copies(self):
+        entries = self._entries()
+        out = ff.apply_memory(entries, now=3000.0, kind="recall:e1")
+        touched = {row["id"]: row for row in out["entries"]}["e1"]
+        self.assertGreater(touched["strength"], 0.5)
+        self.assertEqual(entries[2]["strength"], 0.5)  # input not mutated
+        self.assertEqual(out["forgotten"], [])
+
+    def test_select_returns_selected(self):
+        out = ff.apply_memory(self._entries(), now=3001.0, kind="select:2")
+        self.assertEqual(len(out["entries"]), 2)
+        self.assertTrue(out["changed"])
+        self.assertEqual(out["kind"], "select")
+
+    def test_unknown_kind_noop(self):
+        entries = self._entries()
+        out = ff.apply_memory(entries, now=3002.0, kind="whatever")
+        self.assertEqual(out["kind"], "noop")
+        self.assertFalse(out["changed"])
+        self.assertEqual([row["id"] for row in out["entries"]],
+                         [row["id"] for row in entries])
+
+
+class GuardOnlyWriteTest(unittest.TestCase):
+    def setUp(self):
+        ff.reset_seen()
+
+    def test_no_direct_core_attribute_write(self):
+        core = StrictCore()
+        out = ff.apply_llm({"v": 0.3}, core, now=4000.0)
+        self.assertGreater(out["summary"]["v"]["new"], out["summary"]["v"]["old"])
+        self.assertEqual(core.loaded[-1]["v"], out["summary"]["v"]["new"])
+
+    def test_dict_core_updates_in_place(self):
+        core = {"v": 0.0, "a": 0.4, "stress": 0.1, "self_esteem": 0.5}
+        out = ff.apply_llm({"v": 0.2}, core, now=4001.0)
+        self.assertGreater(core["v"], 0.0)
+        self.assertEqual(core["v"], out["summary"]["v"]["new"])
+
+    def test_source_has_no_main_import_or_core_assignment(self):
+        source = Path(ff.__file__).read_text(encoding="utf-8")
+        self.assertIsNone(re.search(r"^\s*(?:from\s+main|import\s+main)\b",
+                                    source, re.MULTILINE))
+        self.assertIsNone(re.search(r"\bcore\.[A-Za-z_]+\s*=", source))
+        self.assertIn("feedback_guard", source)
+
+
+class ResetSeenTest(unittest.TestCase):
+    def test_reset_allows_reapply(self):
+        ff.reset_seen()
+        core = FakeCore()
+        ff.apply_llm({"v": 0.3}, core, now=5000.0)
+        first_snapshot = core.snapshot()
+        ff.reset_seen()
+        again = ff.apply_llm({"v": 0.3}, core, now=5000.0)
+        self.assertFalse(again["idempotent"])
+        self.assertNotEqual(core.snapshot(), first_snapshot)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_feedback_guard.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import feedback_guard as fg
+
+STATE = {'v': 0.2, 'a': 0.5, 'stress': 0.2, 'social': 0.5, 'social_pain': 0.3, 'self_esteem': 0.5, 'trust': 0.5, 'closeness': 0.5, 'confidence': 0.8, 'needs': {'belonging': 0.6}}
+NOW = 1_700_000_000
+
+class GuardTest(unittest.TestCase):
+    def test_llm_cap(self):
+        out = fg.vet({'v': 0.9}, STATE, 'llm', NOW)
+        self.assertAlmostEqual(out['accepted']['v'], 0.15)
+    def test_user_cap(self):
+        out = fg.vet({'v': 0.9}, STATE, 'user', NOW)
+        self.assertAlmostEqual(out['accepted']['v'], 0.02)
+    def test_other_source_tighter(self):
+        out = fg.vet({'v': 0.9}, STATE, 'other', NOW)
+        self.assertAlmostEqual(out['accepted']['v'], 0.02)
+    def test_stress_cap_llm(self):
+        self.assertAlmostEqual(fg.vet({'stress': 0.9}, STATE, 'llm', NOW)['accepted']['stress'], 0.10)
+    def test_whitelist_rejects_unknown(self):
+        out = fg.vet({'luck': 0.1}, STATE, 'llm', NOW)
+        self.assertEqual(out['rejected'][0]['field'], 'luck')
+    def test_needs_unknown_rejected(self):
+        out = fg.vet({'needs': {'wealth': 0.1}}, STATE, 'llm', NOW)
+        self.assertTrue(any('wealth' in row['field'] for row in out['rejected']))
+    def test_total_cap_v(self):
+        out = fg.vet({'v': 0.15}, STATE, 'llm', NOW)
+        self.assertLessEqual(abs(out['accepted']['v']), 0.15)
+    def test_range_clamp(self):
+        state = dict(STATE, v=0.95)
+        out = fg.vet({'v': 0.15}, state, 'llm', NOW)
+        self.assertLessEqual(out['accepted']['v'], 0.05)
+    def test_idempotent_same_payload(self):
+        seen = {}
+        fg.vet({'v': 0.1}, STATE, 'llm', NOW, seen=seen)
+        second = fg.vet({'v': 0.1}, STATE, 'llm', NOW, seen=seen)
+        self.assertTrue(second['idempotent']); self.assertEqual(second['accepted'], {})
+    def test_audit_fields(self):
+        row = fg.vet({'v': 0.1}, STATE, 'llm', NOW)['audit'][0]
+        for key in ('field', 'old', 'new', 'source', 'reason', 'ts'): self.assertIn(key, row)
+    def test_audit_cap_100(self):
+        seen = {}
+        total = 0
+        for i in range(110):
+            out = fg.vet({'v': 0.01}, STATE, 'llm', NOW + i, seen=seen)
+            total += len(out['audit'])
+        self.assertLessEqual(total, 110)
+    def test_vet_does_not_mutate_state(self):
+        state = dict(STATE)
+        fg.vet({'v': 0.1}, state, 'llm', NOW)
+        self.assertEqual(state, STATE)
+    def test_apply_writes(self):
+        out = fg.apply(STATE, {'v': 0.1, 'needs': {'belonging': 0.05}})
+        self.assertGreater(out['state']['v'], STATE['v']); self.assertIn('v', out['changed'])
+    def test_apply_needs(self):
+        out = fg.apply(STATE, {'needs': {'belonging': 0.05}})
+        self.assertGreater(out['state']['needs']['belonging'], 0.6)
+    def test_deterministic(self):
+        self.assertEqual(fg.vet({'v': 0.1}, STATE, 'llm', NOW), fg.vet({'v': 0.1}, STATE, 'llm', NOW))
+    def test_limits_override(self):
+        out = fg.vet({'v': 0.5}, STATE, 'llm', NOW, limits={'v': 0.05})
+        self.assertAlmostEqual(out['accepted']['v'], 0.05)
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_feedback_llm.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+import re, unittest
+from pathlib import Path
+from biocore_model import feedback_llm as fb
+
+STATE = {'v': 0.0, 'a': 0.5, 'stress': 0.2, 'trust': 0.5, 'closeness': 0.5, 'confidence': 0.8,
+         'needs': {'belonging': 0.6}}
+
+class FeedbackTest(unittest.TestCase):
+    def test_basic_delta(self):
+        out = fb.parse_to_deltas({'v': 0.1}, state=STATE)
+        self.assertAlmostEqual(out['deltas']['v'], 0.1)
+    def test_step_cap_v(self):
+        out = fb.parse_to_deltas({'v': 0.9}, state=STATE)
+        self.assertAlmostEqual(out['deltas']['v'], 0.15)
+    def test_step_cap_stress(self):
+        out = fb.parse_to_deltas({'stress': 0.9}, state=STATE)
+        self.assertLessEqual(out['deltas']['stress'], 0.10)
+    def test_trust_cap(self):
+        out = fb.parse_to_deltas({'trust': 0.9}, state=STATE)
+        self.assertLessEqual(out['deltas']['trust'], 0.05)
+    def test_range_clamp(self):
+        state = dict(STATE, v=0.95)
+        out = fb.parse_to_deltas({'v': 1.0}, state=state)
+        self.assertLessEqual(out['deltas']['v'], 0.05)
+    def test_rejected_unknown(self):
+        out = fb.parse_to_deltas({'mystery': 1}, state=STATE)
+        self.assertIn('mystery', out['rejected'])
+    def test_rejected_bad_type(self):
+        out = fb.parse_to_deltas({'v': 'high'}, state=STATE)
+        self.assertIn('v', out['rejected'])
+    def test_idempotent_same_payload_now(self):
+        seen = {}
+        first = fb.parse_to_deltas({'v': 0.1}, state=STATE, now=100, seen=seen)
+        second = fb.parse_to_deltas({'v': 0.1}, state=STATE, now=100, seen=seen)
+        self.assertTrue(second['idempotent']); self.assertEqual(second['deltas'], {})
+        self.assertTrue(first['deltas'])
+    def test_audit_fields(self):
+        out = fb.parse_to_deltas({'v': 0.1}, state=STATE)
+        row = out['audit'][0]
+        for key in ('field', 'old', 'new', 'source', 'reason'):
+            self.assertIn(key, row)
+        self.assertEqual(row['source'], 'llm')
+    def test_needs_delta(self):
+        out = fb.parse_to_deltas({'needs': {'belonging': 0.8}}, state=STATE)
+        self.assertGreater(out['deltas']['needs']['belonging'], 0)
+    def test_unknown_need_rejected(self):
+        out = fb.parse_to_deltas({'needs': {'wealth': 1}}, state=STATE)
+        self.assertTrue(any('wealth' in item for item in out['rejected']))
+    def test_deterministic(self):
+        self.assertEqual(fb.parse_to_deltas({'v': 0.1}, state=STATE), fb.parse_to_deltas({'v': 0.1}, state=STATE))
+    def test_hash_stable(self):
+        self.assertEqual(fb.payload_hash({'a': 1, 'b': 2}), fb.payload_hash({'b': 2, 'a': 1}))
+    def test_no_core_assignment(self):
+        source = Path(__file__).resolve().parent.parent.joinpath('feedback_llm.py').read_text(encoding='utf-8')
+        self.assertIsNone(re.search(r'core\.[A-Za-z_]+\s*=', source))
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_feedback_llm_inferred.py

@@ -0,0 +1,140 @@
+# -*- coding: utf-8 -*-
+"""FB-1 inferred-meta path tests (interpretation layer -> feedback deltas)."""
+import unittest
+
+from biocore_model import feedback_flow as ff
+from biocore_model import feedback_llm as fl
+
+INFERRED = {
+    "emotion": "joy",
+    "intensity": 0.807,
+    "valence_delta": 0.145,
+    "arousal_delta": 0.048,
+    "dominance_delta": 0.032,
+    "social_delta": 0.040,
+    "trust_delta": 0.016,
+    "confidence": 0.677,
+    "source": "inferred",
+}
+NOW = 1_700_000_000.0
+
+
+class InferredParseTest(unittest.TestCase):
+    def test_full_meta_maps_to_feedback_fields(self):
+        result = fl.parse_to_deltas(INFERRED, now=NOW)
+        self.assertEqual(result["source"], "inferred")
+        deltas = result["deltas"]
+        self.assertAlmostEqual(deltas["v"], 0.0982, places=4)
+        self.assertAlmostEqual(deltas["a"], 0.0325, places=4)
+        self.assertAlmostEqual(deltas["d"], 0.0217, places=4)
+        self.assertAlmostEqual(deltas["social"], 0.0271, places=4)
+        self.assertAlmostEqual(deltas["trust"], 0.0108, places=4)
+        self.assertEqual(result["rejected"], [])
+
+    def test_confidence_scales_deltas(self):
+        low = dict(INFERRED, confidence=0.5)
+        high = dict(INFERRED, confidence=0.9)
+        low_deltas = fl.parse_to_deltas(low, now=NOW)["deltas"]
+        high_deltas = fl.parse_to_deltas(high, now=NOW)["deltas"]
+        for field in ("v", "a", "d", "social", "trust"):
+            self.assertGreater(high_deltas[field], low_deltas[field])
+        self.assertAlmostEqual(high_deltas["v"] / low_deltas["v"], 0.9 / 0.5, places=3)
+
+    def test_low_confidence_produces_nothing(self):
+        payload = dict(INFERRED, confidence=0.39)
+        result = fl.parse_to_deltas(payload, now=NOW)
+        self.assertEqual(result["deltas"], {})
+        self.assertEqual(result.get("gate"), "low_confidence")
+
+    def test_confidence_threshold_boundary(self):
+        result = fl.parse_to_deltas(dict(INFERRED, confidence=0.4), now=NOW)
+        self.assertTrue(result["deltas"])
+        self.assertNotIn("gate", result)
+
+    def test_missing_confidence_produces_nothing(self):
+        payload = dict(INFERRED)
+        payload.pop("confidence")
+        self.assertEqual(fl.parse_to_deltas(payload, now=NOW)["deltas"], {})
+
+    def test_partial_fields_only_emit_present_ones(self):
+        payload = {"valence_delta": 0.1, "confidence": 0.8}
+        deltas = fl.parse_to_deltas(payload, now=NOW)["deltas"]
+        self.assertEqual(list(deltas), ["v"])
+        self.assertAlmostEqual(deltas["v"], 0.08, places=4)
+
+    def test_invalid_field_is_rejected_not_crashing(self):
+        payload = {"valence_delta": "not-a-number", "confidence": 0.9}
+        result = fl.parse_to_deltas(payload, now=NOW)
+        self.assertEqual(result["deltas"], {})
+        self.assertIn("valence_delta", result["rejected"])
+
+    def test_caps_are_applied(self):
+        payload = {"valence_delta": 5.0, "confidence": 1.0}
+        self.assertAlmostEqual(fl.parse_to_deltas(payload, now=NOW)["deltas"]["v"],
+                               0.15, places=4)
+
+    def test_idempotent_same_now(self):
+        seen = {}
+        first = fl.parse_to_deltas(INFERRED, now=NOW, seen=seen)
+        second = fl.parse_to_deltas(INFERRED, now=NOW, seen=seen)
+        self.assertTrue(first["deltas"])
+        self.assertTrue(second["idempotent"])
+        self.assertEqual(second["deltas"], {})
+
+    def test_audit_carries_confidence_and_reason(self):
+        audit = fl.parse_to_deltas(INFERRED, now=NOW)["audit"]
+        self.assertTrue(audit)
+        for row in audit:
+            self.assertEqual(row["reason"], "inferred meta")
+            self.assertEqual(row["source"], "llm")
+            self.assertGreater(row["confidence"], 0)
+
+
+class LegacyPathUnchangedTest(unittest.TestCase):
+    def test_target_value_path_still_works(self):
+        result = fl.parse_to_deltas({"v": 0.9}, state={"v": 0.0}, now=NOW)
+        self.assertAlmostEqual(result["deltas"]["v"], 0.15, places=4)
+
+    def test_needs_path_still_works(self):
+        result = fl.parse_to_deltas(
+            {"needs": {"belonging": 0.9}}, state={"needs": {"belonging": 0.6}},
+            now=NOW)
+        self.assertAlmostEqual(result["deltas"]["needs"]["belonging"], 0.10,
+                               places=4)
+
+
+class ApplyLlmIntegrationTest(unittest.TestCase):
+    def setUp(self):
+        ff.reset_seen()
+
+    def tearDown(self):
+        ff.reset_seen()
+
+    def test_apply_llm_consumes_inferred_meta(self):
+        core = {"v": 0.0, "a": 0.5, "stress": 0.1, "trust": 0.5, "social": 0.5,
+                "self_esteem": 0.5}
+        report = ff.apply_llm(dict(INFERRED), core, NOW)
+        deltas = report["deltas"]
+        self.assertTrue(deltas)
+        self.assertAlmostEqual(deltas["v"], 0.0982, places=4)
+        self.assertAlmostEqual(deltas["a"], 0.0325, places=4)
+        self.assertAlmostEqual(deltas["social"], 0.0271, places=4)
+        self.assertAlmostEqual(deltas["trust"], 0.0108, places=4)
+        # feedback_guard has no 'd' in its whitelist -> rejected at the gate
+        rejected_fields = {row.get("field") if isinstance(row, dict) else row
+                           for row in report["rejected"]}
+        self.assertIn("d", rejected_fields)
+        self.assertNotIn("d", deltas)
+        self.assertGreater(report["summary"]["v"]["new"],
+                           report["summary"]["v"]["old"])
+        self.assertGreater(core["v"], 0.0)
+
+    def test_apply_llm_ignores_low_confidence(self):
+        core = {"v": 0.0, "a": 0.5, "stress": 0.1, "trust": 0.5, "social": 0.5}
+        report = ff.apply_llm(dict(INFERRED, confidence=0.2), core, NOW)
+        self.assertEqual(report["deltas"], {})
+        self.assertEqual(report["summary"]["v"]["new"], report["summary"]["v"]["old"])
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_feedback_memory.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+import random, re, unittest
+from pathlib import Path
+from biocore_model import feedback_memory as fm
+
+NOW = 1_700_000_000
+
+def entry(eid, strength=1.0, last=None):
+    return {'id': eid, 'strength': strength, 'last_decay_ts': last if last is not None else NOW}
+
+class MemoryFeedbackTest(unittest.TestCase):
+    def test_touch_boost(self):
+        out = fm.touch([entry('e1', 0.3)], 'e1', NOW + 10)
+        self.assertGreater(out['entries'][0]['strength'], 0.3); self.assertEqual(out['entries'][0]['recall_count'], 1)
+    def test_touch_cap(self):
+        out = fm.touch([entry('e1', 0.95)], 'e1', NOW + 10)
+        self.assertLessEqual(out['entries'][0]['strength'], 1.0)
+    def test_touch_missing_id_noop(self):
+        out = fm.touch([entry('e1')], 'nope', NOW + 10)
+        self.assertEqual(out['entries'][0]['strength'], 1.0); self.assertEqual(out['audit'], [])
+    def test_touch_idempotent_same_now(self):
+        first = fm.touch([entry('e1', 0.3)], 'e1', NOW + 10)
+        second = fm.touch(first['entries'], 'e1', NOW + 10)
+        self.assertTrue(second['idempotent']); self.assertEqual(second['deltas'], {})
+    def test_core_memory_after_six(self):
+        entries = [entry('e1', 0.5)]
+        for step in range(6):
+            entries = fm.touch(entries, 'e1', NOW + 10 + step)['entries']
+        self.assertTrue(entries[0]['core_memory'])
+    def test_power_law_decay(self):
+        out = fm.decay_all([entry('e1', 1.0, NOW - 86400)], NOW)
+        self.assertAlmostEqual(out['entries'][0]['strength'], round(2 ** -0.5, 4), places=3)
+    def test_core_memory_no_decay(self):
+        e = entry('e1', 0.6, NOW - 86400 * 10); e['core_memory'] = True
+        self.assertEqual(fm.decay_all([e], NOW)['entries'][0]['strength'], 0.6)
+    def test_forgotten_threshold(self):
+        out = fm.decay_all([entry('e1', 0.2, NOW - 86400 * 10)], NOW)
+        self.assertLess(out['entries'][0]['strength'], 0.15); self.assertIn('e1', out['forgotten_ids'])
+    def test_select_skips_weak(self):
+        out = fm.select_for_prompt([entry('a', 0.9), entry('b', 0.05)], limit=2)
+        self.assertEqual([e['id'] for e in out['selected']], ['a']); self.assertIn('b', out['skipped'])
+    def test_select_limit(self):
+        entries = [entry('e%d' % i, 0.5 + i / 10) for i in range(6)]
+        out = fm.select_for_prompt(entries, limit=3, rng=random.Random(1))
+        self.assertEqual(len(out['selected']), 3)
+    def test_select_deterministic_seed(self):
+        entries = [entry('e%d' % i, 0.3 + i / 10) for i in range(5)]
+        a = fm.select_for_prompt(entries, limit=2, rng=random.Random(7))
+        b = fm.select_for_prompt(entries, limit=2, rng=random.Random(7))
+        self.assertEqual([e['id'] for e in a['selected']], [e['id'] for e in b['selected']])
+    def test_audit_fields(self):
+        row = fm.touch([entry('e1', 0.3)], 'e1', NOW + 10)['audit'][0]
+        for key in ('field', 'old', 'new', 'source', 'reason'): self.assertIn(key, row)
+    def test_no_core_assignment(self):
+        source = Path(__file__).resolve().parent.parent.joinpath('feedback_memory.py').read_text(encoding='utf-8')
+        self.assertIsNone(re.search(r'core\.[A-Za-z_]+\s*=', source))
+    def test_only_memory_fields(self):
+        out = fm.touch([entry('e1', 0.3)], 'e1', NOW + 10)
+        allowed = {'strength', 'recall_count', 'last_touched', 'last_decay_ts', 'last_touch_ts', 'last_touch_kind', 'core_memory'}
+        self.assertTrue(set(out['deltas']['e1']).issubset(allowed))
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_feedback_user.py

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+import re, unittest
+from pathlib import Path
+from biocore_model import feedback_user as fu, feedback_llm as fl
+
+STATE = {'v': 0.0, 'social': 0.5, 'stress': 0.2, 'social_pain': 0.3, 'self_esteem': 0.5, 'mood_valence': -0.2}
+NOW = 1_700_000_000
+
+class UserFeedbackTest(unittest.TestCase):
+    def test_reply_deltas(self):
+        out = fu.on_message(STATE, {'kind': 'reply', 'id': 'm1'}, NOW)
+        self.assertGreater(out['deltas']['v'], 0); self.assertLess(out['deltas']['social_pain'], 0)
+    def test_praise(self):
+        out = fu.on_message(STATE, {'kind': 'praise', 'id': 'm2'}, NOW)
+        self.assertGreater(out['deltas']['self_esteem'], 0); self.assertGreater(out['deltas']['v'], 0)
+    def test_insult(self):
+        out = fu.on_message(STATE, {'kind': 'insult', 'id': 'm3'}, NOW)
+        self.assertLess(out['deltas']['self_esteem'], 0); self.assertGreater(out['deltas']['social_pain'], 0)
+    def test_reject(self):
+        out = fu.on_message(STATE, {'kind': 'reject', 'id': 'm4'}, NOW)
+        self.assertGreater(out['deltas']['social_pain'], 0); self.assertLess(out['deltas']['v'], 0)
+    def test_cap_v(self):
+        out = fu.on_message(STATE, {'kind': 'reject', 'id': 'm5'}, NOW)
+        self.assertGreaterEqual(out['deltas']['v'], -0.03); self.assertLessEqual(abs(out['deltas']['v']), 0.03)
+    def test_cap_self_esteem(self):
+        out = fu.on_message(STATE, {'kind': 'insult', 'id': 'm6'}, NOW)
+        self.assertLessEqual(abs(out['deltas']['self_esteem']), 0.05)
+    def test_idempotent_same_event(self):
+        seen = {}
+        first = fu.on_message(STATE, {'kind': 'reply', 'id': 'm7'}, NOW, seen)
+        second = fu.on_message(STATE, {'kind': 'reply', 'id': 'm7'}, NOW, seen)
+        self.assertTrue(second['idempotent']); self.assertEqual(second['deltas'], {})
+        self.assertTrue(first['deltas'])
+    def test_silence_accumulates(self):
+        out = fu.on_silence(STATE, 5, NOW)
+        self.assertGreater(out['deltas']['social_pain'], 0); self.assertLess(out['deltas']['mood_valence'], 0)
+    def test_silence_cap(self):
+        out = fu.on_silence(STATE, 100, NOW)
+        self.assertLessEqual(out['deltas']['social_pain'], 0.10); self.assertGreaterEqual(out['deltas']['mood_valence'], -0.02)
+    def test_silence_idempotent_same_hour(self):
+        seen = {}
+        fu.on_silence(STATE, 5, NOW, seen)
+        second = fu.on_silence(STATE, 5, NOW + 30, seen)
+        self.assertTrue(second['idempotent'])
+    def test_audit_format(self):
+        out = fu.on_message(STATE, {'kind': 'reply', 'id': 'm8'}, NOW)
+        row = out['audit'][0]
+        for key in ('field', 'old', 'new', 'source', 'reason'): self.assertIn(key, row)
+        self.assertEqual(row['source'], 'user')
+    def test_no_field_overlap_with_llm(self):
+        user_fields = set(fu.EVENTS['reply']) | {'mood_valence'}
+        llm_fields = set(fl.CAPS)
+        self.assertTrue(user_fields.isdisjoint({'a', 'trust', 'closeness', 'confidence'}))
+    def test_deterministic(self):
+        self.assertEqual(fu.on_message(STATE, {'kind': 'praise', 'id': 'm9'}, NOW), fu.on_message(STATE, {'kind': 'praise', 'id': 'm9'}, NOW))
+    def test_no_core_assignment(self):
+        source = Path(__file__).resolve().parent.parent.joinpath('feedback_user.py').read_text(encoding='utf-8')
+        self.assertIsNone(re.search(r'core\.[A-Za-z_]+\s*=', source))
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_frustration_curve.py

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+import random, unittest
+from biocore_model import frustration_curve as fc
+
+NOW = 1_700_000_000
+
+class CurveTest(unittest.TestCase):
+    def test_segment_one(self):
+        self.assertAlmostEqual(fc.frustration_mult(1), 1.04); self.assertAlmostEqual(fc.frustration_mult(3), 1.12)
+    def test_segment_two(self):
+        self.assertAlmostEqual(fc.frustration_mult(4), 1.20); self.assertAlmostEqual(fc.frustration_mult(8), 1.24)
+    def test_segment_three(self):
+        self.assertLess(fc.frustration_mult(12), 1.24); self.assertGreaterEqual(fc.frustration_mult(30), 0.9)
+    def test_phase_names(self):
+        self.assertEqual(fc.phase(2), 'invigoration'); self.assertEqual(fc.phase(6), 'plateau'); self.assertEqual(fc.phase(10), 'extinction')
+    def test_inverted_u(self):
+        self.assertGreater(fc.frustration_mult(3), fc.frustration_mult(1))
+        self.assertLess(fc.frustration_mult(20), fc.frustration_mult(8))
+    def test_interval_range(self):
+        for _ in range(50):
+            value = fc.next_interval(rng=random.Random(_))
+            self.assertGreaterEqual(value, 36.0); self.assertLessEqual(value, 96.0)
+    def test_schedule_sets_next(self):
+        state = fc.schedule_tick({}, NOW, rng=random.Random(1))
+        self.assertGreater(state['next_allowed_ts'], NOW)
+    def test_burst_probability(self):
+        state = fc.schedule_tick({}, NOW, rng=random.Random(0))
+        self.assertAlmostEqual(state['next_allowed_ts'], NOW) if state['burst'] else self.assertGreater(state['next_allowed_ts'], NOW)
+    def test_burst_cooldown(self):
+        state = {'burst_cooldown_until': NOW + 3600}
+        state = fc.schedule_tick(state, NOW, rng=random.Random(0))
+        self.assertFalse(state['burst'])
+    def test_wait_blocked_counter(self):
+        state = {'next_allowed_ts': NOW + 600}
+        self.assertEqual(fc.wait_blocked(state, NOW)['wait_blocked'], 1)
+
+class GoalTest(unittest.TestCase):
+    def test_goal_frustration(self):
+        rows = fc.goals_tick([{'id': 'g1', 'progress': 0.2}], NOW, hours=2)
+        self.assertAlmostEqual(rows[0]['frustration_delta'], 0.04)
+    def test_goal_anxiety_near_deadline(self):
+        rows = fc.goals_tick([{'id': 'g1', 'deadline_ts': NOW + 3600}], NOW)
+        self.assertEqual(rows[0]['anxiety_delta'], 0.03)
+    def test_goal_completed(self):
+        out = fc.goal_completed({'id': 'g1'})
+        self.assertEqual(out['joy'], 0.05); self.assertEqual(out['goal']['status'], 'done')
+    def test_done_goal_not_ticked(self):
+        rows = fc.goals_tick([{'id': 'g1', 'status': 'done'}], NOW)
+        self.assertNotIn('frustration_delta', rows[0])
+
+class NeedsTest(unittest.TestCase):
+    def test_allowed_raises_autonomy(self):
+        self.assertGreater(fc.needs_update(allowed=True)['autonomy_need'], 0.5)
+    def test_limited_lowers_autonomy(self):
+        self.assertLess(fc.needs_update(allowed=False)['autonomy_need'], 0.5)
+    def test_helpful_raises_competence(self):
+        self.assertGreater(fc.needs_update(helpful=True)['competence_need'], 0.5)
+    def test_wrong_lowers_competence(self):
+        self.assertLess(fc.needs_update(wrong=True)['competence_need'], 0.5)
+    def test_low_autonomy_suppress_bonus(self):
+        self.assertEqual(fc.needs_update(autonomy=0.2)['suppress_bonus'], 0.2)
+    def test_low_competence_confidence_delta(self):
+        self.assertEqual(fc.needs_update(competence=0.2)['confidence_delta'], -0.05)
+
+if __name__ == '__main__':
+    unittest.main()