dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_possible_selves.py

@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+"""Possible selves: gaps, weights, one-line sentence."""
+import unittest
+
+from biocore_model import possible_selves as ps
+
+SELVES = [
+    {"name": "更会照顾人", "target": {"benevolence": 0.95}, "importance": 0.9},
+    {"name": "更安定", "target": {"security": 0.95}, "importance": 0.5},
+    {"name": "更会说", "target": {"power": 0.9}, "importance": 0.3},
+]
+CURRENT = {"benevolence": 0.5, "security": 0.9, "power": 0.85}
+
+
+class GapTest(unittest.TestCase):
+    def test_gap_positive(self):
+        value = ps.gap({"benevolence": 0.9}, {"benevolence": 0.4})
+        self.assertAlmostEqual(value, 0.5)
+
+    def test_gap_zero_when_matching(self):
+        self.assertEqual(ps.gap({"security": 0.5}, {"security": 0.5}), 0.0)
+
+    def test_gap_bounded(self):
+        self.assertLessEqual(ps.gap({"power": 1.0}, {"power": 0.0}), 1.0)
+
+    def test_empty_target(self):
+        self.assertEqual(ps.gap({}, {"power": 1.0}), 0.0)
+
+
+class RankTest(unittest.TestCase):
+    def test_sorted_by_weight(self):
+        out = ps.rank(SELVES, CURRENT)
+        weights = [item["weight"] for item in out["selves"]]
+        self.assertEqual(weights, sorted(weights, reverse=True))
+
+    def test_top_is_biggest_gap(self):
+        out = ps.rank(SELVES, CURRENT)
+        self.assertEqual(out["top"], "更会照顾人")
+
+    def test_shares_sum_to_one(self):
+        out = ps.rank(SELVES, CURRENT)
+        self.assertAlmostEqual(sum(item["share"] for item in out["selves"]), 1.0, places=2)
+
+    def test_importance_scales_weight(self):
+        low = {"name": "a", "target": {"benevolence": 0.9}, "importance": 0.1}
+        high = {"name": "b", "target": {"benevolence": 0.9}, "importance": 0.9}
+        out = ps.rank([low, high], {"benevolence": 0.1})
+        self.assertEqual(out["top"], "b")
+
+    def test_sentence(self):
+        out = ps.rank(SELVES, CURRENT)
+        self.assertIn("她还想成为", out["sentence"])
+        self.assertLessEqual(len(out["sentence"]), ps.SENTENCE_LIMIT)
+
+    def test_caps_self_count(self):
+        many = [{"name": "s%d" % i, "target": {"benevolence": 0.9}} for i in range(20)]
+        self.assertLessEqual(len(ps.rank(many, CURRENT)["selves"]), ps.MAX_SELVES)
+
+
+class FallbackTest(unittest.TestCase):
+    def test_disabled(self):
+        out = ps.rank(SELVES, CURRENT, flags={"enabled": False})
+        self.assertFalse(out["enabled"])
+        self.assertEqual(out["selves"], [])
+        self.assertEqual(out["sentence"], "")
+
+    def test_malformed(self):
+        out = ps.rank([None, "x", {"name": ""}, {"name": "ok", "target": {}}], "bad")
+        self.assertEqual(out["selves"], [])
+
+    def test_no_current_uses_default(self):
+        out = ps.rank([{"name": "a", "target": {"security": 1.0}}], None)
+        self.assertGreater(out["selves"][0]["gap"], 0.0)
+
+
+class DirectiveTest(unittest.TestCase):
+    def test_pull_matches_top(self):
+        result = ps.rank(SELVES, CURRENT)
+        out = ps.directives(result)
+        self.assertIn("更会照顾人", out["tone"])
+        self.assertGreater(out["pull"], 0.0)
+
+    def test_disabled(self):
+        self.assertEqual(ps.directives({"enabled": False})["tone"], "")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_predictor.py

