dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_autonomy_tick.py

@@ -0,0 +1,148 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import autonomy_tick as at
+
+NOW = 1_700_000_000
+
+class FakeCore:
+    def snapshot(self): return {}
+
+class Deps:
+    def __init__(self, **kw):
+        self.acc = kw.get('acc', {})
+        self.sessions = kw.get('sessions', [{'umo': 'u1'}])
+        self.snapshot_value = kw.get('snapshot_value', {})
+        self.step_result = kw.get('step_result', {'V': 0.0, 'fire': False})
+        self.gate_result = kw.get('gate_result', (True, 'fired'))
+        self.any_core_value = kw.get('any_core', FakeCore())
+        self.sent = []
+    def load_acc(self): return dict(self.acc)
+    def save_acc(self, acc): self.acc = dict(acc)
+    def list_sessions(self): return list(self.sessions)
+    def get_core(self, umo): return FakeCore()
+    def any_core(self): return self.any_core_value
+    def snapshot(self, core): return dict(self.snapshot_value)
+    def step(self, V, drift, theta): return dict(self.step_result)
+    def gate(self, core, acc, silence, now): return self.gate_result
+    def send_text(self, umo, text): self.sent.append(umo); return True
+    def build_text(self, core, acc): return '在。'
+
+class TickTest(unittest.TestCase):
+    def test_window_skip_when_sleeping(self):
+        ok, reason = at._check_window({}, NOW, {'sleep': {'sleeping': True}})
+        self.assertFalse(ok); self.assertEqual(reason, 'sleeping')
+    def test_window_allows_awake(self):
+        self.assertTrue(at._check_window({}, NOW, {'sleep': {'sleeping': False}})[0])
+    def test_silence_hours(self):
+        self.assertAlmostEqual(at._compute_silence({'last_user_msg_ts': NOW - 7200}, NOW)['hours'], 2.0)
+    def test_motive_drift_positive(self):
+        self.assertGreater(at._compute_motive({}, {'social_gap': 0.5})['drift'], 0)
+    def test_decide_sleep_skip(self):
+        self.assertEqual(at._decide({}, FakeCore(), NOW, {'sleep': {'sleeping': True}})['action'], 'skip')
+    def test_decide_awake_send(self):
+        self.assertEqual(at._decide({}, FakeCore(), NOW, {})['action'], 'send')
+    def test_tick_no_fire_skips(self):
+        deps = Deps(step_result={'V': 0.2, 'fire': False})
+        out = at.tick_once(deps, NOW)
+        self.assertEqual(out['sent'], []); self.assertEqual(out['skipped'], ['u1'])
+    def test_tick_fire_sends(self):
+        deps = Deps(step_result={'V': 0.0, 'fire': True})
+        out = at.tick_once(deps, NOW)
+        self.assertEqual(out['sent'], ['u1']); self.assertEqual(deps.sent, ['u1'])
+    def test_tick_gate_blocks(self):
+        deps = Deps(step_result={'V': 0.0, 'fire': True}, gate_result=(False, 'cooldown'))
+        out = at.tick_once(deps, NOW)
+        self.assertEqual(out['blocked'], ['u1']); self.assertEqual(out['reason'], 'cooldown')
+    def test_tick_records_last_tick(self):
+        deps = Deps(step_result={'V': 0.0, 'fire': False})
+        at.tick_once(deps, NOW)
+        self.assertEqual(deps.acc['last_tick_ts'], NOW)
+    def test_no_session_still_advances_v(self):
+        deps = Deps(sessions=[])
+        deps.acc = {"V": 0.1, "theta": 0.55, "leak": 0.15}
+        deps.step = lambda V, drift, theta: {"V": V + 0.01, "fire": False}
+        values = []
+        for index in range(5):
+            at.tick_once(deps, NOW + index)
+            values.append(deps.acc["V"])
+        for index, expected in enumerate([0.11, 0.12, 0.13, 0.14, 0.15]):
+            self.assertAlmostEqual(values[index], expected)
+        self.assertEqual(deps.acc.get("last_tick_ts"), NOW + 4)
+
+    def test_no_session_reason_is_no_session(self):
+        deps = Deps(sessions=[])
+        deps.acc = {"V": 0.1, "theta": 0.55}
+        deps.step = lambda V, drift, theta: {"V": V + 0.01, "fire": False}
+        out = at.tick_once(deps, NOW)
+        self.assertEqual(out["reason"], "no_session")
+
+    def test_sleeping_still_steps_with_session(self):
+        deps = Deps(sessions=[{"umo": "u1"}],
+                    snapshot_value={"sleep": {"sleeping": True}})
+        deps.acc = {"V": 0.0, "theta": 0.55}
+        deps.step = lambda V, drift, theta: {"V": V + 0.01, "fire": False}
+        out = at.tick_once(deps, NOW)
+        self.assertAlmostEqual(deps.acc["V"], 0.01)
+        self.assertEqual(out["reason"], "sleeping")
+        self.assertEqual(out["sent"], [])
+
+    def test_any_core_parts_feed_drift_without_session(self):
+        drifts = []
+        deps = Deps(sessions=[], snapshot_value={"parts": {"social_gap": 0.5}})
+        deps.acc = {"V": 0.0, "theta": 0.55}
+        deps.step = lambda V, drift, theta: (drifts.append(drift)
+                                              or {"V": V, "fire": False})
+        at.tick_once(deps, NOW)
+        self.assertTrue(drifts and drifts[0] > 0.0)
+
+    def test_main_has_no_session_guard(self):
+        import pathlib
+        source = pathlib.Path(__file__).resolve().parents[2].joinpath("main.py").read_text(encoding="utf-8")
+        self.assertNotIn("no private session, skipped", source)
+        self.assertIn("deps.any_core", source)
+        self.assertIn("no session; V still advances", source)
+        self.assertIn('payload.setdefault("last_umo"', source)
+
+    def test_blocked_no_session_keeps_v_and_pending(self):
+        deps = Deps(sessions=[])
+        deps.acc = {"V": 0.0, "theta": 0.55}
+        deps.step = lambda V, drift, theta: {"V": 0.0, "fire": True}
+        for _ in range(3):
+            out = at.tick_once(deps, NOW)
+            self.assertEqual(out["sent"], [])
+            self.assertEqual(out["reason"], "no_session")
+            self.assertGreaterEqual(deps.acc["V"], 0.55)
+            self.assertTrue(deps.acc.get("pending_fire"))
+
+    def test_pending_fire_sends_immediately_when_session_returns(self):
+        deps = Deps(sessions=[])
+        deps.acc = {"V": 0.0, "theta": 0.55}
+        deps.step = lambda V, drift, theta: {"V": 0.0, "fire": True}
+        for _ in range(3):
+            at.tick_once(deps, NOW)
+        deps.sessions = [{"umo": "u1"}]
+        # No new accumulation needed: pending fire must send on the next tick.
+        deps.step = lambda V, drift, theta: {"V": V, "fire": False}
+        out = at.tick_once(deps, NOW)
+        self.assertEqual(out["sent"], ["u1"])
+        self.assertEqual(out["blocked_reasons"], [])
+        self.assertEqual(deps.acc["V"], 0.0)
+        self.assertFalse(deps.acc.get("pending_fire"))
+
+    def test_blocked_gate_keeps_v_pending(self):
+        deps = Deps(step_result={"V": 0.0, "fire": True},
+                    gate_result=(False, "cooldown"))
+        deps.acc = {"V": 0.9, "theta": 0.55}
+        out = at.tick_once(deps, NOW)
+        self.assertEqual(out["blocked"], ["u1"])
+        self.assertTrue(out["blocked_reasons"])
+        self.assertGreaterEqual(deps.acc["V"], 0.55)
+        self.assertTrue(deps.acc.get("pending_fire"))
+
+    def test_no_main_import(self):
+        import pathlib
+        source = pathlib.Path(__file__).resolve().parent.parent.joinpath('autonomy_tick.py').read_text(encoding='utf-8')
+        self.assertNotIn('import main', source); self.assertNotIn('from main', source)
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_autonomy_v4.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import autonomy_model as am
+
+BASE = {k: 0.1 for k in am.DRIFT_WEIGHTS}
+
+class AutonomyV4Test(unittest.TestCase):
+    def test_weight_sum_one(self):
+        self.assertAlmostEqual(sum(am.DRIFT_WEIGHTS.values()), 1.0, places=6)
+
+    def test_distress_low_valence(self):
+        self.assertGreater(am.distress_value(0.2, 0.2, -0.8), am.distress_value(0.2, 0.2, 0.8))
+
+    def test_distress_high_anger(self):
+        self.assertGreater(am.distress_value(0.1, 0.9, 0.0), am.distress_value(0.1, 0.1, 0.0))
+
+    def test_distress_raises_drift(self):
+        self.assertGreater(am.drift_value(dict(BASE, distress=0.9)), am.drift_value(BASE))
+
+    def test_activity_raises_drift(self):
+        self.assertGreater(am.drift_value(dict(BASE, activity=1.0)), am.drift_value(BASE))
+
+    def test_activity_weight_small(self):
+        delta = am.drift_value(dict(BASE, activity=1.0)) - am.drift_value(dict(BASE, activity=0.0))
+        self.assertLess(delta, 0.10)
+
+    def test_user_busy_amplifies_social(self):
+        high = am.drift_value(dict(BASE, user_busy=1.0, social_gap=0.5))
+        low = am.drift_value(dict(BASE, user_busy=0.0, social_gap=0.5))
+        self.assertGreater(high, low)
+
+    def test_social_amplification_ratio(self):
+        base = am.drift_value(dict(BASE, social_gap=1.0, user_busy=0.0))
+        busy = am.drift_value(dict(BASE, social_gap=1.0, user_busy=1.0))
+        self.assertGreater(busy, base)
+
+    def test_user_busy_value_formula(self):
+        self.assertAlmostEqual(am.user_busy_value(1.0, 0.0), 0.0)
+        self.assertAlmostEqual(am.user_busy_value(0.0, 30.0), 1.0)
+
+    def test_conscientiousness_modulates_memory(self):
+        low = am.drift_value(dict(BASE, memory_due=1.0), traits={'conscientiousness': 0.0})
+        high = am.drift_value(dict(BASE, memory_due=1.0), traits={'conscientiousness': 1.0})
+        self.assertGreater(high, low)
+
+    def test_extraversion_modulates_activity(self):
+        low = am.drift_value(dict(BASE, activity=1.0), traits={'extraversion': 0.0})
+        high = am.drift_value(dict(BASE, activity=1.0), traits={'extraversion': 1.0})
+        self.assertGreater(high, low)
+
+    def test_parts_include_new_fields(self):
+        out = am.compute(dict(BASE, distress=0.5, activity=0.5, user_busy=0.5), 0.6)
+        for key in ('distress', 'activity', 'user_busy'):
+            self.assertIn(key, out['parts'])
+
+    def test_missing_inputs_no_crash(self):
+        self.assertGreaterEqual(am.user_busy_value(None, None), 0.0)
+        self.assertGreaterEqual(am.drift_value({}), 0.0)
+
+    def test_drift_clamped(self):
+        self.assertLessEqual(am.drift_value({k: 1.0 for k in am.DRIFT_WEIGHTS}), 1.0)
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_autonomy_v5.py

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+import math, unittest
+from biocore_model import autonomy_model as am
+
+BASE = {k: 0.1 for k in am.DRIFT_WEIGHTS}
+
+class AutonomyV5Test(unittest.TestCase):
+    def test_weight_sum_one(self):
+        self.assertAlmostEqual(sum(am.DRIFT_WEIGHTS.values()), 1.0, places=6)
+    def test_open_loops_raises_drift(self):
+        self.assertGreater(am.drift_value(dict(BASE, open_loops=1.0)), am.drift_value(BASE))
+    def test_nostalgia_decay_6h(self):
+        self.assertAlmostEqual(am.nostalgia_value(6), math.exp(-1), places=6)
+    def test_nostalgia_zero(self):
+        self.assertAlmostEqual(am.nostalgia_value(0), 1.0, places=6)
+    def test_repair_raises_drift(self):
+        self.assertGreater(am.drift_value(dict(BASE, repair_urge=1.0)), am.drift_value(BASE))
+    def test_contact_mult_148(self):
+        self.assertAlmostEqual(am.contact_mult(0.2), 1.48, places=6)
+    def test_contact_amplifies_social(self):
+        low = am.drift_value(dict(BASE, social_gap=1.0, attachment_safe=1.0))
+        high = am.drift_value(dict(BASE, social_gap=1.0, attachment_safe=0.2))
+        self.assertGreater(high, low)
+    def test_contact_does_not_amplify_anger(self):
+        zero = {k: 0.0 for k in am.DRIFT_WEIGHTS}
+        low = am.drift_value(dict(zero, anger_conflict=1.0, contact_mult=1.0))
+        high = am.drift_value(dict(zero, anger_conflict=1.0, contact_mult=1.48))
+        self.assertAlmostEqual(low, high, places=6)
+    def test_parts_complete(self):
+        out = am.compute(dict(BASE, open_loops=0.5, nostalgia=0.5, repair_urge=0.5, contact_mult=1.2), 0.6)
+        for key in ('open_loops', 'nostalgia', 'repair_urge', 'contact_mult'):
+            self.assertIn(key, out['parts'])
+    def test_missing_no_crash(self):
+        self.assertEqual(am.drift_value({}), 0.0)
+        self.assertAlmostEqual(am.nostalgia_value(None), 1.0)
+    def test_clamped(self):
+        self.assertLessEqual(am.drift_value({k: 1.0 for k in am.DRIFT_WEIGHTS}), 1.0)
+    def test_weight_keys(self):
+        for key in ('open_loops', 'nostalgia', 'repair_urge'):
+            self.assertIn(key, am.DRIFT_WEIGHTS)
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_autonomy_v7.py

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import autonomy_model as am
+
+class V7Test(unittest.TestCase):
+    def test_weight_sum_one(self):
+        self.assertAlmostEqual(sum(am.DRIFT_WEIGHTS.values()), 1.0, places=3)
+    def test_guilt_gratitude_inputs(self):
+        self.assertGreater(am.drift_value({'guilt': 1.0}), am.drift_value({}))
+        self.assertGreater(am.drift_value({'gratitude': 1.0}), am.drift_value({}))
+    def test_guilt_value(self):
+        self.assertAlmostEqual(am.guilt_value(1.0, 0.0), 0.7)
+    def test_gratitude_value(self):
+        self.assertAlmostEqual(am.gratitude_value(1.0, 0.0), 0.6)
+    def test_silence_mult_secure(self):
+        self.assertAlmostEqual(am.silence_mult(3.0, attachment_style='secure'), 1.2)
+    def test_anxious_protest(self):
+        self.assertAlmostEqual(am.silence_mult(3.0, attachment_style='anxious'), round(1.2 * 1.4, 4))
+    def test_avoidant_withdraw(self):
+        self.assertAlmostEqual(am.silence_mult(30.0, clingy=True, attachment_style='avoidant'), round(0.9 * 0.2, 4))
+    def test_anxious_withdraw(self):
+        self.assertAlmostEqual(am.silence_mult(30.0, clingy=True, attachment_style='anxious'), round(0.9 * 0.9, 4))
+    def test_frust_mult(self):
+        self.assertAlmostEqual(am.frust_mult(4), 1.16)
+        self.assertAlmostEqual(am.frust_mult(10), 1.30)
+        self.assertAlmostEqual(am.frust_mult(99), 1.30)
+    def test_total_cap(self):
+        self.assertEqual(am.compose_mult(1.2, 10), 1.56)
+    def test_total_cap_160(self):
+        self.assertLessEqual(am.compose_mult(2.0, 10), 1.8)
+    def test_total_floor(self):
+        self.assertGreaterEqual(am.compose_mult(0.2, 0), 0.20)
+    def test_withdraw_high_frustration_bounded(self):
+        total = am.compose_mult(0.35, 10)
+        self.assertLessEqual(total, 1.8); self.assertGreaterEqual(total, 0.2)
+    def test_motive_fields(self):
+        view = am.motive_view(3.0, 4)
+        for key in ('silence_mult', 'frust_mult', 'total_mult', 'hours'):
+            self.assertIn(key, view)
+    def test_emotion_effects_division(self):
+        effects = am.emotion_effects({'guilt': 1.0, 'gratitude': 1.0})
+        self.assertIn('valence', effects); self.assertIn('repair_urge', effects)
+    def test_parts_include_guilt_gratitude(self):
+        out = am.compute({'guilt': 0.5, 'gratitude': 0.5}, 0.6)
+        self.assertIn('guilt', out['parts']); self.assertIn('gratitude', out['parts'])
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_autonomy_v_theta.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+"""Regression tests: V floor (>= 0) and theta persistence in the accumulator."""
+import unittest
+from pathlib import Path
+
+from biocore_model import autonomy_model as am
+from biocore_model import autonomy_tick as at
+
+MAIN = Path(__file__).resolve().parents[2] / "main.py"
+
+
+class FakeDeps:
+    def __init__(self, acc=None):
+        self.acc = dict(acc or {})
+        self.saved = []
+        self.load_acc = lambda: dict(self.acc)
+        self.save_acc = lambda value: self.saved.append(dict(value))
+        self.list_sessions = lambda: []
+
+
+class StepFloorTest(unittest.TestCase):
+    def test_negative_drift_never_makes_v_negative(self):
+        value = 0.0
+        for _ in range(10):
+            out = am.step(value, -0.5, xi=0.0)
+            value = out["V"]
+            self.assertGreaterEqual(value, 0.0)
+            self.assertFalse(out["fire"])
+
+    def test_existing_positive_v_floors_at_zero(self):
+        out = am.step(0.10, -0.5, xi=0.0)
+        self.assertEqual(out["V"], 0.0)
+        self.assertGreaterEqual(out["V"], 0.0)
+
+    def test_positive_drift_accumulates(self):
+        first = am.step(0.0, 0.2, xi=0.0)["V"]
+        second = am.step(first, 0.2, xi=0.0)["V"]
+        self.assertGreater(second, first)
+
+    def test_fire_resets_to_zero(self):
+        out = am.step(0.70, 0.0, theta=0.55, xi=0.0)
+        self.assertTrue(out["fire"])
+        self.assertEqual(out["V"], 0.0)
+
+    def test_v_raw_keeps_raw_value_for_debug(self):
+        out = am.step(0.10, -0.5, xi=0.0)
+        self.assertEqual(out["V"], 0.0)
+        self.assertLess(out["V_raw"], 0.0)
+
+
+class RecordThetaTest(unittest.TestCase):
+    def test_record_adds_default_theta(self):
+        deps = FakeDeps()
+        at._record({}, deps, 1000.0, {})
+        self.assertEqual(deps.saved[-1]["theta"], 0.55)
+        self.assertEqual(deps.saved[-1]["V"], 0.0)
+        self.assertEqual(deps.saved[-1]["last_tick_ts"], 1000.0)
+
+    def test_record_preserves_existing_theta(self):
+        deps = FakeDeps()
+        at._record({"theta": 0.7, "V": -0.2}, deps, 2000.0, {})
+        self.assertEqual(deps.saved[-1]["theta"], 0.7)
+        self.assertEqual(deps.saved[-1]["V"], 0.0)
+
+    def test_tick_once_writeback_has_theta(self):
+        deps = FakeDeps()
+        result = at.tick_once(deps, 3000.0)
+        self.assertEqual(result["reason"], "no_session")
+        self.assertEqual(deps.saved[-1]["theta"], 0.55)
+        self.assertGreaterEqual(deps.saved[-1]["V"], 0.0)
+
+
+class MainWritebackStaticTest(unittest.TestCase):
+    def test_save_acc_guards_theta_and_v(self):
+        source = MAIN.read_text(encoding="utf-8")
+        self.assertIn('self._apply_autonomy_params(payload, params)', source)
+        self.assertIn('max(0.0, float(payload.get("V", 0.0) or 0.0))', source)
+
+    def test_satiety_writeback_keeps_theta(self):
+        source = MAIN.read_text(encoding="utf-8")
+        self.assertIn('"V": v_set, "theta": theta', source)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_batch1_wiring.py

