dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_exit_or_silence.py

@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+"""task-161 沉默/退出单测：四种动作、概率分布、抽样、关闭、输入健壮性。
+
+只依赖 biocore_model.exit_or_silence 的纯函数；不导入 main.py，不新增
+LLM 调用。
+"""
+import unittest
+
+from biocore_model import exit_or_silence as es
+
+CALM = {"closeness": 0.5, "trust": 0.5, "conflict": 0.0}
+
+
+def decide(**kwargs):
+    return es.exit_or_silence(**kwargs)
+
+
+class ContractTest(unittest.TestCase):
+    def test_actions(self):
+        self.assertEqual(es.ACTIONS,
+                         ("respond", "delay", "silent", "end_topic"))
+
+    def test_result_keys(self):
+        out = decide()
+        for key in ("enabled", "action", "probability", "distribution",
+                    "delay_seconds", "reason", "roll"):
+            self.assertIn(key, out)
+
+    def test_distribution_is_probability(self):
+        for state in (None, {"energy": 0.1, "stress": 0.9},
+                      {"energy": 0.9, "stress": 0.1, "valence": -0.8}):
+            out = decide(state=state)
+            self.assertAlmostEqual(sum(out["distribution"].values()), 1.0,
+                                   places=2)
+            for action, value in out["distribution"].items():
+                self.assertIn(action, es.ACTIONS)
+                self.assertGreaterEqual(value, 0.0)
+                self.assertLessEqual(value, 1.0)
+            self.assertEqual(out["probability"],
+                             out["distribution"][out["action"]])
+
+    def test_reason_present(self):
+        for state in (None, {"energy": 0.1, "stress": 0.9},
+                      {"energy": 0.9, "stress": 0.1}):
+            self.assertTrue(decide(state=state)["reason"])
+
+
+class ActionTest(unittest.TestCase):
+    def test_rested_and_comfortable_responds(self):
+        out = decide(state={"energy": 0.7, "stress": 0.2, "valence": 0.2},
+                     relationship=CALM, topic={"intensity": 0.35})
+        self.assertEqual(out["action"], "respond")
+        self.assertEqual(out["delay_seconds"], 0)
+
+    def test_exhausted_and_tense_goes_silent(self):
+        out = decide(state={"energy": 0.0, "stress": 1.0, "valence": -1.0},
+                     relationship=CALM)
+        self.assertEqual(out["action"], "silent")
+        self.assertEqual(out["delay_seconds"], 0)
+
+    def test_heavy_topic_ends_topic(self):
+        out = decide(state={"energy": 0.5, "stress": 0.5, "valence": -0.4},
+                     relationship={"closeness": 0.3, "trust": 0.2,
+                                   "conflict": 0.5},
+                     topic={"intensity": 1.0})
+        self.assertEqual(out["action"], "end_topic")
+
+    def test_one_foot_out_the_door_delays(self):
+        out = decide(state={"energy": 0.4, "stress": 0.9, "valence": 0.0},
+                     relationship={"closeness": 0.6, "trust": 0.6},
+                     topic={"intensity": 0.5})
+        self.assertEqual(out["action"], "delay")
+        self.assertGreaterEqual(out["delay_seconds"], es.DELAY_MIN_S)
+        self.assertLessEqual(out["delay_seconds"], es.DELAY_MAX_S)
+
+    def test_conflict_does_not_force_respond(self):
+        out = decide(state={"energy": 0.6, "stress": 0.4, "valence": -0.3},
+                     relationship={"conflict": 0.8},
+                     topic={"intensity": 0.5})
+        self.assertIn(out["action"], ("delay", "silent", "end_topic"))
+        self.assertLess(out["distribution"]["respond"], 0.30)
+
+    def test_close_relationship_raises_respond_probability(self):
+        near = decide(state={"energy": 0.6, "stress": 0.3},
+                       relationship={"closeness": 0.95, "trust": 0.9},
+                       topic={"intensity": 0.3})
+        far = decide(state={"energy": 0.6, "stress": 0.3},
+                      relationship={"closeness": 0.1, "trust": 0.1},
+                      topic={"intensity": 0.3})
+        self.assertGreater(near["distribution"]["respond"],
+                           far["distribution"]["respond"])
+
+
+class TopicIntensityTest(unittest.TestCase):
+    def test_higher_intensity_raises_end_topic(self):
+        low = decide(state={"energy": 0.6, "stress": 0.3},
+                     topic={"intensity": 0.2})
+        high = decide(state={"energy": 0.6, "stress": 0.3},
+                      topic={"intensity": 1.0})
+        self.assertGreater(high["distribution"]["end_topic"],
+                           low["distribution"]["end_topic"])
+
+    def test_heavy_kind_counts_as_heavy_topic(self):
+        plain = decide(topic={"intensity": 0.1})
+        heavy = decide(topic={"kind": "conflict", "intensity": 0.1})
+        self.assertGreater(heavy["distribution"]["end_topic"],
+                           plain["distribution"]["end_topic"])
+
+    def test_numeric_topic_is_accepted(self):
+        out = decide(topic=0.9)
+        self.assertIn(out["action"], es.ACTIONS)
+
+
+class SamplingTest(unittest.TestCase):
+    def test_roll_zero_is_respond(self):
+        out = decide(state={"energy": 0.1, "stress": 0.9}, roll=0.0)
+        self.assertEqual(out["action"], "respond")
+
+    def test_high_roll_reaches_last_action(self):
+        out = decide(state={"energy": 0.1, "stress": 0.9}, roll=0.9999)
+        self.assertEqual(out["action"], "end_topic")
+
+    def test_roll_reports_action_probability(self):
+        out = decide(state={"energy": 0.1, "stress": 0.9}, roll=0.9)
+        self.assertEqual(out["probability"],
+                         out["distribution"][out["action"]])
+        self.assertIsNotNone(out["roll"])
+
+    def test_roll_is_clamped(self):
+        for roll in (-1.0, 2.0):
+            out = decide(roll=roll)
+            self.assertIn(out["action"], es.ACTIONS)
+
+
+class SwitchTest(unittest.TestCase):
+    def test_disabled_always_responds(self):
+        out = decide(state={"energy": 0.0, "stress": 1.0},
+                     flags={"enabled": False})
+        self.assertFalse(out["enabled"])
+        self.assertEqual(out["action"], "respond")
+        self.assertEqual(out["probability"], 1.0)
+        self.assertEqual(out["distribution"]["respond"], 1.0)
+        self.assertIn("关闭", out["reason"])
+
+    def test_disabled_directives_send(self):
+        out = es.directives(decide(state={"energy": 0.0},
+                                  flags={"enabled": False}))
+        self.assertTrue(out["send"])
+        self.assertEqual(out["action"], "respond")
+
+
+class HelpersTest(unittest.TestCase):
+    def test_should_reply_matches_action(self):
+        silent = decide(state={"energy": 0.0, "stress": 1.0,
+                              "valence": -1.0})
+        self.assertEqual(silent["action"], "silent")
+        self.assertFalse(es.should_reply(silent))
+        self.assertTrue(es.should_reply(decide()))
+        self.assertTrue(es.should_reply(None))
+
+    def test_directives_map_actions(self):
+        self.assertFalse(es.directives(decide(
+            state={"energy": 0.0, "stress": 1.0, "valence": -1.0}))["send"])
+        delay = decide(state={"energy": 0.4, "stress": 0.9},
+                       relationship={"closeness": 0.6, "trust": 0.6},
+                       topic={"intensity": 0.5})
+        self.assertEqual(delay["action"], "delay")
+        directive = es.directives(delay)
+        self.assertTrue(directive["send"])
+        self.assertEqual(directive["delay_seconds"], delay["delay_seconds"])
+        self.assertGreater(directive["delay_seconds"], 0)
+
+    def test_directives_bounded(self):
+        for state in (None, {"energy": 0.1, "stress": 0.9},
+                      {"energy": 0.9, "valence": -0.9}):
+            out = es.directives(decide(state=state))
+            self.assertGreaterEqual(out["length_scale"], 0.0)
+            self.assertLessEqual(out["length_scale"], 1.0)
+            self.assertIn("tone", out)
+
+    def test_delay_seconds_only_for_delay(self):
+        out = decide(state={"energy": 0.0, "stress": 1.0,
+                     "valence": -1.0})
+        self.assertEqual(out["action"], "silent")
+        self.assertEqual(out["delay_seconds"], 0)
+        self.assertEqual(decide()["delay_seconds"], 0)
+
+
+class RobustnessTest(unittest.TestCase):
+    def test_none_and_odd_inputs(self):
+        for state in (None, {}, "x", 3, []):
+            out = decide(state=state)
+            self.assertIn(out["action"], es.ACTIONS)
+        self.assertEqual(decide()["action"], "respond")
+
+    def test_nan_values_are_safe(self):
+        out = decide(state={"energy": float("nan"),
+                            "stress": None, "valence": "x"})
+        self.assertIn(out["action"], es.ACTIONS)
+        self.assertTrue(out["reason"])
+
+    def test_relationship_defaults_from_state(self):
+        out = decide(state={"closeness": 0.1, "trust": 0.1},
+                     relationship={})
+        self.assertEqual(out["action"], "respond")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_expr_guard.py

