dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_user_classify.py

@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+"""User-message classification + empathy/insult wiring tests."""
+import ast
+import types
+import unittest
+from pathlib import Path
+
+from biocore_model import feedback_user as fu
+import interpretation
+
+MAIN = Path(__file__).resolve().parents[2] / "main.py"
+SOURCE = MAIN.read_text(encoding="utf-8")
+NOW = 1_700_000_000.0
+
+
+def _load_insult_helper():
+    tree = ast.parse(SOURCE)
+    cls = next(n for n in tree.body
+               if isinstance(n, ast.ClassDef) and n.name == "BioCorePlugin")
+    node = next(f for f in cls.body
+                if isinstance(f, ast.FunctionDef) and f.name == "_autonomy_insult_blocked")
+    ns = {}
+    exec(compile(ast.Module(body=[node], type_ignores=[]), "<insult>", "exec"), ns)
+    return ns[node.name]
+
+
+INSULT_BLOCKED = _load_insult_helper()
+
+
+class ClassifyTest(unittest.TestCase):
+    def test_flag_is_off_by_default(self):
+        self.assertIs(interpretation.USER_CLASSIFY_ENABLED, False)
+
+    def test_no_word_table_remains(self):
+        self.assertFalse(hasattr(interpretation, "_USER_WORDS"))
+
+    def test_insult_text_is_neutral(self):
+        out = interpretation.classify_user_msg("你真废物，闭嘴")
+        self.assertEqual(out["kind"], "neutral")
+        self.assertLess(out["confidence"], 0.4)
+
+    def test_reject_text_is_neutral(self):
+        self.assertEqual(
+            interpretation.classify_user_msg("不用了，别说了")["kind"],
+            "neutral")
+
+    def test_sad_text_is_neutral(self):
+        self.assertEqual(
+            interpretation.classify_user_msg("我今天特别难受，想哭")["kind"],
+            "neutral")
+
+    def test_praise_text_is_neutral(self):
+        self.assertEqual(
+            interpretation.classify_user_msg("你好厉害，谢谢")["kind"],
+            "neutral")
+
+    def test_affectionate_text_is_neutral(self):
+        self.assertEqual(
+            interpretation.classify_user_msg("想你了，抱抱")["kind"], "neutral")
+
+    def test_empty_is_neutral(self):
+        self.assertEqual(interpretation.classify_user_msg("")["kind"],
+                         "neutral")
+
+    def test_bounds(self):
+        out = interpretation.classify_user_msg("谢谢你，你真好，太厉害了")
+        self.assertGreaterEqual(out["intensity"], 0.0)
+        self.assertLessEqual(out["intensity"], 1.0)
+        self.assertGreaterEqual(out["confidence"], 0.0)
+        self.assertLessEqual(out["confidence"], 1.0)
+
+    def test_all_kinds_share_neutral_shape(self):
+        for text in ("我很难受，你真废物", "嗯", "晚安"):
+            out = interpretation.classify_user_msg(text)
+            self.assertEqual(out["kind"], "neutral", text)
+
+class FeedbackEventTest(unittest.TestCase):
+    def test_sad_empathy_raises_stress(self):
+        out = fu.on_message({"stress": 0.1}, {"kind": "sad_empathy",
+                                              "id": "m1", "ts": NOW}, NOW)
+        self.assertGreater(out["deltas"]["stress"], 0.0)
+        self.assertGreater(out["deltas"]["social_pain"], 0.0)
+
+    def test_affection_raises_social_lowers_stress(self):
+        out = fu.on_message({"social": 0.5, "stress": 0.2},
+                            {"kind": "affection", "id": "m2", "ts": NOW}, NOW)
+        self.assertGreater(out["deltas"]["social"], 0.0)
+        self.assertLess(out["deltas"]["stress"], 0.0)
+
+    def test_classifier_kinds_are_accepted(self):
+        for kind in ("neutral", "sad", "affectionate", "insult", "reject", "praise"):
+            out = fu.on_message({}, {"kind": kind, "id": kind, "ts": NOW}, NOW)
+            self.assertEqual(out["rejected"], [], kind)
+
+
+class InsultGateTest(unittest.TestCase):
+    def test_blocked_within_30_minutes(self):
+        plugin = types.SimpleNamespace(_last_insult_ts=NOW - 100)
+        self.assertTrue(INSULT_BLOCKED(plugin, NOW))
+
+    def test_not_blocked_after_30_minutes(self):
+        plugin = types.SimpleNamespace(_last_insult_ts=NOW - 2000)
+        self.assertFalse(INSULT_BLOCKED(plugin, NOW))
+
+    def test_no_insult_not_blocked(self):
+        self.assertFalse(INSULT_BLOCKED(types.SimpleNamespace(), NOW))
+
+
+class WiringStaticTest(unittest.TestCase):
+    def test_main_keeps_helpers_behind_default_off_switch(self):
+        self.assertIn("classify_user_msg(text)", SOURCE)
+        self.assertIn('getattr(self, "lexical_fallback_enabled", False)',
+                      SOURCE)
+        self.assertIn('self.config.get("lexical_fallback_enabled", False)',
+                      SOURCE)
+        self.assertIn('"sad_empathy"', SOURCE)
+        self.assertIn('"affection"', SOURCE)
+        self.assertIn("insult_cooldown", SOURCE)
+        self.assertIn("[biocore] user kind=%s conf=%.2f deltas=%s", SOURCE)
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_value_order.py