@@ -0,0 +1,227 @@
+# -*- coding: utf-8 -*-
+"""P1-1 predictive coding tests (predictor.py + main wiring)."""
+import ast
+import json
+import types
+import unittest
+from pathlib import Path
+
+from biocore_model import predictor as pr
+from biocore_model import policy_learning as pl
+
+ROOT = Path(__file__).resolve().parents[2]
+MAIN = ROOT / "main.py"
+SOURCE = MAIN.read_text(encoding="utf-8")
+SCHEMA = json.loads((ROOT / "_conf_schema.json").read_text(encoding="utf-8"))
+
+STATE = {"v": 0.2, "a": 0.5, "d": 0.5, "social": 0.6, "stress": 0.3,
+         "energy": 0.6, "trust": 0.6, "emotion": "joy",
+         "needs": {"belonging": 0.5, "self_esteem": 0.6, "control": 0.4,
+                   "meaningful_existence": 0.7}}
+
+
+def _load_cycle():
+    tree = ast.parse(SOURCE)
+    node = next(item for item in tree.body
+                if isinstance(item, ast.FunctionDef)
+                and item.name == "_predictive_cycle")
+    clone = ast.FunctionDef(name=node.name, args=node.args, body=node.body,
+                            decorator_list=[], returns=node.returns,
+                            type_comment=None, lineno=node.lineno,
+                            col_offset=node.col_offset,
+                            end_lineno=node.end_lineno,
+                            end_col_offset=node.end_col_offset)
+    state_node = next(item for item in tree.body
+                      if isinstance(item, ast.FunctionDef)
+                      and item.name == "_prediction_state")
+    state_clone = ast.FunctionDef(name=state_node.name, args=state_node.args,
+                                  body=state_node.body, decorator_list=[],
+                                  returns=state_node.returns, type_comment=None,
+                                  lineno=state_node.lineno,
+                                  col_offset=state_node.col_offset,
+                                  end_lineno=state_node.end_lineno,
+                                  end_col_offset=state_node.end_col_offset)
+    log = []
+    ns = {"logger": types.SimpleNamespace(
+        info=lambda *a, **k: log.append(a),
+        warning=lambda *a, **k: None,
+        debug=lambda *a, **k: None)}
+    exec(compile(ast.Module(body=[state_clone, clone], type_ignores=[]),
+                 "<_predictive_cycle>", "exec"), ns)
+    return ns[node.name], log
+
+
+CYCLE, LOG = _load_cycle()
+
+
+class FakeCore:
+    def __init__(self, state=None):
+        for key, value in (state or STATE).items():
+            setattr(self, key, value)
+        self.labels = {"emotion": (state or STATE).get("emotion", "joy")}
+
+
+class FakePlugin:
+    def __init__(self, enabled=True):
+        self.predictive_enabled = enabled
+        self._next_prediction = None
+        self._predict_history = []
+
+
+class VectorTest(unittest.TestCase):
+    def test_vector_clamps_and_orders(self):
+        vec = pr.vector({"v": 9, "a": -3, "d": "x", "social": 0.4})
+        self.assertEqual(list(vec), list(pr.CHANNELS))
+        self.assertEqual(vec["v"], 1.0)
+        self.assertEqual(vec["a"], 0.0)
+        self.assertEqual(vec["d"], 0.0)
+        self.assertEqual(vec["social"], 0.4)
+
+    def test_predict_flat_state_is_current(self):
+        pred = pr.predict(STATE)
+        self.assertEqual(pred["channels"], pr.vector(STATE))
+        self.assertEqual(pred["emotion"], "joy")
+
+    def test_predict_follows_damped_trend(self):
+        history = [dict(pr.vector(STATE), v=0.0), pr.vector(STATE)]
+        pred = pr.predict(STATE, history=history)
+        self.assertEqual(pred["channels"]["v"], 0.3)
+        rising = [pr.vector({"v": 0.0}), pr.vector({"v": 0.1})]
+        pred2 = pr.predict({"v": 0.1}, history=rising)
+        self.assertAlmostEqual(pred2["channels"]["v"], 0.15)
+        self.assertGreater(pred2["confidence"], pr.predict(STATE)["confidence"])
+
+    def test_slope_is_clamped(self):
+        history = [pr.vector({"v": -1.0}), pr.vector({"v": 1.0})]
+        pred = pr.predict({"v": 1.0}, history=history)
+        self.assertLessEqual(pred["channels"]["v"], 1.0)
+        self.assertAlmostEqual(pred["channels"]["v"], 1.0)
+
+    def test_needs_drift_toward_baseline(self):
+        pred = pr.predict(STATE)
+        self.assertGreater(pred["needs"]["belonging"], 0.5)
+        self.assertLess(pred["needs"]["meaningful_existence"], 0.7)
+
+
+class CompareTest(unittest.TestCase):
+    def test_identical_state_has_no_surprise(self):
+        pred = pr.predict(STATE)
+        report = pr.compare(pred, STATE)
+        self.assertEqual(report["error"], 0.0)
+        self.assertEqual(report["surprise"], 0.0)
+        self.assertTrue(report["emotion_hit"])
+
+    def test_large_change_raises_surprise(self):
+        pred = pr.predict(STATE)
+        changed = dict(STATE, v=-0.6, a=0.95, stress=0.9, emotion="anger")
+        report = pr.compare(pred, changed)
+        self.assertGreater(report["error"], 0.1)
+        self.assertGreaterEqual(report["surprise"], 0.5)
+        self.assertFalse(report["emotion_hit"])
+        self.assertEqual(report["actual_emotion"], "anger")
+        self.assertEqual(report["channels"]["v"]["error"], 0.8)
+
+    def test_needs_error_reported(self):
+        pred = pr.predict(STATE)
+        changed = dict(STATE, needs={"belonging": 0.1, "self_esteem": 0.6,
+                                     "control": 0.4, "meaningful_existence": 0.7})
+        report = pr.compare(pred, changed)
+        self.assertGreater(report["needs_error"], 0.0)
+
+    def test_surprise_bounds_and_monotonicity(self):
+        values = [pr.surprise(x) for x in (0.0, 0.05, 0.1, 0.25, 1.0)]
+        self.assertEqual(values, sorted(values))
+        self.assertEqual(values[0], 0.0)
+        self.assertEqual(values[-1], 1.0)
+
+
+class EffectScaleTest(unittest.TestCase):
+    def test_attention_boost_monotone_bounded(self):
+        values = [pr.attention_boost(x) for x in (0.0, 0.2, 0.5, 1.0)]
+        self.assertEqual(values, sorted(values))
+        self.assertEqual(values[0], 0.0)
+        self.assertEqual(values[-1], 1.0)
+
+    def test_learning_rate_scale_monotone_bounded(self):
+        low = pr.learning_rate_scale(0.0)
+        high = pr.learning_rate_scale(1.0)
+        self.assertEqual(low, 0.6)
+        self.assertEqual(high, 1.8)
+        self.assertLess(low, high)
+        custom = pr.learning_rate_scale(0.5, low=0.5, high=2.0)
+        self.assertAlmostEqual(custom, 1.25)
+
+    def test_scale_feeds_policy_alpha(self):
+        # The main wiring multiplies the policy-learning alpha by the scale.
+        self.assertIn("_prediction_lr_scale", SOURCE)
+        self.assertIn("alpha=_lr", SOURCE)
+        slow_table = pl.update({}, "ctx", "approach", 1.0, alpha=0.1)
+        fast_table = pl.update({}, "ctx", "approach", 1.0, alpha=0.4)
+        slow_q = float(slow_table["ctx"]["approach"]["q"])
+        fast_q = float(fast_table["ctx"]["approach"]["q"])
+        self.assertLess(slow_q, fast_q)
+
+
+class HistoryTest(unittest.TestCase):
+    def test_append_history_bounded_and_non_mutating(self):
+        history = [pr.vector({"v": i / 20.0}) for i in range(6)]
+        snapshot = list(history)
+        grown = pr.append_history(history, pr.vector({"v": 0.9}))
+        self.assertEqual(history, snapshot)
+        self.assertEqual(len(grown), pr.MAX_HISTORY)
+        self.assertEqual(grown[-1]["v"], 0.9)
+
+    def test_invalid_inputs_are_safe(self):
+        self.assertTrue(all(v == 0.0 for v in pr.vector(None).values()))
+        self.assertEqual(pr.predict(None)["emotion"], "neutral")
+        self.assertEqual(pr.compare(None, None)["surprise"], 0.0)
+        self.assertEqual(pr.append_history("x", "y"), [])
+        self.assertEqual(pr.summary(None)["surprise"], 0.0)
+
+
+class WiringTest(unittest.TestCase):
+    def test_main_wiring_markers(self):
+        self.assertIn("def _predictive_cycle(plugin, core)", SOURCE)
+        self.assertIn("_predictive_cycle(self, core)", SOURCE)
+        self.assertIn("attention_boost", SOURCE)
+        self.assertIn("_retrieval_limit + 1", SOURCE)
+        self.assertIn("predictor as _predictor", SOURCE)
+        self.assertIn("[biocore] predict surprise=", SOURCE)
+
+    def test_schema_and_config_default(self):
+        self.assertIn("predictive_enabled", SCHEMA)
+        self.assertTrue(SCHEMA["predictive_enabled"]["default"])
+        self.assertIn('self.config.get("predictive_enabled", True)', SOURCE)
+
+    def _run(self, plugin, core):
+        return CYCLE(plugin, core)
+
+    def test_cycle_records_error_and_predicts_next(self):
+        plugin = FakePlugin()
+        core = FakeCore()
+        LOG.clear()
+        self.assertEqual(self._run(plugin, core), {})
+        self.assertIsNotNone(plugin._next_prediction)
+        changed = dict(STATE, v=-0.7, stress=0.9, emotion="anger")
+        core2 = FakeCore(changed)
+        report = self._run(plugin, core2)
+        row = pr.summary(report)
+        self.assertGreater(report["surprise"], 0.0)
+        self.assertEqual(core2.prediction_surprise, row["surprise"])
+        self.assertAlmostEqual(core2.learning_rate_scale,
+                               row["learning_rate_scale"], places=3)
+        self.assertGreaterEqual(core2.attention_boost, 0.0)
+        self.assertTrue(any("predict" in str(row) for row in LOG))
+        self.assertEqual(plugin._prediction_lr_scale,
+                         core2.learning_rate_scale)
+
+    def test_cycle_disabled_is_noop(self):
+        plugin = FakePlugin(enabled=False)
+        core = FakeCore()
+        self.assertEqual(self._run(plugin, core), {})
+        self.assertIsNone(plugin._next_prediction)
+        self.assertFalse(hasattr(core, "prediction_surprise"))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_preference_drift.py