@@ -0,0 +1 @@
+from biocore_model.tests.test_expr_template import GuardTest  # noqa: F401

package/python/biocore_model/tests/test_expr_intent.py

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+import random, unittest
+from biocore_model import expr_intent as ei
+
+NOW = 1_700_000_000
+
+def cand(kind, **kw):
+    data = {'kind': kind, 'text_hint': kind + ' hint', 'novelty': 1.0}
+    data.update(kw)
+    return data
+
+class IntentTest(unittest.TestCase):
+    def test_eight_kinds_available(self):
+        for kind in ei.BASE:
+            self.assertIn(kind, ei.BASE)
+    def test_picks_some_kind(self):
+        out = ei.pick_intent([cand(k) for k in ei.BASE], {}, random.Random(1))
+        self.assertIn(out['kind'], ei.BASE)
+    def test_text_hint_returned(self):
+        out = ei.pick_intent([cand('repair')], {}, random.Random(1))
+        self.assertEqual(out['text_hint'], 'repair hint')
+    def test_novelty_excludes_low(self):
+        out = ei.pick_intent([cand('repair', novelty=0.2), cand('question', novelty=1.0)], {}, random.Random(1))
+        self.assertEqual(out['kind'], 'question')
+    def test_gratitude_requires_event(self):
+        out = ei.pick_intent([cand('gratitude'), cand('comfort')], {}, random.Random(1))
+        self.assertEqual(out['kind'], 'comfort')
+    def test_memory_due_requires_event(self):
+        self.assertNotEqual(ei.pick_intent([cand('memory_due')], {}, random.Random(1))['kind'], 'memory_due')
+    def test_memory_due_requires_window(self):
+        out = ei.pick_intent([cand('memory_due', event_ref='e1', due_ts=NOW + 10 * 86400)], {'now': NOW}, random.Random(1))
+        self.assertEqual(out['kind'], '')
+    def test_bid_frequency_modulates(self):
+        low = ei.pick_intent([cand('question')], {'bid_frequency': 0.5}, random.Random(0))
+        high = ei.pick_intent([cand('question')], {'bid_frequency': 1.3}, random.Random(0))
+        self.assertGreater(high['weight'], low['weight'])
+    def test_responsiveness_modulates_self_life(self):
+        low = ei.pick_intent([cand('self_life')], {'responsiveness': 0.1}, random.Random(0))
+        high = ei.pick_intent([cand('self_life')], {'responsiveness': 0.9}, random.Random(0))
+        self.assertGreater(high['weight'], low['weight'])
+    def test_deactivating_halves_self_life(self):
+        normal = ei.pick_intent([cand('self_life')], {}, random.Random(0))
+        avoidant = ei.pick_intent([cand('self_life')], {'attachment_mode': 'deactivating'}, random.Random(0))
+        self.assertAlmostEqual(avoidant['weight'], normal['weight'] * 0.5, places=3)
+    def test_consecutive_same_kind_excluded(self):
+        out = ei.pick_intent([cand('repair'), cand('comfort')], {'recent_kinds': ['repair', 'repair']}, random.Random(1))
+        self.assertEqual(out['kind'], 'comfort')
+    def test_single_recent_kind_allowed(self):
+        out = ei.pick_intent([cand('repair')], {'recent_kinds': ['repair']}, random.Random(1))
+        self.assertEqual(out['kind'], 'repair')
+    def test_deterministic_with_seed(self):
+        args = ([cand(k) for k in ei.BASE], {}, random.Random(7))
+        first = ei.pick_intent(*args)
+        second = ei.pick_intent([cand(k) for k in ei.BASE], {}, random.Random(7))
+        self.assertEqual(first, second)
+    def test_alternatives_listed(self):
+        out = ei.pick_intent([cand('repair'), cand('comfort'), cand('question')], {}, random.Random(1))
+        self.assertNotIn(out['kind'], out['alternatives']); self.assertEqual(len(out['alternatives']), 2)
+    def test_empty_candidates(self):
+        self.assertEqual(ei.pick_intent([], {}, random.Random(1))['kind'], '')
+    def test_no_field_name_leak_in_hint(self):
+        out = ei.pick_intent([cand('self_life')], {}, random.Random(1))
+        self.assertNotIn('valence=', out['text_hint'])
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_expr_state.py

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import expr_state as es
+
+FULL = {
+    'labels': {'emotion': 'joy', 'intensity': 0.62},
+    'spectrum_probs': {'joy': 0.62, 'contentment': 0.23, 'amusement': 0.15},
+    'v': 0.42, 'a': 0.66, 'd': 0.52, 'social': 0.61, 'stress': 0.24, 'energy': 0.81,
+    'mood': {'valence': -0.15, 'arousal': 0.4, 'label': '偏低'},
+    'needs': {'belonging': 0.42, 'control': 0.58, 'meaningful_existence': 0.60},
+    'self_esteem': 0.51, 'social_pain': 0.35,
+    'attachment': {'activation': 0.42, 'mode': 'hyperactivating'},
+    'regulation': {'strategy': 'suppress', 'effort': 0.30},
+    'sleep_debt': 1.2,
+    'attribution': {'locus': 'external', 'stability': 'unstable'},
+}
+REL = {'state': {'closeness': 0.61, 'trust': 0.57, 'conflict': 0.22}}
+
+class ExprStateTest(unittest.TestCase):
+    def test_full_render_has_sections(self):
+        out = es.render_state_block(FULL, REL)
+        for key in ('joy', '情绪还挺杂', '心情', '自尊', '被冷落', '依恋', '在忍着', '关系', '觉得是'):
+            self.assertIn(key, out['text'])
+    def test_empty_returns_empty(self):
+        out = es.render_state_block({}, {})
+        self.assertEqual(out['text'], ''); self.assertEqual(out['parts_used'], [])
+    def test_missing_fields_skip(self):
+        out = es.render_state_block({'labels': {'emotion': 'neutral'}}, {})
+        self.assertIn('neutral', out['text'])
+    def test_budget_truncates_optional(self):
+        out = es.render_state_block(FULL, REL, budget_chars=80)
+        self.assertTrue(out['truncated']); self.assertLessEqual(len(out['text']), 80)
+    def test_mandatory_kept_under_budget(self):
+        out = es.render_state_block(FULL, REL, budget_chars=200)
+        for key in ('joy', '情绪还挺杂', '心情'):
+            self.assertIn(key, out['text'])
+    def test_parts_used_lists_present(self):
+        out = es.render_state_block(FULL, REL)
+        self.assertIn('emotion', out['parts_used']); self.assertIn('relationship', out['parts_used'])
+    def test_no_field_names(self):
+        out = es.render_state_block(FULL, REL)
+        for name in es.FIELD_NAMES:
+            self.assertNotIn(name + '=', out['text'])
+    def test_adverb_mapping(self):
+        self.assertEqual(es.adverb(0.85), '很')
+        self.assertEqual(es.adverb(0.65), '有点')
+        self.assertEqual(es.adverb(0.45), '略')
+        self.assertEqual(es.adverb(0.1), '几乎不')
+    def test_self_esteem_note(self):
+        self.assertIn('犹豫', es.render_state_block({'self_esteem': 0.3}, {})['text'])
+    def test_attachment_modes(self):
+        text = es.render_state_block({'attachment': {'activation': 0.5, 'mode': 'deactivating'}}, {})['text']
+        self.assertIn('想退开', text)
+    def test_sleep_debt_threshold(self):
+        self.assertEqual(es.render_state_block({'sleep_debt': 0.1}, {})['text'], '')
+        self.assertIn('有点累', es.render_state_block({'sleep_debt': 1.2}, {})['text'])
+    def test_relationship_values(self):
+        text = es.render_state_block({}, REL)['text']
+        self.assertIn('亲近', text); self.assertIn('信任', text)
+    def test_attribution_neutral_skipped(self):
+        self.assertEqual(es.render_state_block({'attribution': {'locus': 'neutral'}}, {})['text'], '')
+    def test_render_is_deterministic(self):
+        self.assertEqual(es.render_state_block(FULL, REL), es.render_state_block(FULL, REL))
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_expr_template.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+import re, unittest
+from pathlib import Path
+from biocore_model import expr_template as et, expr_guard as eg
+
+OPTS = {'persona': '你是小灰', 'speak_style': '像在群里回消息', 'output_protocol': '只输出正文 + <bc>'}
+CTX = {'state_block': '她现在有点低落', 'relationship': '亲近', 'gap': '几小时前', 'event_hints': ['他提过体检']}
+
+class TemplateTest(unittest.TestCase):
+    def test_system_persona_then_speak(self):
+        out = et.build_proactive(state_ctx=CTX, opts=OPTS)
+        self.assertLess(out['system'].index('小灰'), out['system'].index('群里'))
+    def test_user_order(self):
+        out = et.build_proactive(state_ctx=CTX, intent={'kind': 'comfort', 'text_hint': '想关心'}, tone='语气自然', guard=eg.guard_block(), opts=OPTS)
+        self.assertEqual(out['order'], ['状态', '关系', '间隔', '你记得', '意图', '语气'])
+    def test_user_text_order(self):
+        out = et.build_proactive(state_ctx=CTX, intent={'text_hint': '想关心'}, tone='语气自然', guard=eg.guard_block(), opts=OPTS)
+        user = out['user']
+        self.assertLess(user.index('低落'), user.index('亲近'))
+        self.assertLess(user.index('亲近'), user.index('几小时前'))
+        self.assertLess(user.index('想关心'), user.index('语气自然'))
+        self.assertNotIn('【输出格式', user)
+        self.assertNotIn('<bc>', out['system'])
+    def test_missing_optional_skipped(self):
+        out = et.build_proactive(state_ctx={'state_block': '平静'}, opts=OPTS)
+        self.assertEqual(out['order'], ['状态'])
+    def test_intent_kind_fallback(self):
+        out = et.build_proactive(intent={'kind': 'repair'}, opts=OPTS)
+        self.assertIn('repair', out['user'])
+    def test_deterministic(self):
+        a = et.build_proactive(state_ctx=CTX, intent={'text_hint': 'x'}, tone='t', guard='g', opts=OPTS)
+        b = et.build_proactive(state_ctx=CTX, intent={'text_hint': 'x'}, tone='t', guard='g', opts=OPTS)
+        self.assertEqual(a, b)
+    def test_no_core_assignment(self):
+        for name in ('expr_template.py', 'expr_guard.py'):
+            source = Path(__file__).resolve().parent.parent.joinpath(name).read_text(encoding='utf-8')
+            self.assertIsNone(re.search(r'core\.[A-Za-z_]+\s*=', source), name)
+    def test_build_reply_has_no_intent(self):
+        out = et.build_reply(state_ctx=CTX, tone='语气自然', guard='g', opts=OPTS)
+        self.assertNotIn('意图', out['order'])
+    def test_hints_list_joined(self):
+        out = et.build_reply(state_ctx={'event_hints': ['a', 'b']}, opts=OPTS)
+        self.assertIn('a；b', out['user'])
+    def test_protocol_default_present_in_system(self):
+        out = et.build_reply(opts={})
+        self.assertNotIn('【输出格式', out['system'])
+        self.assertNotIn('<bc>', out['system'])
+        self.assertNotIn('【输出格式', out['user'])
+
+class GuardTest(unittest.TestCase):
+    def test_block_mentions_four(self):
+        block = eg.guard_block()
+        for token in ('编造', '数值', '内疚', '系统'):
+            self.assertIn(token, block)
+    def test_forbidden_cases(self):
+        for text in ('你不理我我就难过', '我这么难受你也不管', '系统说', '模型觉得', '触发了一次', '权限不足'):
+            ok, reason = eg.assert_clean(text)
+            self.assertFalse(ok, text); self.assertTrue(reason)
+    def test_clean_positive(self):
+        ok, _reason = eg.assert_clean('今天吃了苹果派，想跟你说一句。')
+        self.assertTrue(ok)
+    def test_assert_clean_deterministic(self):
+        self.assertEqual(eg.assert_clean('系统'), eg.assert_clean('系统'))
+    def test_guard_block_deterministic(self):
+        self.assertEqual(eg.guard_block(), eg.guard_block())
+    def test_no_assignment_in_guard(self):
+        source = Path(__file__).resolve().parent.parent.joinpath('expr_guard.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_expr_tone.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import expr_tone as et
+
+class ToneTest(unittest.TestCase):
+    def test_anxiety(self):
+        out = et.tone_block('anxiety')
+        self.assertAlmostEqual(out['chars_mult'], 0.8); self.assertIn('想问清楚', out['text'])
+    def test_sadness(self):
+        out = et.tone_block('sadness'); self.assertAlmostEqual(out['chars_mult'], 0.7)
+    def test_anger(self):
+        self.assertAlmostEqual(et.tone_block('anger')['chars_mult'], 0.9)
+    def test_joy(self):
+        out = et.tone_block('joy'); self.assertAlmostEqual(out['chars_mult'], 1.2); self.assertIn('分享', out['text'])
+    def test_guilt(self):
+        self.assertAlmostEqual(et.tone_block('guilt')['chars_mult'], 0.75)
+    def test_calm(self):
+        self.assertEqual(et.tone_block('calm')['chars_mult'], 1.0)
+    def test_suppress_shrinks(self):
+        out = et.tone_block('joy', regulation='suppress')
+        self.assertTrue(out['suppressed']); self.assertLess(out['chars_mult'], 1.2); self.assertIn('收一点', out['text'])
+    def test_reappraise_steady(self):
+        self.assertIn('讲道理', et.tone_block('sadness', regulation='reappraise')['text'])
+    def test_low_esteem_uncertain(self):
+        out = et.tone_block('calm', self_esteem=0.3)
+        self.assertIn('也许', out['text']); self.assertEqual(out['text'].count('也许'), 1)
+    def test_high_esteem_no_uncertain(self):
+        self.assertNotIn('也许', et.tone_block('calm', self_esteem=0.8)['text'])
+    def test_deterministic(self):
+        self.assertEqual(et.tone_block('anger', 'joy', 0.4, 0.5, 'suppress'), et.tone_block('anger', 'joy', 0.4, 0.5, 'suppress'))
+    def test_unknown_falls_back_calm(self):
+        self.assertEqual(et.tone_block('bogus')['tendency'], 'calm')
+    def test_emotion_fallback(self):
+        self.assertEqual(et.tone_block(None, 'sadness')['tendency'], 'sadness')
+    def test_no_psych_terms(self):
+        for tendency in et.BASE:
+            text = et.tone_block(tendency)['text']
+            self.assertNotIn('行动倾向', text); self.assertNotIn('焦虑值', text)
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_extreme_scenarios.py

@@ -0,0 +1,147 @@
+# -*- coding: utf-8 -*-
+"""P2-2 eight extreme-scenario tests (extreme_scenarios.py)."""
+import unittest
+from pathlib import Path
+
+from biocore_model import extreme_scenarios as es
+
+ROOT = Path(__file__).resolve().parents[2]
+SOURCE = (ROOT / "biocore_model" / "extreme_scenarios.py").read_text(
+    encoding="utf-8")
+
+
+def _in_bounds(state):
+    return all(-1.0 <= state[key] <= 1.0 if key in ("v", "d")
+               else 0.0 <= state[key] <= 1.0 for key in es.CHANNELS)
+
+
+class ScenarioMatrixTest(unittest.TestCase):
+    def test_all_eight_scenarios_pass(self):
+        report = es.run_all()
+        self.assertTrue(report["ok"])
+        self.assertEqual(len(report["scenarios"]), 8)
+        names = [item["scenario"] for item in report["scenarios"]]
+        self.assertEqual(sorted(names), sorted(es.SCENARIOS))
+        for item in report["scenarios"]:
+            self.assertTrue(item["ok"], item)
+            self.assertIsInstance(item["details"], dict)
+
+    def test_declared_scenarios_are_eight(self):
+        self.assertEqual(len(es.SCENARIOS), 8)
+        self.assertEqual(len(set(es.SCENARIOS)), 8)
+
+
+class LongSilenceTest(unittest.TestCase):
+    def test_recovery_toward_baseline(self):
+        report = es.long_silence({"v": 0.9, "stress": 0.95, "trust": 0.9},
+                                 gap_hours=24 * 30 * 4)
+        self.assertTrue(report["ok"])
+        details = report["details"]
+        self.assertLess(details["state"]["stress"], 0.95)
+        self.assertLess(details["state"]["v"], 0.9)
+        self.assertGreater(details["recovered"], 0.9)
+        self.assertTrue(_in_bounds(details["state"]))
+
+    def test_zero_gap_keeps_state(self):
+        report = es.long_silence({"v": 0.5, "stress": 0.7}, gap_hours=0)
+        self.assertEqual(report["details"]["state"]["v"], 0.5)
+        self.assertEqual(report["details"]["state"]["stress"], 0.7)
+
+
+class AbuseTest(unittest.TestCase):
+    def test_abuse_stays_bounded(self):
+        report = es.repeated_abuse(200)
+        details = report["details"]
+        self.assertTrue(report["ok"])
+        self.assertEqual(details["stress"], 1.0)
+        self.assertEqual(details["trust"], 0.0)
+        self.assertEqual(details["conflict"], 1.0)
+        self.assertGreaterEqual(details["v"], -1.0)
+        self.assertTrue(0.0 <= details["refusal"] <= 1.0)
+
+    def test_zero_hits_is_neutral(self):
+        details = es.repeated_abuse(0)["details"]
+        self.assertEqual(details["stress"], es.BASELINE["stress"])
+        self.assertEqual(details["trust"], es.BASELINE["trust"])
+
+
+class PraiseTest(unittest.TestCase):
+    def test_praise_saturates(self):
+        report = es.repeated_praise(500)
+        details = report["details"]
+        self.assertTrue(report["ok"])
+        self.assertEqual(details["v"], 1.0)
+        self.assertEqual(details["self_esteem"], 1.0)
+        self.assertLessEqual(details["trust"], 1.0)
+
+
+class BreakdownTest(unittest.TestCase):
+    def test_breakdown_recovery_is_bounded(self):
+        report = es.relationship_breakdown({"trust": 0.9, "social": 0.8})
+        details = report["details"]
+        self.assertTrue(report["ok"])
+        self.assertEqual(details["trust"], 0.0)
+        self.assertGreater(details["repair_urge"], 0.0)
+        self.assertLessEqual(details["repair_urge"], 1.0)
+        self.assertGreaterEqual(details["recover_step"], 0.0)
+
+
+class AmnesiaTest(unittest.TestCase):
+    def test_missing_state_uses_baseline(self):
+        details = es.amnesia({})["details"]
+        self.assertEqual(details["state"]["stress"], es.BASELINE["stress"])
+        self.assertEqual(details["state"]["trust"], es.BASELINE["trust"])
+        self.assertEqual(set(details["needs"]), set(es.NEEDS))
+
+    def test_dirty_state_is_clamped(self):
+        details = es.amnesia({"v": 9.0, "needs": {"belonging": 5.0},
+                              "junk": 1})["details"]
+        self.assertEqual(details["state"]["v"], 1.0)
+        self.assertEqual(details["needs"]["belonging"], 1.0)
+        self.assertIn("junk", details["dropped"])
+
+
+class ConcurrentUsersTest(unittest.TestCase):
+    def test_states_do_not_leak(self):
+        report = es.concurrent_users({"u1": {"v": 0.5, "trust": 0.9},
+                                      "u2": {"v": -0.5, "trust": 0.1}})
+        self.assertTrue(report["ok"])
+        self.assertEqual(report["details"]["leaked"], [])
+        rows = report["details"]["rows"]
+        self.assertEqual(rows["u1"]["v"], 0.5)
+        self.assertEqual(rows["u2"]["v"], -0.5)
+        self.assertNotEqual(rows["u1"]["trust"], rows["u2"]["trust"])
+
+    def test_empty_users_is_safe(self):
+        self.assertTrue(es.concurrent_users(None)["ok"])
+
+
+class LateNightTest(unittest.TestCase):
+    def test_quiet_hours(self):
+        for hour in (0, 3, 7):
+            report = es.late_night(hour)
+            self.assertTrue(report["ok"])
+            self.assertFalse(report["details"]["send_allowed"])
+        for hour in (8, 14, 23):
+            self.assertTrue(es.late_night(hour)["details"]["send_allowed"])
+
+
+class CrashRecoveryTest(unittest.TestCase):
+    def test_dirty_values_recover(self):
+        details = es.crash_recovery({"stress": 0.4, "v": 0.9})["details"]
+        restored = details["restored"]
+        self.assertEqual(restored["v"], 0.0)          # NaN
+        self.assertEqual(restored["a"], es.BASELINE["a"])  # inf -> baseline
+        self.assertEqual(restored["stress"], es.BASELINE["stress"])  # string
+        self.assertEqual(restored["trust"], 1.0)      # 99 clamps
+        self.assertEqual(restored["energy"], 0.0)     # -5 clamps
+        self.assertTrue(_in_bounds(restored))
+
+    def test_module_is_pure(self):
+        self.assertNotIn("import main", SOURCE)
+        self.assertNotIn("time.", SOURCE)
+        self.assertNotIn("open(", SOURCE)
+
+
+if __name__ == "__main__":
+    unittest.main()