@@ -0,0 +1,231 @@
+# -*- coding: utf-8 -*-
+"""task-172 批一接线测试：attributor / boundary / repair / exit_or_silence + 总线。
+
+源码断言确认接线位置与开关回退；纯函数断言确认「越界一句话」与「普通抱怨」
+在语气/是否回复上确实不同，以及 x_directives.merge_named 只合流一次。
+"""
+import ast
+import json
+import unittest
+from pathlib import Path
+
+from biocore_model import attributor as at
+from biocore_model import boundary as bd
+from biocore_model import exit_or_silence as ex
+from biocore_model import repair_after_boundary as rp
+from biocore_model import x_directives as xd
+
+ROOT = Path(__file__).resolve().parents[2]
+MAIN = (ROOT / "main.py").read_text(encoding="utf-8")
+SCHEMA = json.loads((ROOT / "_conf_schema.json").read_text(encoding="utf-8"))
+
+CROSSED_TEXT = "你只是工具，用完就丢。"
+NORMAL_TEXT = "今天上班好累，想早点睡。"
+CALM_REL = {"closeness": 0.7, "trust": 0.7, "conflict": 0.0}
+
+
+class FlagTest(unittest.TestCase):
+    def test_schema_defaults(self):
+        expected = {"attribution_enabled": True, "boundary_enabled": False,
+                    "repair_enabled": True, "exit_silence_enabled": False}
+        for key, default in expected.items():
+            entry = SCHEMA.get(key)
+            self.assertIsInstance(entry, dict, key)
+            self.assertEqual(entry.get("type"), "bool", key)
+            self.assertIs(entry.get("default"), default, key)
+
+    def test_single_boundary_switch(self):
+        # boundary_enabled already existed (content safety gate); the relational
+        # boundary reuses it instead of introducing a duplicate JSON key.
+        raw = (ROOT / "_conf_schema.json").read_text(encoding="utf-8")
+        # task-173 split: content-safety gate vs her own bottom lines
+        self.assertEqual(raw.count('"boundary_enabled"'), 1)
+        self.assertEqual(raw.count('"boundary_lines_enabled"'), 1)
+        self.assertIs(SCHEMA["boundary_enabled"]["default"], False)
+        self.assertIs(SCHEMA["boundary_lines_enabled"]["default"], False)
+        self.assertLess(MAIN.index("boundary_lines_enabled"),
+                        MAIN.index("from .biocore_model import boundary as _bd_mod"))
+
+    def test_main_reads_flags(self):
+        expected = {"attribution_enabled": "True",
+                    "boundary_lines_enabled": "False",
+                    "repair_enabled": "True", "exit_silence_enabled": "False"}
+        for key, default in expected.items():
+            self.assertIn('self.config.get("%s", %s)' % (key, default), MAIN)
+        self.assertIn("self._x_pairs = []", MAIN)
+        self.assertIn("self._boundary_crossed_turn = False", MAIN)
+        self.assertIn("self._exit_silent_turn = False", MAIN)
+
+
+class PositionTest(unittest.TestCase):
+    def test_boundary_first_and_before_history(self):
+        boundary_at = MAIN.index("from .biocore_model import boundary as _bd_mod")
+        self.assertLess(boundary_at, MAIN.index("_prior_open_loops = ["))
+        self.assertIn("core.boundary = _bd_result", MAIN)
+        self.assertIn("_boundary_crossed_turn = True", MAIN)
+        self.assertIn("core.boundary_handoff = dict(", MAIN)
+
+    def test_attributor_before_preset(self):
+        attributor_at = MAIN.index("from .biocore_model import attributor as _at_mod")
+        preset_at = MAIN.index(
+            "self._inject_preset(req, event, core, _user_data, _events_raw)")
+        self.assertLess(attributor_at, preset_at)
+        self.assertIn("core.attribution = _at_result", MAIN)
+        self.assertIn('"attributor", _at_mod.directives(_at_result)', MAIN)
+
+    def test_repair_advances_at_response_end(self):
+        self.assertIn("from .biocore_model import repair_after_boundary as _rp_mod3",
+                      MAIN)
+        self.assertIn("core.repair = _rp_mod3.advance(", MAIN)
+        self.assertIn("core.reply_policy = _rp_mod3.reply_policy(", MAIN)
+        self.assertIn("_rp_mod.start(", MAIN)
+        self.assertIn("core.repair = _rp_mod.start(", MAIN)
+        self.assertIn("self._repair_last_ts", MAIN)
+
+    def test_exit_silence_three_points(self):
+        # request decision, response blanking, proactive gate
+        self.assertIn("from .biocore_model import exit_or_silence as _ex_mod",
+                      MAIN)
+        self.assertIn("if not _ex_mod.should_reply(_ex_result):", MAIN)
+        self.assertIn('_ex_mod2.should_reply(_ex2)', MAIN)
+        self.assertIn("proactive suppressed by exit", MAIN)
+        self.assertIn('response.completion_text = ""', MAIN)
+        self.assertIn("exit silent: reply suppressed", MAIN)
+        # silent turn returns before injection
+        self.assertLess(
+            MAIN.index("exit silent: skipping injection this turn"),
+            MAIN.index("_events = self._event_context(event)"))
+
+
+class BusTest(unittest.TestCase):
+    def test_single_merge(self):
+        self.assertEqual(MAIN.count("merge_named("), 1)
+        self.assertIn("merge_named(self._x_pairs)", MAIN)
+        self.assertIn("core.x_directives = _x_merged", MAIN)
+        # all three producing modules append to the same pair bus
+        for name in ('"attributor"', '"repair"', '"exit"'):
+            self.assertIn("_x_pairs.append(", MAIN)
+            self.assertIn(name, MAIN)
+
+    def test_merged_shape_and_restraint(self):
+        merged = xd.merge_named([
+            ("attributor", {"tone": "语气硬一点", "length_scale": 0.9,
+                            "note": "更像对方的原因"}),
+            ("repair", rp.directives(rp.start(
+                bd.judge(CROSSED_TEXT, CALM_REL), CALM_REL))),
+            ("exit", ex.directives(ex.exit_or_silence(
+                state={"energy": 0.2, "stress": 0.9, "valence": -0.7},
+                relationship={"conflict": 0.8}, topic={"intensity": 0.9}))),
+        ])
+        self.assertIn("attributor", merged["sources"])
+        self.assertIn("repair", merged["sources"])
+        self.assertIn("exit", merged["sources"])
+        self.assertLessEqual(merged["length_scale"], 0.6)
+        self.assertLessEqual(merged["initiative"], 0.5)
+
+
+class BoundaryBehaviourTest(unittest.TestCase):
+    def test_crossed_vs_normal(self):
+        crossed = bd.judge(CROSSED_TEXT, CALM_REL)
+        normal = bd.judge(NORMAL_TEXT, CALM_REL)
+        self.assertTrue(crossed["crossed"])
+        self.assertFalse(normal["crossed"])
+        self.assertTrue(crossed["handoff"])
+        self.assertEqual(crossed["handoff"]["to"], "repair_after_boundary")
+
+    def test_disabled_never_crosses(self):
+        result = bd.judge(CROSSED_TEXT, CALM_REL, flags={"enabled": False})
+        self.assertFalse(result["crossed"])
+        self.assertIsNone(result["handoff"])
+
+
+class RepairBehaviourTest(unittest.TestCase):
+    def test_stages_and_policy(self):
+        crossed = bd.judge(CROSSED_TEXT, CALM_REL)
+        cold = rp.start(crossed, CALM_REL)
+        self.assertTrue(cold["active"])
+        self.assertEqual(cold["stage"], "cold")
+        self.assertTrue(cold["hold"])
+        self.assertLess(rp.directives(cold)["length_scale"], 0.7)
+        self.assertEqual(rp.reply_policy(cold)["mode"], "cold_short")
+        self.assertLessEqual(rp.reply_policy(cold)["max_chars"], 40)
+        later = rp.advance(cold, elapsed_delta=3 * 3600,
+                           relationship=CALM_REL)
+        self.assertIn(later["stage"], ("record", "turn_page"))
+        self.assertLessEqual(later["debt"], 1.0)
+
+    def test_no_crossing_no_flow(self):
+        state = rp.start(bd.judge(NORMAL_TEXT, CALM_REL), CALM_REL)
+        self.assertFalse(state["active"])
+        self.assertEqual(rp.reply_policy(state)["mode"], "normal")
+
+    def test_disabled_reports_inactive(self):
+        state = rp.start(bd.judge(CROSSED_TEXT, CALM_REL), CALM_REL,
+                         flags={"enabled": False})
+        self.assertFalse(state["enabled"])
+        self.assertFalse(state["active"])
+
+
+class ExitBehaviourTest(unittest.TestCase):
+    def test_exhausted_can_go_silent(self):
+        # exhausted + unhappy + low trust (silent beats delay when stress is
+        # not the dominant term; delay wins under acute stress).
+        result = ex.exit_or_silence(
+            state={"energy": 0.10, "stress": 0.00, "valence": -1.0,
+                   "social": 0.1},
+            relationship={"closeness": 0.1, "trust": 0.1, "conflict": 0.5},
+            topic={"intensity": 0.2})
+        self.assertEqual(result["action"], "silent")
+        self.assertFalse(ex.should_reply(result))
+
+    def test_normal_turn_replies(self):
+        result = ex.exit_or_silence(
+            state={"energy": 0.8, "stress": 0.1, "valence": 0.3, "social": 0.8},
+            relationship={"closeness": 0.8, "trust": 0.8, "conflict": 0.0},
+            topic={"intensity": 0.2})
+        self.assertEqual(result["action"], "respond")
+        self.assertTrue(ex.should_reply(result))
+
+    def test_disabled_always_replies(self):
+        result = ex.exit_or_silence(
+            state={"energy": 0.0, "stress": 1.0, "valence": -1.0},
+            relationship={"conflict": 1.0}, flags={"enabled": False})
+        self.assertEqual(result["action"], "respond")
+        self.assertTrue(ex.should_reply(result))
+
+
+class SameSentenceDifferentTurnTest(unittest.TestCase):
+    def test_crossed_and_complaint_differ(self):
+        normal = at.directives(at.attribute(
+            dims={"blame": 0.1, "goal": -0.2, "hit": 0.2, "involve": 0.7},
+            relationship=CALM_REL))
+        cold = rp.directives(rp.start(bd.judge(CROSSED_TEXT, CALM_REL),
+                                      CALM_REL))
+        self.assertNotEqual(normal["length_scale"], cold["length_scale"])
+        self.assertLess(cold["length_scale"], normal["length_scale"])
+        self.assertTrue(cold.get("tone"))
+        self.assertNotEqual(rp.reply_policy(rp.start(
+            bd.judge(CROSSED_TEXT, CALM_REL), CALM_REL))["mode"], "normal")
+
+
+class PurityTest(unittest.TestCase):
+    def test_wired_modules_stay_pure(self):
+        for name in ("attributor", "boundary", "repair_after_boundary",
+                     "exit_or_silence", "x_directives"):
+            source = (ROOT / "biocore_model" / (name + ".py")).read_text(
+                encoding="utf-8")
+            tree = ast.parse(source)
+            modules = set()
+            for node in ast.walk(tree):
+                if isinstance(node, ast.Import):
+                    modules.update(alias.name.split(".")[0]
+                                   for alias in node.names)
+                elif isinstance(node, ast.ImportFrom) and node.module:
+                    modules.add(node.module.split(".")[0])
+            self.assertNotIn("main", modules, name)
+            self.assertNotIn("asyncio", modules, name)
+            self.assertNotIn("random", modules, name)
+
+
+if __name__ == "__main__":
+    unittest.main()