@@ -0,0 +1,142 @@
+# -*- coding: utf-8 -*-
+"""task-219: repeated topics slowly drift value_order (preference drift)."""
+import unittest
+
+from biocore_memory.core import config as engine_config
+from biocore_model import preference_drift as pd
+from biocore_model import value_order as vo
+
+
+def memory(text):
+    return {"id": "m", "text": text, "role": "user", "ts": 1700000000.0}
+
+
+class SwitchTest(unittest.TestCase):
+    def test_flag_defaults_off(self):
+        self.assertIs(engine_config.FLAGS.get("preference_drift"), False)
+
+    def test_enabled_reads_flag_and_env(self):
+        self.assertFalse(pd.enabled({}))
+        self.assertTrue(pd.enabled({"preference_drift": True}))
+        self.assertTrue(pd.enabled({}, {"BIOCORE_PREFERENCE_DRIFT": "1"}))
+        self.assertFalse(pd.enabled({}, {"BIOCORE_PREFERENCE_DRIFT": "0"}))
+
+    def test_disabled_leaves_weights_alone(self):
+        before = vo.defaults()
+        out = pd.step(before, {"安全": 50}, {}, enabled=False)
+        self.assertEqual(out["reason"], "disabled")
+        self.assertEqual(out["drifted"], {})
+        self.assertEqual(out["weights"], vo.normalize(before))
+
+
+class TopicTest(unittest.TestCase):
+    def test_topics_extract_cjk_and_latin(self):
+        found = pd.topics("今天陪我聊聊天 happy")
+        self.assertIn("陪我", found)
+        self.assertIn("happy", found)
+        self.assertNotIn("今天", found)  # stopword
+
+    def test_dimension_mapping(self):
+        self.assertEqual(pd.dimension_of("安全"), "security")
+        self.assertEqual(pd.dimension_of("陪我"), "benevolence")
+        self.assertEqual(pd.dimension_of("开心"), "hedonism")
+        self.assertEqual(pd.dimension_of("诚实"), "universalism")
+        self.assertIsNone(pd.dimension_of("zzz"))
+
+    def test_accumulate_counts_once_per_entry(self):
+        counts = pd.accumulate({}, [memory("安全安全"), memory("注意安全"),
+                                    memory("安全第一")])
+        self.assertEqual(counts["安全"], 3)
+        self.assertIn("陪我", pd.count_topics([memory("陪我聊天")]))
+
+    def test_entries_are_not_mutated(self):
+        entry = memory("陪我聊天")
+        snapshot = dict(entry)
+        pd.accumulate({}, [entry])
+        self.assertEqual(entry, snapshot)
+
+
+class DriftTest(unittest.TestCase):
+    def test_below_threshold_does_nothing(self):
+        out = pd.step(vo.defaults(), {"安全": 5}, {}, days=1)
+        self.assertEqual(out["drifted"], {})
+        self.assertEqual(out["weights"], vo.defaults())
+
+    def test_repeated_topic_raises_dimension(self):
+        counts = pd.count_topics([memory("注意安全") for _ in range(6)])
+        self.assertEqual(counts["安全"], 6)
+        out = pd.step(vo.defaults(), counts, {}, days=1)
+        self.assertEqual(out["drifted"].get("security"), 0.01)
+        self.assertAlmostEqual(out["weights"]["security"], 0.71, places=4)
+
+    def test_daily_cap_is_respected(self):
+        out = pd.step(vo.defaults(), {"安全": 50}, {}, days=1)
+        self.assertLessEqual(out["drifted"]["security"], pd.DAILY_CAP)
+        self.assertAlmostEqual(out["drifted"]["security"], 0.01, places=4)
+
+    def test_replay_is_idempotent(self):
+        counts = {"安全": 6}
+        first = pd.step(vo.defaults(), counts, {}, days=1)
+        second = pd.step(first["weights"], counts, first["counts"], days=1)
+        self.assertEqual(second["drifted"], {})
+        self.assertEqual(second["weights"], first["weights"])
+        self.assertEqual(second["weights"]["security"], first["weights"]["security"])
+
+    def test_multi_month_accumulation(self):
+        weights = vo.defaults()
+        counts = {}
+        last = {}
+        for day in range(1, 91):
+            if day % 3 == 0:
+                counts = pd.accumulate(counts, [memory("还是要注意安全")])
+            out = pd.step(weights, counts, last, days=3)
+            weights, last = out["weights"], out["counts"]
+        # 30 mentions, first 5 under threshold, 25 steps x 0.002
+        self.assertAlmostEqual(weights["security"], 0.75, places=3)
+
+
+class BoundsTest(unittest.TestCase):
+    def test_ceiling(self):
+        weights = vo.defaults()
+        counts = {}
+        last = {}
+        for day in range(1, 301):
+            counts = pd.accumulate(counts, [memory("注意安全")])
+            out = pd.step(weights, counts, last, days=1)
+            weights, last = out["weights"], out["counts"]
+        self.assertLessEqual(weights["security"], vo.WEIGHT_CEIL)
+        self.assertGreaterEqual(weights["security"], vo.WEIGHT_FLOOR)
+
+    def test_floor_via_normalize(self):
+        out = pd.step({"security": -5.0}, {}, {}, days=1)
+        self.assertGreaterEqual(out["weights"]["security"], vo.WEIGHT_FLOOR)
+
+    def test_decay_returns_toward_default(self):
+        table = vo.defaults()
+        table["security"] = 0.90
+        out = pd.step(table, {}, {}, days=30)
+        self.assertIn("security", out["decayed"])
+        self.assertAlmostEqual(out["weights"]["security"], 0.885, places=4)
+
+    def test_decay_settles_at_default(self):
+        table = vo.defaults()
+        table["security"] = 0.90
+        for _ in range(200):
+            table = pd.step(table, {}, {}, days=30)["weights"]
+        self.assertAlmostEqual(table["security"], vo.DEFAULTS["security"], places=3)
+
+
+class DegradedTest(unittest.TestCase):
+    def test_missing_value_order_skips(self):
+        saved = pd._vo
+        pd._vo = None
+        try:
+            out = pd.step({"security": 0.7}, {"安全": 9}, {}, days=1)
+        finally:
+            pd._vo = saved
+        self.assertEqual(out["reason"], "value_order_unavailable")
+        self.assertEqual(out["weights"], {"security": 0.7})
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_preset.py