@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+"""Value ordering: ten dimensions, loss aversion, sunk cost, status quo."""
+import unittest
+
+from biocore_model import value_order as vo
+
+class DefaultsTest(unittest.TestCase):
+    def test_ten_dimensions(self):
+        table = vo.defaults()
+        self.assertEqual(len(table), 10)
+        self.assertEqual(set(table), set(vo.DIMENSIONS))
+
+    def test_normalize_fills_and_clamps(self):
+        table = vo.normalize({"security": 9, "benevolence": -3})
+        self.assertEqual(table["security"], vo.WEIGHT_CEIL)
+        self.assertEqual(table["benevolence"], vo.WEIGHT_FLOOR)
+        self.assertNotIn("honesty", table)
+        self.assertIn("universalism", table)
+
+class UpdateTest(unittest.TestCase):
+    def test_update_moves_slowly(self):
+        before = vo.defaults()
+        after = vo.update(before, {"benevolence": 0.15})
+        self.assertLess(after["benevolence"] - before["benevolence"], 0.02)
+        self.assertGreater(after["benevolence"], before["benevolence"])
+
+    def test_update_bounded(self):
+        table = vo.defaults()
+        for _ in range(200):
+            table = vo.update(table, {"power": 5.0})
+        self.assertLessEqual(table["power"], vo.WEIGHT_CEIL)
+        self.assertGreaterEqual(table["power"], vo.WEIGHT_FLOOR)
+
+    def test_unknown_dimension_ignored(self):
+        table = vo.update(vo.defaults(), {"flying": 1.0})
+        self.assertEqual(set(table), set(vo.DIMENSIONS))
+
+class LossAversionTest(unittest.TestCase):
+    def test_loss_counts_double(self):
+        table = vo.defaults()
+        gain = vo.rank([{"name": "gain", "gains": {"benevolence": 0.5}}],
+                       table)["ranked"][0]["score"]
+        loss = vo.rank([{"name": "loss", "losses": {"benevolence": 0.5}}],
+                       table)["ranked"][0]["score"]
+        self.assertAlmostEqual(loss, -vo.LOSS_MULTIPLIER * gain, places=4)
+
+class SunkCostTest(unittest.TestCase):
+    def test_grows_with_age(self):
+        young = vo.sunk_cost(10)
+        old = vo.sunk_cost(730)
+        self.assertGreater(old, young)
+        self.assertLessEqual(old, vo.SUNK_COST_CAP)
+
+    def test_capped(self):
+        self.assertEqual(vo.sunk_cost(100000), vo.SUNK_COST_CAP)
+
+class StatusQuoTest(unittest.TestCase):
+    def test_threshold_in_range(self):
+        value = vo.status_quo_threshold(vo.defaults(), 365)
+        self.assertGreaterEqual(value, 0.05)
+        self.assertLessEqual(value, vo.STATUS_QUO_CAP)
+
+    def test_small_gain_keeps_status_quo(self):
+        options = [
+            {"name": "保持现状", "keeps_status_quo": True},
+            {"name": "小改变", "gains": {"stimulation": 0.02}},
+        ]
+        out = vo.rank(options, vo.defaults(), {"investment": 0.8,
+                                               "relationship_age_days": 365})
+        self.assertEqual(out["chosen"], "保持现状")
+
+    def test_big_gain_wins(self):
+        options = [
+            {"name": "保持现状", "keeps_status_quo": True},
+            {"name": "大改变", "gains": {"security": 1.0, "benevolence": 1.0}},
+        ]
+        out = vo.rank(options, vo.defaults(), {"investment": 0.2,
+                                               "relationship_age_days": 30})
+        self.assertEqual(out["chosen"], "大改变")
+
+class NecessityTest(unittest.TestCase):
+    def test_priority_order(self):
+        rows = vo.necessity_priority(vo.defaults())
+        self.assertEqual(len(rows), 4)
+        self.assertEqual(rows[0]["need"], "被需要")
+        self.assertGreaterEqual(rows[0]["value"], rows[-1]["value"])
+
+    def test_custom_table_reorders(self):
+        table = vo.defaults()
+        table["security"] = 1.0
+        table["benevolence"] = 0.2
+        rows = vo.necessity_priority(table)
+        self.assertEqual(rows[0]["need"], "安全感")
+
+class FallbackTest(unittest.TestCase):
+    def test_disabled_keeps_ranking(self):
+        out = vo.rank([{"name": "a", "gains": {"security": 0.3}}],
+                      vo.defaults(), {}, flags={"enabled": False})
+        self.assertFalse(out["enabled"])
+        self.assertEqual(out["chosen"], "a")
+
+    def test_empty_options(self):
+        out = vo.rank([], vo.defaults(), {})
+        self.assertIsNone(out["chosen"])
+        self.assertEqual(out["ranked"], [])
+
+    def test_malformed(self):
+        out = vo.rank([None, "x", {"name": "ok"}], "bad", "bad")
+        self.assertEqual(len(out["ranked"]), 3)
+
+class DirectiveTest(unittest.TestCase):
+    def test_directive(self):
+        out = vo.directives({"enabled": True, "chosen": "保持现状"})
+        self.assertEqual(out["chosen"], "保持现状")
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_voice_bank.py

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+"""Voice bank: loading, state matching, cooldown, picking."""
+import random
+import unittest
+
+from biocore_model import voice_bank as vb
+
+NOW = 1790000000.0
+
+BANK = [
+    {"phrase": "少来。", "when": {"v_min": 0.0, "v_max": 1.0, "stages": ["close"]},
+     "weight": 2.0, "cooldown_s": 3600},
+    {"phrase": "有点累。", "when": {"v_min": -1.0, "v_max": 0.0,
+                                "tension_min": 0.5}, "weight": 3.0},
+    {"phrase": "怎么了？", "when": {"v_min": -1.0, "v_max": 0.3},
+     "weight": 1.0, "cooldown_s": 60},
+]
+
+class LoadTest(unittest.TestCase):
+    def test_drops_malformed_and_duplicates(self):
+        rows = vb.load([None, "x", {"phrase": ""}, {"phrase": "嗯"},
+                       {"phrase": "嗯"}, {"phrase": "y" * 80}])
+        self.assertEqual([row["phrase"] for row in rows], ["嗯"])
+
+    def test_normalizes_stage_string_and_range(self):
+        row = vb.load([{"phrase": "好", "when": {"stages": "close",
+                                      "v_min": 0.8, "v_max": 0.2}}])[0]
+        self.assertEqual(row["when"]["stages"], ["close"])
+        self.assertEqual(row["when"]["v_min"], 0.2)
+        self.assertEqual(row["when"]["v_max"], 0.8)
+
+    def test_defaults_filled(self):
+        row = vb.load([{"phrase": "嗯"}])[0]
+        self.assertEqual(row["weight"], 1.0)
+        self.assertEqual(row["cooldown_s"], vb.DEFAULT_COOLDOWN_S)
+        self.assertEqual(len(row["when"]["stages"]), len(vb.STAGES))
+
+class MatchTest(unittest.TestCase):
+    def test_v_range(self):
+        row = vb.load(BANK)[0]
+        self.assertTrue(vb.matches(row, {"v": 0.5}, "close"))
+        self.assertFalse(vb.matches(row, {"v": -0.5}, "close"))
+
+    def test_stage(self):
+        row = vb.load(BANK)[0]
+        self.assertFalse(vb.matches(row, {"v": 0.5}, "stranger"))
+
+    def test_tension_band(self):
+        row = vb.load(BANK)[1]
+        self.assertTrue(vb.matches(row, {"v": -0.2, "tension": 0.7}, "normal"))
+        self.assertFalse(vb.matches(row, {"v": -0.2, "tension": 0.2}, "normal"))
+
+class CooldownTest(unittest.TestCase):
+    def test_cooldown_blocks(self):
+        out = vb.pick({"v": -0.2}, {"stage": "normal"},
+                      {"怎么了？": NOW - 10}, NOW, BANK)
+        self.assertNotIn("怎么了？", out)
+
+    def test_cooldown_expires(self):
+        out = vb.pick({"v": -0.2}, {"stage": "normal"},
+                      {"怎么了？": NOW - 120}, NOW, BANK)
+        self.assertIn("怎么了？", out)
+
+class PickTest(unittest.TestCase):
+    def test_empty_bank(self):
+        self.assertEqual(vb.pick({}, {}, {}, NOW, []), [])
+        self.assertEqual(vb.pick({}, {}, {}, NOW), [])
+
+    def test_at_most_two_and_deterministic(self):
+        out = vb.pick({"v": -0.2, "tension": 0.8}, {"stage": "normal"},
+                      {}, NOW, BANK)
+        self.assertLessEqual(len(out), 2)
+        self.assertEqual(out[0], "有点累。")
+
+    def test_rng_picks_within_candidates(self):
+        rng = random.Random(7)
+        out = vb.pick({"v": -0.2, "tension": 0.8}, {"stage": "normal"},
+                      {}, NOW, BANK, rng=rng)
+        self.assertTrue(set(out).issubset({"有点累。", "怎么了？"}))
+        self.assertEqual(len(out), len(set(out)))
+
+    def test_mark_used_stamps(self):
+        used = vb.mark_used({}, ["嗯"], NOW)
+        self.assertEqual(used["嗯"], NOW)
+        used = vb.mark_used(used, ["啊"], NOW + 5)
+        self.assertEqual(used["啊"], NOW + 5)
+        self.assertEqual(used["嗯"], NOW)
+
+    def test_available_sorted_by_weight(self):
+        rows = vb.available(BANK, {"v": -0.2, "tension": 0.8},
+                             {"stage": "normal"}, {}, NOW)
+        weights = [row["weight"] for row in rows]
+        self.assertEqual(weights, sorted(weights, reverse=True))
+
+class StatsTest(unittest.TestCase):
+    def test_counts(self):
+        out = vb.stats(BANK)
+        self.assertEqual(out["total"], 3)
+        # Entries without an explicit stage list apply to every stage.
+        self.assertEqual(out["by_stage"]["close"], 3)
+        self.assertEqual(out["by_stage"]["normal"], 2)
+        self.assertEqual(out["by_stage"]["stranger"], 2)
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_waiting_sense.py

