dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_self_layer_wiring.py

@@ -0,0 +1,198 @@
+# -*- coding: utf-8 -*-
+"""task-149/150/151 接线测试：三个自我层模块 + 面板投射（只读源码断言）。
+
+纯函数行为由 test_prospective / test_voice_bank / test_metacog 覆盖；这里只确认
+main.py 的接线位置、开关默认值、回退守卫、提示合流与面板投射都存在，不导入
+AstrBot。
+"""
+import json
+import unittest
+from pathlib import Path
+
+from biocore_model import self_intent as si
+
+ROOT = Path(__file__).resolve().parents[2]
+MAIN = (ROOT / "main.py").read_text(encoding="utf-8")
+ROUTES = (ROOT / "biocore_model" / "plugin_routes.py").read_text(encoding="utf-8")
+SCHEMA = json.loads((ROOT / "_conf_schema.json").read_text(encoding="utf-8"))
+DASH = ROOT / "pages" / "dashboard"
+SRC_HTML = (DASH / "index.src.html").read_text(encoding="utf-8")
+INDEX_HTML = (DASH / "index.html").read_text(encoding="utf-8")
+APP_JS = (DASH / "app.js").read_text(encoding="utf-8")
+
+
+class FlagTest(unittest.TestCase):
+    def test_schema_flags_default_true(self):
+        for key in ("prospective_enabled", "voice_bank_enabled",
+                    "metacog_enabled"):
+            entry = SCHEMA.get(key)
+            self.assertIsInstance(entry, dict, key)
+            self.assertEqual(entry.get("type"), "bool", key)
+            self.assertIs(entry.get("default"), True, key)
+
+    def test_main_reads_flags(self):
+        for key in ("prospective_enabled", "voice_bank_enabled",
+                    "metacog_enabled"):
+            self.assertIn('self.config.get("%s", True)' % key, MAIN)
+        self.assertIn("self.prospective_enabled = True", MAIN)
+        self.assertIn("self.voice_bank_enabled = True", MAIN)
+        self.assertIn("self.metacog_enabled = True", MAIN)
+
+
+class ProspectiveWiringTest(unittest.TestCase):
+    def test_due_check_and_pending_prompts(self):
+        self.assertIn("from .biocore_model import prospective as _pm_mod", MAIN)
+        self.assertIn("_pm_mod.mark_overdue(", MAIN)
+        self.assertIn("_pm_mod.due_now(", MAIN)
+        self.assertIn("_pm_mod.build_hint(", MAIN)
+        self.assertIn("core.pending_prompts = _pm_hints", MAIN)
+        self.assertIn('if bool(getattr(self, "prospective_enabled", True)):', MAIN)
+
+    def test_prospective_hint_feeds_expression_layer(self):
+        self.assertIn("self._prospective_hint = _pm_hints[0]", MAIN)
+        self.assertIn("self._prospective_hint", MAIN)
+        self.assertNotIn("await event.send", MAIN.split("prospective as _pm_mod")[1][:4000])
+
+    def test_prospective_store_path(self):
+        self.assertIn('self._self_layer_data_file("prospective.json")', MAIN)
+        self.assertIn('base = DATA_DIR / "biocore"', MAIN)
+
+
+class VoiceBankWiringTest(unittest.TestCase):
+    def test_pick_and_phrases(self):
+        self.assertIn("from .biocore_model import voice_bank as _vb_mod", MAIN)
+        self.assertIn("_vb_mod.pick(", MAIN)
+        self.assertIn("core.voice_phrases = _vb_phrases", MAIN)
+        self.assertIn('if bool(getattr(self, "voice_bank_enabled", True)):', MAIN)
+
+    def test_voice_data_file_and_usage(self):
+        self.assertIn('self._self_layer_data_file("voice_bank.json")', MAIN)
+        self.assertIn('self._self_layer_data_file(\n                                "voice_bank_used.json")', MAIN)
+        self.assertIn("_vb_mod.mark_used(", MAIN)
+
+    def test_voice_hint_bounded(self):
+        self.assertIn('"口头习惯：" + "；".join(_vb_phrases)', MAIN)
+        self.assertIn("self._voice_hint", MAIN)
+
+
+class MetacogWiringTest(unittest.TestCase):
+    def test_evaluate_and_history(self):
+        self.assertIn("from .biocore_model import metacog as _mc_mod", MAIN)
+        self.assertIn("_mc_mod.evaluate(", MAIN)
+        self.assertIn("_mc_mod.directives(", MAIN)
+        self.assertIn("_mc_mod.remember(", MAIN)
+        self.assertIn('if _sl_meta_on:', MAIN)
+
+    def test_directives_drive_length(self):
+        self.assertIn("core.self_length_scale = max(0.5, min(1.5, _sl_scale))", MAIN)
+        self.assertIn("_sl_scale = min(_sl_scale, max(0.0, _mc_scale))", MAIN)
+        self.assertIn("self._metacog_hint = _mc_tone", MAIN)
+        self.assertIn('self._self_layer_data_file("metacog.json")', MAIN)
+
+    def test_expression_layers_read_metacog_flag(self):
+        self.assertIn('getattr(core, "metacog_enabled", False)', MAIN)
+
+
+class HintCombineTest(unittest.TestCase):
+    def test_hints_combined_once(self):
+        self.assertIn("for _sl_hint in (getattr(self, \"_prospective_hint\", \"\"),", MAIN)
+        self.assertIn("interpretation.combine_strategy_hint(", MAIN)
+        self.assertIn("self._last_strategy_hint = str(_strategy_hint)[:140]", MAIN)
+
+
+class PanelProjectionTest(unittest.TestCase):
+    def test_payload_uses_module_projection(self):
+        self.assertIn("_si_view.payload(", MAIN)
+        self.assertIn('_self_intent_status_payload', MAIN)
+        self.assertIn('"self_intent": (self._self_intent_status_payload()', MAIN)
+        self.assertIn('"self_intent": (self._self_intent_status_payload()', ROUTES)
+
+    def test_payload_projection_bounds(self):
+        result = si.evaluate(snapshot={"stress": 0.2}, relationship={},
+                             needs={"belonging": 0.2})
+        out = si.payload(result, pending_prompts=["p" * 100],
+                         voice_phrases=["v" * 40],
+                         metacog={"band": "low" * 5, "confidence": 0.3})
+        self.assertLessEqual(len(out["pending_prompts"][0]), 60)
+        self.assertLessEqual(len(out["voice_phrases"][0]), 20)
+        self.assertTrue(out["metacog"]["band"].startswith("low"))
+        self.assertLessEqual(out["top_weight"], 1.0)
+        self.assertGreaterEqual(out["top_weight"], 0.0)
+
+    def test_dashboard_row_next_to_memory_meta(self):
+        self.assertIn('id="selfIntentNote"', SRC_HTML)
+        self.assertIn('id="selfIntentNote"', INDEX_HTML)
+        self.assertIn('siEl=$("selfIntentNote")', APP_JS)
+        self.assertIn("她的意图：", SRC_HTML)
+        # the row sits right after the memory-meta strategy line
+        self.assertLess(SRC_HTML.index("memHintNote"),
+                        SRC_HTML.index("selfIntentNote"))
+
+
+class RollbackTest(unittest.TestCase):
+    def test_disabled_switch_clears_projection(self):
+        self.assertIn('core.pending_prompts = []', MAIN)
+        self.assertIn('core.voice_phrases = []', MAIN)
+        self.assertIn('if not _sl_self_on and not _sl_meta_on:', MAIN)
+
+    def test_one_turn_computation(self):
+        # a single occurrence in the turn path (prospective block marker)
+        self.assertEqual(MAIN.count('self._self_layer_data_file("prospective.json")'), 1)
+        self.assertEqual(MAIN.count('_pm_mod.due_now('), 1)
+        self.assertEqual(MAIN.count('_vb_mod.pick('), 1)
+        self.assertEqual(MAIN.count('_mc_mod.evaluate('), 1)
+
+
+class PanelMethodTest(unittest.TestCase):
+    """Exec the real projection method from main.py against a fake plugin."""
+
+    @staticmethod
+    def _method():
+        import ast
+        import types
+        tree = ast.parse(MAIN)
+        nodes = [node for node in ast.walk(tree)
+                 if isinstance(node, ast.FunctionDef)
+                 and node.name == "_self_intent_status_payload"]
+        assert len(nodes) == 1, "expected exactly one projection method"
+        module = ast.Module(body=nodes, type_ignores=[])
+        ns = {}
+        exec(compile(module, "<panel_projection>", "exec"), ns)
+        return ns["_self_intent_status_payload"]
+
+    def test_projection_reads_core_state(self):
+        import types
+        method = self._method()
+        result = si.evaluate(
+            snapshot={"stress": 0.2, "energy": 0.7},
+            relationship={"closeness": 0.9, "trust": 0.9},
+            needs={"belonging": 0.2, "self_esteem": 0.6,
+                   "control": 0.6, "meaningful_existence": 0.6},
+            silence_seconds=12 * 3600)
+        core = types.SimpleNamespace(
+            self_intent=result,
+            pending_prompts=["你答应过要问一句：体检结果"],
+            voice_phrases=["少来。"],
+            metacog={"band": "low", "confidence": 0.3, "converge": False,
+                     "allow_self_correction": False, "low_streak": 1})
+        plugin = types.SimpleNamespace(cores={"k": core},
+                                       self_intent_enabled=True)
+        out = method(plugin)
+        self.assertEqual(out["top"], result["top"])
+        self.assertEqual(out["top_weight"], result["intents"][0]["weight"])
+        self.assertEqual(out["pending_prompts"][0][:4], "你答应过")
+        self.assertEqual(out["voice_phrases"], ["少来。"])
+        self.assertEqual(out["metacog"]["band"], "low")
+
+    def test_projection_defaults_without_core(self):
+        method = self._method()
+        import types
+        plugin = types.SimpleNamespace(cores={}, self_intent_enabled=True)
+        out = method(plugin)
+        self.assertEqual(out["top"], "顺着你")
+        self.assertEqual(out["intents"], [])
+        self.assertGreaterEqual(out["self_weight"], si.SELF_WEIGHT_FLOOR)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_self_verification.py