@@ -0,0 +1,142 @@
+# -*- coding: utf-8 -*-
+"""Preset structure tests: positions, order, conditions, depth, empty skip."""
+import sys
+import unittest
+from pathlib import Path
+
+from biocore_model import preset
+
+PKG = Path(__file__).resolve().parents[1]
+IDS = ["situation", "layered_memory", "graph_memory", "state_block",
+       "relationship", "gap", "speak_style", "numeric_legend"]
+FULL = {"situation": "对方在质问你。", "layered_memory": "[分层记忆] 常驻事实：他姓王", "graph_memory": "你知道的：\n- 小夏 —害怕→ 打雷",
+        "state_block": "她此刻：紧张。", "relationship": "关系：亲近，信任中等。",
+        "gap": "已 3 小时没说话。", "speak_style": "一次只说一句，10 字以内。",
+        "numeric_legend": "v 正面度 / a 唤醒度"}
+
+
+def _rec(**extra):
+    base = {"id": "x", "name": "X", "role": "system",
+            "position": "before_history", "depth": 4, "order": 100,
+            "enabled": True, "condition": "", "content": "{{ value }}"}
+    base.update(extra)
+    return base
+
+
+class StructureTest(unittest.TestCase):
+    def test_default_record_ids(self):
+        self.assertEqual([r["id"] for r in preset.PRESET], IDS)
+
+    def test_default_record_fields(self):
+        required = {"id", "name", "role", "position", "depth", "order",
+                    "enabled", "condition", "content"}
+        for record in preset.PRESET:
+            self.assertTrue(required.issubset(record.keys()), record["id"])
+            self.assertIn(record["position"], preset.POSITIONS)
+            self.assertTrue(record["enabled"])
+
+    def test_default_positions(self):
+        by_id = {r["id"]: r for r in preset.PRESET}
+        for key in ("situation", "layered_memory", "state_block",
+                    "relationship", "gap"):
+            self.assertEqual(by_id[key]["position"], "before_history")
+        self.assertEqual(by_id["speak_style"]["position"], "depth")
+        self.assertEqual(by_id["speak_style"]["depth"], 2)
+        self.assertEqual(by_id["numeric_legend"]["position"], "after_history")
+
+    def test_before_history_order(self):
+        out = preset.assemble(FULL, history_len=10)
+        self.assertEqual([b["id"] for b in out["before_history"]],
+                         ["situation", "layered_memory", "graph_memory",
+                          "state_block", "relationship", "gap"])
+
+    def test_depth_group(self):
+        out = preset.assemble(FULL, history_len=10)
+        self.assertEqual(len(out["depth"]), 1)
+        self.assertEqual(out["depth"][0]["depth"], 2)
+        self.assertEqual(out["depth"][0]["blocks"][0]["id"], "speak_style")
+
+    def test_after_history_group(self):
+        out = preset.assemble(FULL, history_len=10)
+        self.assertEqual([b["id"] for b in out["after_history"]],
+                         ["numeric_legend"])
+
+    def test_empty_action_skips_missing_vars(self):
+        out = preset.assemble({}, history_len=3)
+        self.assertEqual(out["before_history"], [])
+        self.assertEqual(out["depth"], [])
+        self.assertEqual(out["after_history"], [])
+
+    def test_empty_content_is_skipped(self):
+        out = preset.assemble({"situation": "   ", "gap": "\n"}, 3)
+        self.assertEqual(out["before_history"], [])
+
+    def test_variables_are_substituted(self):
+        out = preset.assemble({"situation": "他在夸你。"}, 3)
+        self.assertEqual(out["before_history"][0]["content"],
+                         "[局面摘要]\n他在夸你。")
+
+    def test_condition_false_hides_block(self):
+        out = preset.assemble({"situation": "x", "layered_memory": ""}, 3)
+        self.assertEqual([b["id"] for b in out["before_history"]],
+                         ["situation"])
+
+    def test_threshold_condition(self):
+        record = _rec(condition="trust > 0.5", content="trusted")
+        self.assertEqual(len(preset._blocks([record], {"trust": 0.8}, 0)), 1)
+        self.assertEqual(len(preset._blocks([record], {"trust": 0.2}, 0)), 0)
+
+    def test_invalid_condition_fails_closed(self):
+        record = _rec(condition="1 +", content="never")
+        self.assertEqual(preset._blocks([record], {}, 0), [])
+
+    def test_order_sorting(self):
+        low = _rec(id="b", order=200, content="B")
+        high = _rec(id="a", order=100, content="A")
+        out = preset._blocks([low, high], {}, 0)
+        self.assertEqual([b["id"] for b in out], ["a", "b"])
+
+    def test_depth_clamped_by_history_len(self):
+        out = preset.assemble(FULL, history_len=1)
+        self.assertEqual(out["depth"][0]["depth"], 1)
+        out2 = preset.assemble(FULL, history_len=0)
+        self.assertEqual(out2["depth"][0]["depth"], 0)
+
+    def test_render_texts_flattens_positions(self):
+        rows = preset.render_texts(preset.assemble(FULL, 10))
+        positions = [row[0] for row in rows]
+        self.assertEqual(positions.count("before_history"), 6)
+        self.assertEqual(positions.count("depth"), 1)
+        self.assertEqual(positions.count("after_history"), 1)
+
+    def test_module_is_pure_and_does_not_import_main(self):
+        source = (PKG / "preset.py").read_text(encoding="utf-8")
+        self.assertNotIn("import main", source)
+        self.assertNotIn("main.py", source)
+        # Check the module's own namespace instead of the global sys.modules:
+        # discovery imports root-level test modules that import main, which made
+        # the old process-wide assertion order-dependent.
+        module = sys.modules.get("biocore_model.preset")
+        self.assertIsNotNone(module)
+        self.assertNotIn("main", vars(module))
+
+    def test_depth_index_after_nth_newest(self):
+        self.assertEqual(preset.depth_index(10, 2), 9)
+        self.assertEqual(preset.depth_index(3, 5), 0)
+        self.assertEqual(preset.depth_index(0, 2), 0)
+
+    def test_ui_settings_preset_default_is_on(self):
+        from biocore_model import ui_settings
+        self.assertIs(ui_settings.DEFAULTS["preset"]["enabled"], True)
+
+    def test_main_has_gated_fallback_path(self):
+        from pathlib import Path
+        repo = Path(__file__).resolve().parents[2]
+        main = (repo / "main.py").read_text(encoding="utf-8")
+        self.assertIn("if self._preset_enabled():", main)
+        self.assertIn("self._inject_preset(req, event, core, _user_data,", main)
+        self.assertIn("self._legacy_context_blocks(req, event, core, _user_data,",
+                      main)
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_proactive_context.py

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+import time, unittest
+from biocore_model import proactive_context as pc
+
+NOW = 1_700_000_000
+
+class FakeCore:
+    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
+    homeostasis = {'drives': {'belong': 0.26, 'curiosity': 0.1}}
+    interoception = {'label': 'steady'}
+
+class ContextTest(unittest.TestCase):
+    def test_state_block_fields(self):
+        text = pc.render_state_block(FakeCore())
+        self.assertIn('主导情绪：joy', text); self.assertIn('情绪谱', text); self.assertIn('维度', text)
+    def test_state_block_missing_fields_no_crash(self):
+        class Empty: pass
+        self.assertIn('主导情绪', pc.render_state_block(Empty()))
+    def test_relationship(self):
+        text = pc.render_relationship({'state': {'closeness': 0.61, 'trust': 0.57, 'conflict': 0.22}, 'attachment': {'safe': 0.5}})
+        self.assertIn('亲近 0.61', text); self.assertIn('依恋安全感 0.50', text)
+    def test_gap_bands(self):
+        self.assertIn('刚刚', pc.gap_text(0.5))
+        self.assertIn('几小时前', pc.gap_text(3))
+        self.assertIn('大半天', pc.gap_text(10))
+        self.assertIn('两天多', pc.gap_text(38))
+        self.assertIn('好几天', pc.gap_text(80))
+    def test_gap_style_hint(self):
+        self.assertIn('抗议', pc.attachment_gap_hint('anxious'))
+        self.assertIn('不要提间隔', pc.attachment_gap_hint('avoidant'))
+        self.assertIn('温和问候', pc.attachment_gap_hint('secure'))
+    def test_event_next_date(self):
+        hints = pc.render_event_hints([{'title': '体检', 'next_date_ts': NOW + 86400, 'importance': 0.8}], NOW)
+        self.assertTrue(any('体检' in h and '明天' in h for h in hints))
+    def test_event_unresolved(self):
+        hints = pc.render_event_hints([{'title': '旧话题', 'unresolved': True, 'ts': NOW - 2 * 86400, 'importance': 0.8}], NOW)
+        self.assertTrue(any('没收尾' in h for h in hints))
+    def test_event_low_importance_filtered(self):
+        self.assertEqual(pc.render_event_hints([{'title': 'x', 'next_date_ts': NOW + 3600, 'importance': 0.1}], NOW), [])
+    def test_event_no_title_skipped(self):
+        self.assertEqual(pc.render_event_hints([{'next_date_ts': NOW + 3600, 'importance': 0.9}], NOW), [])
+    def test_event_max_two(self):
+        events = [{'title': 'a', 'next_date_ts': NOW + 3600, 'importance': 0.9}, {'title': 'b', 'unresolved': True, 'ts': NOW - 2 * 86400, 'importance': 0.9}, {'title': 'c', 'unresolved': True, 'ts': NOW - 2 * 86400, 'importance': 0.9}]
+        self.assertLessEqual(len(pc.render_event_hints(events, NOW)), 2)
+    def test_l1_extra_lines(self):
+        lines = pc.l1_extra_lines(38, [{'title': '体检', 'next_date_ts': NOW + 86400, 'importance': 0.9}], NOW)
+        self.assertTrue(any(line.startswith('【间隔】') for line in lines))
+        self.assertTrue(any(line.startswith('【你记得】') for line in lines))
+    def test_prompt_order(self):
+        prompt = pc.build_proactive_prompt('人设', '说话方式', '情绪块', '关系块', '间隔块', ['提示'], {'code': 'lonely', 'text': '有点闷', 'weight': 0.3}, 1.34)
+        user = prompt['user']
+        self.assertLess(user.index('【当前情绪】'), user.index('【关系】'))
+        self.assertLess(user.index('【关系】'), user.index('【间隔】'))
+        self.assertLess(user.index('【间隔】'), user.index('【动机】'))
+        self.assertLess(user.index('【动机】'), user.index('【要求】'))
+        self.assertIn('动机', user)
+        self.assertNotIn('<bc>', prompt['system'])
+        self.assertNotIn('【输出格式', prompt['system'])
+    def test_prompt_contains_event_hints(self):
+        prompt = pc.build_proactive_prompt("人设", "说话", "x", "y", "z", ["他提过「体检」（明天）"], {"code": "memory_due", "text": "记得体检", "weight": 0.4}, 1.2)
+        self.assertIn("你记得", prompt["user"]); self.assertIn("体检", prompt["user"])
+
+    def test_system_contains_persona_and_speak(self):
+        prompt = pc.build_proactive_prompt('人设', '说话方式', 'x', 'y', 'z', [], {})
+        self.assertIn('人设', prompt['system']); self.assertIn('说话方式', prompt['system'])
+
+if __name__ == '__main__':
+    unittest.main()