@@ -0,0 +1,216 @@
+# -*- coding: utf-8 -*-
+"""task-180 等待感单测：对数饱和、夜间放大、亲近放大、四种感受、关闭。
+
+只依赖 biocore_model.waiting_sense 的纯函数；不导入 main.py。
+"""
+import unittest
+
+from biocore_model import waiting_sense as ws
+
+CALM = {"gap_seconds": 300, "hour": 14}
+FOND = {"gap_seconds": 4 * 3600, "relationship": "friend", "hour": 14}
+ANXIOUS = {"gap_seconds": 8 * 3600,
+           "last_emotion": {"label": "sad", "valence": -0.6, "arousal": 0.3},
+           "relationship": "stranger", "hour": 23}
+SULKY = {"gap_seconds": 8 * 3600,
+         "last_emotion": {"label": "anger", "valence": -0.7,
+                          "arousal": 0.85},
+         "relationship": {"stage": "close", "closeness": 0.9}, "hour": 14}
+
+
+class ContractTest(unittest.TestCase):
+    def test_result_keys(self):
+        out = ws.waiting_sense(**FOND)
+        for key in ("enabled", "waiting", "feeling", "thought", "threshold_hit",
+                    "gap_seconds", "gap_hours", "saturation", "closeness",
+                    "night", "factors", "reason"):
+            self.assertIn(key, out)
+
+    def test_feelings_and_thoughts(self):
+        self.assertEqual(set(ws.FEELINGS), {"平静", "惦记", "不安", "赌气"})
+        self.assertEqual(set(ws.THOUGHTS), set(ws.FEELINGS))
+
+    def test_values_bounded(self):
+        for args in (CALM, FOND, ANXIOUS, SULKY):
+            out = ws.waiting_sense(**args)
+            self.assertGreaterEqual(out["waiting"], 0.0)
+            self.assertLessEqual(out["waiting"], 1.0)
+            self.assertGreaterEqual(out["saturation"], 0.0)
+            self.assertLessEqual(out["saturation"], 1.0)
+            self.assertGreaterEqual(out["closeness"], 0.0)
+            self.assertLessEqual(out["closeness"], 1.0)
+
+    def test_flags_and_reason_present(self):
+        for args in (CALM, FOND, ANXIOUS, SULKY):
+            out = ws.waiting_sense(**args)
+            self.assertTrue(out["reason"])
+            self.assertTrue(out["thought"])
+
+
+class FeelingTest(unittest.TestCase):
+    def test_short_gap_is_calm(self):
+        out = ws.waiting_sense(**CALM)
+        self.assertEqual(out["feeling"], "平静")
+        self.assertLess(out["waiting"], 0.22)
+        self.assertFalse(out["threshold_hit"])
+
+    def test_moderate_gap_is_fond(self):
+        self.assertEqual(ws.waiting_sense(**FOND)["feeling"], "惦记")
+
+    def test_long_gap_with_sad_mood_is_anxious(self):
+        out = ws.waiting_sense(**ANXIOUS)
+        self.assertEqual(out["feeling"], "不安")
+        self.assertGreaterEqual(out["waiting"], 0.55)
+        self.assertTrue(out["threshold_hit"])
+
+    def test_long_gap_with_anger_and_closeness_is_sulky(self):
+        out = ws.waiting_sense(**SULKY)
+        self.assertEqual(out["feeling"], "赌气")
+
+    def test_distant_negative_mood_is_not_sulky(self):
+        out = ws.waiting_sense(gap_seconds=8 * 3600, relationship="stranger",
+                               last_emotion={"label": "anger",
+                                             "valence": -0.7,
+                                             "arousal": 0.85})
+        self.assertEqual(out["feeling"], "不安")
+
+    def test_not_waiting_stays_calm(self):
+        out = ws.waiting_sense(gap_seconds=8 * 3600, awaiting_reply=False,
+                               last_emotion={"label": "anger"}, hour=23)
+        self.assertEqual(out["feeling"], "平静")
+        self.assertLess(out["waiting"], 0.22)
+        self.assertFalse(out["threshold_hit"])
+
+    def test_thoughts_are_short_and_distinct(self):
+        scenarios = (CALM, FOND, ANXIOUS, SULKY)
+        thoughts = set()
+        for args in scenarios:
+            out = ws.waiting_sense(**args)
+            self.assertTrue(out["thought"])
+            self.assertLessEqual(len(out["thought"]), 24)
+            thoughts.add(out["thought"])
+        self.assertEqual(len(thoughts), len(scenarios))
+
+
+class SaturationTest(unittest.TestCase):
+    def test_log_saturation_monotone(self):
+        values = [ws.saturation(hours * 3600)
+                  for hours in (1, 2, 3, 4, 8, 24, 72)]
+        self.assertEqual(values, sorted(values))
+        self.assertEqual(ws.saturation(0), 0.0)
+
+    def test_equal_windows_shrink(self):
+        first = ws.saturation(2 * 3600) - ws.saturation(1 * 3600)
+        second = ws.saturation(3 * 3600) - ws.saturation(2 * 3600)
+        self.assertGreater(first, second)
+        self.assertGreater(first, 0.0)
+
+    def test_seven_days_saturates(self):
+        self.assertAlmostEqual(ws.saturation(7 * 24 * 3600), 1.0, places=3)
+        self.assertLessEqual(ws.saturation(30 * 24 * 3600), 1.0)
+
+    def test_waiting_rises_with_gap(self):
+        values = [ws.waiting_sense(gap_seconds=h * 3600)["waiting"]
+                  for h in (1, 2, 4, 8, 24)]
+        self.assertEqual(values, sorted(values))
+
+    def test_waiting_factor_product(self):
+        out = ws.waiting_sense(**FOND)
+        factors = out["factors"]
+        expected = (factors["saturation"] * factors["closeness"]
+                    * factors["night"] * factors["mood"]
+                    * factors["expectation"])
+        self.assertAlmostEqual(out["waiting"], min(1.0, expected), places=2)
+
+
+class AmplificationTest(unittest.TestCase):
+    def test_night_amplifies(self):
+        day = ws.waiting_sense(gap_seconds=4 * 3600, relationship="friend",
+                               hour=14)
+        night = ws.waiting_sense(gap_seconds=4 * 3600, relationship="friend",
+                                 hour=23)
+        self.assertFalse(day["night"])
+        self.assertTrue(night["night"])
+        self.assertGreater(night["waiting"], day["waiting"])
+
+    def test_closeness_amplifies(self):
+        far = ws.waiting_sense(gap_seconds=4 * 3600, relationship="stranger",
+                               hour=14)
+        near = ws.waiting_sense(gap_seconds=4 * 3600,
+                                relationship={"closeness": 0.95}, hour=14)
+        self.assertGreater(near["waiting"], far["waiting"])
+
+    def test_stage_strings_map_to_closeness(self):
+        friend = ws.waiting_sense(gap_seconds=4 * 3600, relationship="friend",
+                                  hour=14)
+        close = ws.waiting_sense(gap_seconds=4 * 3600, relationship="close",
+                                 hour=14)
+        self.assertGreater(close["closeness"], friend["closeness"])
+        self.assertGreater(close["waiting"], friend["waiting"])
+
+    def test_negative_last_emotion_amplifies(self):
+        neutral = ws.waiting_sense(gap_seconds=4 * 3600,
+                                   relationship="friend", hour=14)
+        negative = ws.waiting_sense(
+            gap_seconds=4 * 3600, relationship="friend", hour=14,
+            last_emotion={"valence": -0.8, "arousal": 0.8})
+        self.assertGreater(negative["waiting"], neutral["waiting"])
+
+
+class ThresholdTest(unittest.TestCase):
+    def test_threshold_hit_on_long_gap(self):
+        self.assertTrue(ws.waiting_sense(gap_seconds=8 * 3600)["threshold_hit"])
+
+    def test_custom_threshold_can_suppress(self):
+        out = ws.waiting_sense(**FOND, flags={"threshold": 0.99})
+        self.assertFalse(out["threshold_hit"])
+        self.assertGreater(out["waiting"], 0.5)
+
+    def test_threshold_seconds_rule(self):
+        out = ws.waiting_sense(gap_seconds=6 * 3600 + 1,
+                               flags={"threshold": 0.99})
+        self.assertTrue(out["threshold_hit"])
+
+    def test_not_waiting_has_no_gap_alert(self):
+        out = ws.waiting_sense(gap_seconds=8 * 3600, awaiting_reply=False)
+        self.assertFalse(out["threshold_hit"])
+
+
+class SwitchAndRobustnessTest(unittest.TestCase):
+    def test_disabled_is_neutral(self):
+        out = ws.waiting_sense(gap_seconds=8 * 3600,
+                               flags={"enabled": False})
+        self.assertFalse(out["enabled"])
+        self.assertEqual(out["waiting"], 0.0)
+        self.assertEqual(out["feeling"], "平静")
+        self.assertFalse(out["threshold_hit"])
+        self.assertIn("关闭", out["reason"])
+
+    def test_odd_gaps(self):
+        for gap in (None, "x", [], 3, float("nan"), -100):
+            out = ws.waiting_sense(gap_seconds=gap)
+            self.assertEqual(out["enabled"], True)
+            self.assertGreaterEqual(out["waiting"], 0.0)
+            self.assertLessEqual(out["waiting"], 1.0)
+
+    def test_odd_emotions_and_relationships(self):
+        for emotion in (None, "anger", "sad", "happy", "weird", 3, []):
+            out = ws.waiting_sense(gap_seconds=4 * 3600, last_emotion=emotion)
+            self.assertIn(out["feeling"], ws.FEELINGS)
+        for rel in (None, "x", 3, [], {"stage": "friend"},
+                    {"closeness": -5}):
+            out = ws.waiting_sense(gap_seconds=4 * 3600, relationship=rel)
+            self.assertGreaterEqual(out["closeness"], 0.0)
+            self.assertLessEqual(out["closeness"], 1.0)
+
+    def test_hour_and_night(self):
+        self.assertFalse(ws.waiting_sense(gap_seconds=3600, hour=None)["night"])
+        self.assertTrue(ws.waiting_sense(gap_seconds=3600, hour=2)["night"])
+        self.assertTrue(ws.waiting_sense(gap_seconds=3600, hour=23)["night"])
+        self.assertFalse(ws.waiting_sense(gap_seconds=3600, hour=12)["night"])
+        self.assertEqual(ws.night_factor(None), 1.0)
+        self.assertGreater(ws.night_factor(23), 1.0)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_x_directives.py