@@ -0,0 +1,113 @@
+# -*- coding: utf-8 -*-
+import unittest
+
+from biocore_model import self_verification as sv
+
+NOW = 1_700_000_000
+
+
+class SelfVerificationUrgeTest(unittest.TestCase):
+    def test_accurate_description_has_no_urge(self):
+        self.assertEqual(sv.correction_urge(False, 0.9, 0.9, 0.9), 0.0)
+
+    def test_misunderstood_is_higher_than_accurate(self):
+        pair = sv.compare(clarity=0.7, relation=0.7, severity=0.7)
+        self.assertGreater(pair["misunderstood"], pair["accurate"])
+        self.assertGreater(pair["delta"], 0.10)
+
+    def test_higher_clarity_raises_urge(self):
+        low = sv.correction_urge(True, clarity=0.1, relation=0.6)
+        high = sv.correction_urge(True, clarity=0.9, relation=0.6)
+        self.assertGreater(high, low)
+
+    def test_higher_relation_raises_urge(self):
+        low = sv.correction_urge(True, clarity=0.6, relation=0.1)
+        high = sv.correction_urge(True, clarity=0.6, relation=0.9)
+        self.assertGreater(high, low)
+
+    def test_urge_stays_in_unit_interval(self):
+        low = sv.correction_urge(True, clarity=-5, relation=-5, severity=-5)
+        high = sv.correction_urge(True, clarity=5, relation=5, severity=5)
+        self.assertGreaterEqual(low, 0.0)
+        self.assertLessEqual(high, 1.0)
+
+    def test_clarity_factor_floor_and_ceiling(self):
+        self.assertAlmostEqual(sv.clarity_factor(0.0), sv.CLARITY_FLOOR)
+        self.assertAlmostEqual(sv.clarity_factor(1.0), 1.0)
+
+    def test_relation_factor_floor_and_ceiling(self):
+        self.assertAlmostEqual(sv.relation_factor(0.0), sv.RELATION_FLOOR)
+        self.assertAlmostEqual(sv.relation_factor(1.0), 1.0)
+
+
+class SelfVerificationMisreadTest(unittest.TestCase):
+    def test_identical_self_image_is_zero_gap(self):
+        image = {"warmth": 0.8, "honesty": 0.9}
+        self.assertEqual(sv.misread_level(image, dict(image)), 0.0)
+
+    def test_different_self_image_opens_gap(self):
+        level = sv.misread_level({"warmth": 0.8, "honesty": 0.9},
+                                 {"warmth": 0.2, "honesty": 0.9})
+        self.assertAlmostEqual(level, 0.3)
+
+    def test_missing_traits_are_not_total_misread(self):
+        level = sv.misread_level({"warmth": 0.8, "honesty": 0.9},
+                                 {"warmth": 0.2})
+        self.assertAlmostEqual(level, 0.6)
+
+    def test_bad_inputs_do_not_crash(self):
+        self.assertEqual(sv.misread_level(None, None), 0.0)
+        self.assertEqual(sv.misread_level({"warmth": 0.5}, "nope"), 0.0)
+        self.assertEqual(sv.correction_urge(None, None, None, None), 0.0)
+
+
+class SelfVerificationStateTest(unittest.TestCase):
+    def test_initial_defaults(self):
+        state = sv.initial(NOW)
+        self.assertEqual(state["urge"], 0.0)
+        self.assertEqual(state["misread_count"], 0)
+
+    def test_observe_counts_misreads(self):
+        state = sv.observe(sv.initial(NOW - 10), True,
+                           clarity=0.7, relation=0.7, now=NOW)
+        self.assertEqual(state["misread_count"], 1)
+        self.assertEqual(state["last_event"], "misunderstood")
+        self.assertGreater(state["urge"], 0.0)
+
+    def test_observe_accurate_does_not_count(self):
+        state = sv.observe(sv.initial(NOW - 10), False,
+                           clarity=0.7, relation=0.7, now=NOW)
+        self.assertEqual(state["misread_count"], 0)
+        self.assertEqual(state["urge"], 0.0)
+        self.assertEqual(state["last_event"], "seen_accurately")
+
+    def test_same_turn_is_idempotent(self):
+        once = sv.observe(sv.initial(NOW - 10), True, now=NOW)
+        twice = sv.observe(once, True, now=NOW)
+        self.assertEqual(twice["urge"], once["urge"])
+        self.assertEqual(twice["misread_count"], once["misread_count"])
+
+    def test_decay_fades_urge(self):
+        state = sv.observe(sv.initial(NOW - 10), True,
+                           clarity=0.9, relation=0.9, severity=1.0, now=NOW)
+        faded = sv.decay(state, NOW + int(sv.DECAY_HALF_LIFE_HOURS * 3600))
+        self.assertLess(faded["urge"], state["urge"])
+
+    def test_intent_threshold_switches(self):
+        state = dict(sv.initial(NOW), urge=0.10)
+        self.assertFalse(sv.intent(state)["want_correct"])
+        self.assertEqual(sv.intent(state)["strength"], "none")
+        state = dict(sv.initial(NOW), urge=0.80)
+        self.assertTrue(sv.intent(state)["want_correct"])
+        self.assertEqual(sv.intent(state)["strength"], "strong")
+
+    def test_view_fields(self):
+        state = sv.observe(sv.initial(NOW - 10), True, now=NOW)
+        panel = sv.view(state)
+        for key in ("urge", "want_correct", "strength", "peak",
+                    "misread_count", "last_event"):
+            self.assertIn(key, panel)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_situation.py