@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+"""Cross-layer directives: normalize, merge, conservative precedence."""
+import unittest
+
+from biocore_model import x_directives as xd
+
+
+class NormalizeTest(unittest.TestCase):
+    def test_defaults(self):
+        out = xd.normalize({})
+        self.assertEqual(out["length_scale"], 1.0)
+        self.assertEqual(out["initiative"], 0.5)
+        self.assertEqual(out["tone"], "")
+        self.assertFalse(out["allow_correction"])
+
+    def test_clamps_length_and_initiative(self):
+        out = xd.normalize({"length_scale": 9, "initiative": -3})
+        self.assertEqual(out["length_scale"], xd.LENGTH_MAX)
+        self.assertEqual(out["initiative"], 0.0)
+
+    def test_legacy_proactive_maps_to_initiative(self):
+        out = xd.normalize({"proactive": 0.8})
+        self.assertEqual(out["initiative"], 0.8)
+
+    def test_legacy_allow_fields(self):
+        self.assertTrue(xd.normalize({"allow_self_correction": True})["allow_correction"])
+        self.assertTrue(xd.normalize({"allow_clarify": True})["allow_correction"])
+
+    def test_note_from_reason(self):
+        self.assertEqual(xd.normalize({"reason": "因为累"}).get("note"), "因为累")
+
+    def test_source_recorded(self):
+        self.assertEqual(xd.normalize({}, "metacog")["sources"], ["metacog"])
+
+    def test_malformed(self):
+        out = xd.normalize("nope")
+        self.assertEqual(out["length_scale"], 1.0)
+
+
+class MergeTest(unittest.TestCase):
+    def test_empty(self):
+        out = xd.merge([])
+        self.assertEqual(out["length_scale"], 1.0)
+        self.assertEqual(out["sources"], [])
+
+    def test_takes_min_length(self):
+        out = xd.merge([{"length_scale": 1.0}, {"length_scale": 0.8},
+                        {"length_scale": 0.9}])
+        self.assertEqual(out["length_scale"], 0.8)
+
+    def test_takes_min_initiative(self):
+        out = xd.merge([{"proactive": 0.8}, {"initiative": 0.3}])
+        self.assertEqual(out["initiative"], 0.3)
+
+    def test_tone_priority(self):
+        out = xd.merge_named([("metacog", {"tone": "低置信"}),
+                              ("dissonance", {"tone": "认一句"}),
+                              ("value_order", {"tone": "按选定的来"})])
+        self.assertEqual(out["tone"], "认一句")
+
+    def test_tone_ignores_empty(self):
+        out = xd.merge_named([("value_order", {"tone": ""}),
+                              ("metacog", {"tone": "少说"})])
+        self.assertEqual(out["tone"], "少说")
+
+    def test_correction_is_or(self):
+        out = xd.merge([{"allow_self_correction": False},
+                        {"allow_correction": True}])
+        self.assertTrue(out["allow_correction"])
+
+    def test_notes_joined_and_deduped(self):
+        out = xd.merge_named([("metacog", {"reason": "不确定"}),
+                              ("attributor", {"reason": "不确定"}),
+                              ("narrative", {"note": "故事有点矛盾"})])
+        self.assertEqual(out["note"].count("不确定"), 1)
+        self.assertIn("故事有点矛盾", out["note"])
+
+    def test_sources_listed(self):
+        out = xd.merge_named([("metacog", {}), ("metacog", {}),
+                              ("dissonance", {})])
+        self.assertEqual(out["sources"], ["metacog", "dissonance"])
+
+    def test_idempotent(self):
+        first = xd.merge_named([("metacog", {"tone": "少说"})])
+        first["_x_normalized"] = True
+        second = xd.merge([first])
+        self.assertEqual(second["length_scale"], first["length_scale"])
+        self.assertEqual(second["tone"], first["tone"])
+
+    def test_malformed_entries_skipped(self):
+        out = xd.merge([None, "x", {"length_scale": 0.7}])
+        self.assertEqual(out["length_scale"], 0.7)
+        self.assertEqual(len(out["sources"]), 1)
+
+    def test_note_capped(self):
+        out = xd.merge([{"note": "字" * 500}])
+        self.assertLessEqual(len(out["note"]), xd.NOTE_LIMIT)
+
+
+if __name__ == "__main__":
+    unittest.main()