@@ -0,0 +1,142 @@
+# -*- coding: utf-8 -*-
+import unittest
+
+from biocore_model import situation
+
+NOW = 1_700_000_000
+
+
+def _history(*rows):
+    return [{"role": role, "content": text, "ts": ts} for role, text, ts in rows]
+
+
+class SituationTest(unittest.TestCase):
+    def test_challenge_from_probe_number(self):
+        out = situation.summarize(
+            history=_history(("user", "这句话什么意思？", NOW - 60)),
+            core_state={"v": -0.5, "stress": 0.7,
+                        "labels": {"emotion": "anger"}},
+            relationship={"state": {"trust": 0.5, "conflict": 0.2,
+                                    "closeness": 0.5}},
+            situation={"challenge": 0.8},
+            now=NOW)
+        self.assertTrue(out.startswith("局面："))
+        self.assertIn("质问你", out)
+        self.assertIn("语气不满", out)
+        self.assertIn("关系：", out)
+        self.assertLessEqual(len(out.splitlines()), 3)
+
+    def test_praise_from_probe_number(self):
+        out = situation.summarize(
+            history=[{"role": "user", "content": "今天多亏你了"}],
+            relationship={"state": {"closeness": 0.72, "trust": 0.7,
+                                    "conflict": 0.05}},
+            situation={"praise": 0.75},
+            now=NOW)
+        self.assertIn("夸你", out)
+        self.assertIn("亲近", out)
+        self.assertIn("信任高", out)
+
+    def test_hurt_from_probe_number(self):
+        out = situation.summarize(
+            history=[{"role": "user", "content": "随便你"}],
+            situation={"hurt": 0.7},
+            now=NOW)
+        self.assertIn("火气", out)
+
+    def test_weak_signals_keep_neutral_line(self):
+        out = situation.summarize(
+            history=[{"role": "user", "content": "今天天气不错"}],
+            situation={"challenge": 0.2, "praise": 0.3, "hurt": 0.1},
+            now=NOW)
+        self.assertIn("日常闲聊", out)
+
+    def test_no_word_scanning_without_probe(self):
+        # the old keyword tables are gone: text alone never picks a scene
+        out = situation.summarize(
+            history=[{"role": "user", "content": "你凭什么骗我？"}] +
+                    [{"role": "user", "content": "你真厉害，谢谢你"}],
+            now=NOW)
+        self.assertIn("日常闲聊", out)
+        self.assertNotIn("质问你", out)
+        self.assertNotIn("夸你", out)
+
+    def test_unanswered_proactive_messages(self):
+        out = situation.summarize(
+            history=_history(
+                ("user", "在吗", NOW - 120),
+                ("assistant", "在的", NOW - 100),
+                ("assistant", "看到回我一下", NOW - 80),
+                ("assistant", "我先睡了", NOW - 60)),
+            now=NOW)
+        self.assertIn("主动发了 3 条", out)
+        self.assertIn("还没回", out)
+
+    def test_long_silence(self):
+        out = situation.summarize(
+            history=_history(("user", "晚安", NOW - 8 * 3600)), now=NOW)
+        self.assertIn("8 小时", out)
+        self.assertIn("没说话", out)
+
+    def test_silence_not_triggered_recently(self):
+        out = situation.summarize(
+            history=_history(("user", "刚到家", NOW - 300)), now=NOW)
+        self.assertNotIn("没说话", out)
+        self.assertIn("最近话题", out)
+
+    def test_relationship_tension(self):
+        out = situation.summarize(
+            history=[{"role": "user", "content": "嗯"}],
+            relationship={"state": {"conflict": 0.6, "trust": 0.3,
+                                    "closeness": 0.6}},
+            now=NOW)
+        self.assertIn("紧张", out)
+        self.assertIn("信任偏低", out)
+
+    def test_three_line_budget_and_no_overflow(self):
+        out = situation.summarize(
+            history=_history(("user", "你为什么骗我？", NOW - 9 * 3600)),
+            core_state={"v": -0.6, "stress": 0.9,
+                        "labels": {"emotion": "anger"}},
+            relationship={"state": {"conflict": 0.7, "trust": 0.2,
+                                    "closeness": 0.8}},
+            situation={"challenge": 0.9, "hurt": 0.6},
+            now=NOW)
+        lines = out.splitlines()
+        self.assertLessEqual(len(lines), 3)
+        self.assertGreaterEqual(len(lines), 2)
+        self.assertLessEqual(len(out), situation.MAX_CHARS)
+        self.assertTrue(all(line.strip() for line in lines))
+
+    def test_empty_inputs(self):
+        self.assertEqual(situation.summarize(), "")
+        self.assertEqual(situation.summarize(None, None, None, None, None, None),
+                         "")
+
+    def test_tolerant_history_shapes(self):
+        out = situation.summarize(
+            history=["在吗", ("user", "早"), {"text": "吃了吗"}], now=NOW)
+        self.assertIn("局面：", out)
+
+    def test_events_clock_fallback(self):
+        out = situation.summarize(
+            history=[],
+            events=[{"ts": NOW - 10 * 3600, "event": "上次聊天"}],
+            now=NOW)
+        self.assertIn("10 小时", out)
+        self.assertIn("没说话", out)
+
+    def test_malformed_situation_values_are_safe(self):
+        out = situation.summarize(
+            history=[{"role": "user", "content": "在吗"}],
+            situation={"challenge": "高", "praise": None, "hurt": 2.0},
+            now=NOW)
+        self.assertIn("局面：", out)
+        self.assertIn("火气", out)  # hurt clamped to 1.0
+        values = situation.situation_values({"challenge": -1, "praise": 3})
+        self.assertEqual(values["challenge"], 0.0)
+        self.assertEqual(values["praise"], 1.0)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_sleep_circadian.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import sleep_circadian as sc
+
+NOW_04 = 1_700_000_000 - ((1_700_000_000 / 3600 + 8) % 24 - 4) * 3600
+
+class SleepTest(unittest.TestCase):
+    def test_circadian_trough(self):
+        self.assertLess(sc.circadian(4), 0.1)
+    def test_circadian_peak(self):
+        self.assertGreater(sc.circadian(10), 0.9)
+    def test_circadian_range(self):
+        for hour in range(24):
+            self.assertGreaterEqual(sc.circadian(hour), 0.0); self.assertLessEqual(sc.circadian(hour), 1.0)
+    def test_sleep_window_inside(self):
+        self.assertTrue(sc.in_sleep_window(1.0))
+    def test_sleep_window_wake(self):
+        self.assertFalse(sc.in_sleep_window(8.0))
+    def test_sleep_window_boundaries(self):
+        self.assertTrue(sc.in_sleep_window(0.5)); self.assertFalse(sc.in_sleep_window(7.6))
+    def test_sleep_state_fields(self):
+        state = sc.sleep_state(1_700_000_000)
+        for key in ('sleeping', 'circadian', 'sleep_quality', 'asleep_since', 'wake_ts'):
+            self.assertIn(key, state)
+    def test_quality_from_duration(self):
+        self.assertAlmostEqual(sc.quality_from_durations(3.5), 0.5)
+    def test_short_sleep_lowers_energy(self):
+        self.assertLess(sc.next_day_energy(0.5), sc.next_day_energy(1.0))
+    def test_energy_effects(self):
+        low = sc.energy_effects(0.2)
+        self.assertLess(low['drive_mult'], 1.0); self.assertLess(low['max_chars_mult'], 1.0); self.assertGreater(low['stress_delta'], 0)
+    def test_energy_idempotent_same_now(self):
+        energy, ts = sc.settled_energy(1.0, 0.5, 8, 1_700_000_000, last_applied_ts=1_700_000_000)
+        self.assertEqual(ts, 1_700_000_000)
+        self.assertEqual(energy, 1.0)  # same now => no re-application
+    def test_energy_wakes_apply(self):
+        energy, ts = sc.settled_energy(1.0, 1.0, 8, 1_700_000_000, last_applied_ts=0)
+        self.assertEqual(ts, 1_700_000_000); self.assertAlmostEqual(energy, 1.0)
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_social_pain.py

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import social_pain as sp
+
+NOW = 1_700_000_000
+
+class SocialPainTest(unittest.TestCase):
+    def test_initial_zero(self):
+        self.assertEqual(sp.initial(NOW)['value'], 0.0)
+    def test_ignored_adds(self):
+        self.assertAlmostEqual(sp.update(sp.initial(NOW - 10), 'ignored', NOW)['value'], 0.05)
+    def test_rejected_adds(self):
+        self.assertAlmostEqual(sp.update(sp.initial(NOW - 10), 'rejected', NOW)['value'], 0.10)
+    def test_excluded_adds(self):
+        self.assertAlmostEqual(sp.update(sp.initial(NOW - 10), 'excluded', NOW)['value'], 0.15)
+    def test_replied_lowers(self):
+        state = dict(sp.initial(NOW - 10), value=0.5, last_value=0.5)
+        self.assertAlmostEqual(sp.update(state, 'replied', NOW)['value'], 0.4)
+    def test_comforted_lowers(self):
+        state = dict(sp.initial(NOW - 10), value=0.5, last_value=0.5)
+        self.assertAlmostEqual(sp.update(state, 'comforted', NOW)['value'], 0.35)
+    def test_decay_per_hour(self):
+        state = dict(sp.initial(NOW - 3600 * 2), value=0.3, last_value=0.3)
+        self.assertAlmostEqual(sp.decay(state, NOW)['value'], 0.26)
+    def test_decay_same_now_idempotent(self):
+        state = dict(sp.initial(NOW - 10), value=0.3, last_decay_ts=NOW)
+        self.assertEqual(sp.decay(state, NOW)['value'], 0.3)
+    def test_update_same_now_no_double(self):
+        first = sp.update(sp.initial(NOW - 10), 'rejected', NOW)
+        second = sp.update(first, 'rejected', NOW)
+        self.assertEqual(second['value'], first['value'])
+    def test_clamp_upper(self):
+        state = dict(sp.initial(NOW - 10), value=0.95)
+        self.assertLessEqual(sp.update(state, 'excluded', NOW)['value'], 1.0)
+    def test_clamp_lower(self):
+        state = dict(sp.initial(NOW - 10), value=0.02)
+        self.assertGreaterEqual(sp.update(state, 'comforted', NOW)['value'], 0.0)
+    def test_independent_from_stress(self):
+        state = sp.update(sp.initial(NOW - 10), 'rejected', NOW)
+        self.assertNotIn('stress', state); self.assertNotIn('allostatic_load', state)
+    def test_drive_and_gate(self):
+        self.assertAlmostEqual(sp.drive_delta(0.4), 0.2)
+        self.assertAlmostEqual(sp.gate_cost(0.4), 0.02)
+    def test_view_fields(self):
+        view = sp.view(sp.update(sp.initial(NOW - 10), 'ignored', NOW))
+        for key in ('value', 'last_event', 'trend'): self.assertIn(key, view)
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_social_repair.py

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import social_repair as sr
+
+class GratitudeTest(unittest.TestCase):
+    def test_kindness_raises(self):
+        self.assertAlmostEqual(sr.gratitude_event(0.0, True), 0.15)
+    def test_message_references_event(self):
+        events = [{'owner': 'user', 'valence': 0.5, 'text': '帮我拿快递'}]
+        msg = sr.gratitude_message(events, 0.8)
+        self.assertIn('帮我拿快递', msg); self.assertIn('谢了', msg)
+    def test_no_event_falls_back(self):
+        self.assertEqual(sr.gratitude_message([{'owner': 'self', 'text': 'x'}], 0.8), '')
+    def test_low_gratitude_no_message(self):
+        self.assertEqual(sr.gratitude_message([{'owner': 'user', 'valence': 1, 'text': 'x'}], 0.2), '')
+
+class BoundaryTest(unittest.TestCase):
+    def test_depth_by_stage(self):
+        self.assertLess(sr.boundaries('stranger')['disclosure_depth'], sr.boundaries('close')['disclosure_depth'])
+    def test_blocked_reply(self):
+        self.assertEqual(sr.boundary_reply('ex', ['ex']), '这个先不说。')
+    def test_normal_topic(self):
+        self.assertEqual(sr.boundary_reply('天气', ['ex']), '')
+
+class EmpathyTest(unittest.TestCase):
+    def test_affective_shift(self):
+        self.assertAlmostEqual(sr.empathy(1.0, cognitive_accuracy=0.0)['valence_shift'], 0.3)
+    def test_four_modes(self):
+        self.assertEqual(sr.empathy(1.0, cognitive_accuracy=1.0)['mode'], 'comfort')
+        self.assertEqual(sr.empathy(0.0, cognitive_accuracy=1.0)['mode'], 'reason')
+        self.assertEqual(sr.empathy(1.0, cognitive_accuracy=0.0)['mode'], 'resonance')
+        self.assertEqual(sr.empathy(0.0, cognitive_accuracy=0.0)['mode'], 'cold')
+
+class RepairTest(unittest.TestCase):
+    def test_trigger(self):
+        self.assertTrue(sr.repair_check('你说什么？', '这是一句比较长的上一条回复内容')['needed'])
+    def test_no_trigger_short(self):
+        self.assertFalse(sr.repair_check('嗯', '长回复长回复长回复长回复')['needed'])
+    def test_failure_degrades(self):
+        out = sr.repair_check('没懂？', '这是一句比较长的上一条回复内容', clarify_failures=2)
+        self.assertIn('简单点说', out['text'])
+
+class TimeTest(unittest.TestCase):
+    def test_gap_bands(self):
+        self.assertEqual(sr.time_gap_text(0.5), '刚刚'); self.assertEqual(sr.time_gap_text(3), '几小时前')
+        self.assertEqual(sr.time_gap_text(48), '两天多'); self.assertEqual(sr.time_gap_text(200), '一周前')
+    def test_future(self):
+        self.assertEqual(sr.future_text(3), '还有 3 天'); self.assertEqual(sr.future_text(0), '已经过了')
+    def test_memory_label(self):
+        self.assertIn('你说过', sr.memory_time_label(3))
+
+    def test_trust_raises_depth(self):
+        self.assertGreater(sr.boundaries('stranger', trust=0.9)['disclosure_depth'], sr.boundaries('stranger', trust=0.1)['disclosure_depth'])
+
+    def test_empathy_fields(self):
+        info = sr.empathy(0.5, cognitive_accuracy=0.6)
+        for key in ('affective', 'cognitive', 'mode', 'valence_shift'):
+            self.assertIn(key, info)
+
+    def test_view_fields(self):
+        view = sr.view(0.4, sr.boundaries('friend'), sr.empathy(0.5), sr.repair_check('嗯'), {'gap': '刚刚'})
+        for key in ('gratitude', 'boundaries', 'empathy', 'repair', 'time_sense'):
+            self.assertIn(key, view)
+
+
+if __name__ == '__main__':
+    unittest.main()