dsh-biocore 0.2.0 → 0.3.1

package/python/biocore_model/tests/test_autonomy_caps.py

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import autonomy_model as am
+
+class CapsTest(unittest.TestCase):
+    def test_daily3_hourly1(self):
+        self.assertEqual(am.derive_hourly_cap(3), 1)
+    def test_daily5_hourly2(self):
+        self.assertEqual(am.derive_hourly_cap(5), 2)
+    def test_daily9_hourly3(self):
+        self.assertEqual(am.derive_hourly_cap(9), 3)
+    def test_daily20_hourly7(self):
+        self.assertEqual(am.derive_hourly_cap(20), 7)
+    def test_daily1_hourly1(self):
+        self.assertEqual(am.derive_hourly_cap(1), 1)
+    def test_clamp_daily(self):
+        self.assertEqual(am.daily_cap_value(99), 20); self.assertEqual(am.daily_cap_value(0), 1)
+    def test_default(self):
+        self.assertEqual(am.daily_cap_value(None), 5)
+    def test_effective_caps(self):
+        self.assertEqual(am.effective_caps(5), {'daily_cap': 5, 'hourly_cap': 2})
+    def test_legacy_hourly_override(self):
+        self.assertEqual(am.effective_caps(5, legacy_hourly=4)['hourly_cap'], 4)
+    def test_limit_view_has_caps(self):
+        view = am.limit_view({}, 2, 1_700_000_000, daily_cap=5)
+        self.assertEqual(view['hourly_cap'], 2); self.assertEqual(view['daily_cap'], 5)
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_autonomy_check.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+import time, unittest
+from biocore_model import autonomy_check as ac
+
+BASE = {"enabled": True, "ready": True, "impulse": 0.9, "threshold": 0.6,
+        "last_sent_ts": 0, "sent_count": 0, "sent_day": "", "cooldown_seconds": 3600, "daily_cap": 3}
+
+class AutonomyCheckTest(unittest.TestCase):
+    def test_ready(self):
+        self.assertEqual(ac.reason(dict(BASE), True, True, now=time.mktime((2026, 1, 1, 12, 0, 0, 0, 1, -1))), "ready")
+
+    def test_not_private(self):
+        self.assertEqual(ac.reason(dict(BASE), False, True), "not_private")
+
+    def test_no_session(self):
+        self.assertEqual(ac.reason(dict(BASE), True, False), "no_session")
+
+    def test_not_ready(self):
+        self.assertEqual(ac.reason(dict(BASE, ready=False)), "not_ready")
+        self.assertEqual(ac.reason(dict(BASE, impulse=0.1)), "not_ready")
+
+    def test_cooldown(self):
+        now = time.mktime((2026, 1, 1, 12, 0, 0, 0, 1, -1))
+        self.assertEqual(ac.reason(dict(BASE, last_sent_ts=now - 10), True, True, now=now), "cooldown")
+
+    def test_daily_cap(self):
+        now = time.mktime((2026, 1, 1, 12, 0, 0, 0, 1, -1))
+        day = time.strftime("%Y-%m-%d", time.localtime(now))
+        self.assertEqual(ac.reason(dict(BASE, sent_day=day, sent_count=3), True, True, now=now), "daily_cap")
+
+    def test_snapshot_fields(self):
+        snap = ac.snapshot(dict(BASE, impulse_ema=0.5, max_chars=120, last_sent_ts=1.0))
+        self.assertIn("impulse", snap); self.assertIn("max_chars", snap)
+
+    def test_chinese_mapping(self):
+        for code in ("ready", "not_ready", "cooldown", "daily_cap", "quiet_hours", "no_session", "not_private"):
+            self.assertTrue(ac.reason_text(code))
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_autonomy_clingy.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+import random, unittest
+from biocore_model import autonomy_model as am
+
+NOW = 1_700_000_000
+
+class ClingyTest(unittest.TestCase):
+    def test_withdraw_clingy(self):
+        self.assertAlmostEqual(am.silence_phase(30, True)['drive_mult'], 0.90)
+    def test_withdraw_fallback(self):
+        self.assertAlmostEqual(am.silence_phase(30, False)['drive_mult'], 0.35)
+    def test_other_phases(self):
+        self.assertAlmostEqual(am.silence_phase(1, True)['drive_mult'], 1.00)
+        self.assertAlmostEqual(am.silence_phase(3, True)['drive_mult'], 1.20)
+        self.assertAlmostEqual(am.silence_phase(10, True)['drive_mult'], 0.80)
+    def test_retry_allowed(self):
+        self.assertTrue(am.withdraw_retry_allowed(NOW - 7 * 3600, NOW))
+    def test_retry_blocked(self):
+        self.assertFalse(am.withdraw_retry_allowed(NOW - 2 * 3600, NOW))
+    def test_burst_probability(self):
+        rng = random.Random(0)
+        hits = sum(1 for _ in range(2000) if am.clingy_burst(rng))
+        self.assertGreater(hits / 2000, 0.10); self.assertLess(hits / 2000, 0.30)
+    def test_burst_zero(self):
+        self.assertFalse(am.clingy_burst(random.Random(1), p=0.0))
+    def test_burst_one(self):
+        self.assertTrue(am.clingy_burst(random.Random(1), p=1.0))
+    def test_view_multiplier_on_burst(self):
+        view = am.silence_view(NOW - 30 * 3600, 0, NOW, clingy=True, rng=random.Random(0))
+        if view['burst']:
+            self.assertAlmostEqual(view['effective_mult'], round(view['drive_mult'] * 1.5, 4))
+    def test_view_fields(self):
+        view = am.silence_view(NOW - 3 * 3600, 0, NOW, clingy=True)
+        for key in ('hours', 'phase', 'drive_mult', 'burst', 'clingy', 'effective_mult'):
+            self.assertIn(key, view)
+    def test_status_keeps_clingy(self):
+        snap = am.status_snapshot({'silence': {'phase': 'withdraw', 'clingy': True, 'burst': True}})
+        self.assertTrue(snap['silence']['clingy'])
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_autonomy_cooldown_selfcontact.py

@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*-
+"""Cooldown/daily-cap gating + post-send self-contact loneliness damping."""
+import ast
+import time
+import types
+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"
+NOW = 1_800_000_000.0
+
+
+def _load(name):
+    tree = ast.parse(MAIN.read_text(encoding="utf-8"))
+    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 == name)
+    ns = {"time": time}
+    exec(compile(ast.Module(body=[node], type_ignores=[]), "<a>", "exec"), ns)
+    return ns[name]
+
+
+class ParamsTest(unittest.TestCase):
+    def test_apply_forces_cooldown_and_cap(self):
+        fn = _load("_apply_autonomy_params")
+        plugin = types.SimpleNamespace()
+        out = fn(plugin, {}, {"theta": 0.52, "cooldown_s": 1625,
+                              "daily_cap": 3})
+        self.assertEqual(out["cooldown_seconds"], 1625)
+        self.assertEqual(out["daily_cap"], 3)
+
+
+class GateTest(unittest.TestCase):
+    def test_cooldown_rejects_five_minutes(self):
+        fn = _load("_autonomy_gate_limits")
+        ok, why = fn(types.SimpleNamespace(), {"last_sent_ts": NOW - 300},
+                     NOW, cooldown_seconds=1625)
+        self.assertFalse(ok)
+        self.assertEqual(why, "cooldown")
+
+    def test_cooldown_allows_after_30_minutes(self):
+        fn = _load("_autonomy_gate_limits")
+        ok, why = fn(types.SimpleNamespace(), {"last_sent_ts": NOW - 2000},
+                     NOW, cooldown_seconds=1625)
+        self.assertTrue(ok, why)
+
+    def test_daily_cap_blocks(self):
+        fn = _load("_autonomy_gate_limits")
+        day = time.strftime("%Y-%m-%d", time.localtime(NOW))
+        ok, why = fn(types.SimpleNamespace(), {
+            "sent_day": day, "sent_count": 3}, NOW, daily_cap=3)
+        self.assertFalse(ok)
+        self.assertEqual(why, "daily_cap")
+
+
+class Core:
+    def snapshot(self):
+        return {"a": 0.4, "energy": 0.5, "stress": 0.2}
+
+    labels = {"emotion": "neutral", "intensity": 0.0}
+
+
+class PartsTest(unittest.TestCase):
+    def test_self_contact_resets_gap(self):
+        acc = {"last_user_msg_ts": NOW - 10 * 3600,
+               "last_self_contact_ts": NOW - 100}
+        parts = am.parts_from_state(Core(), {}, now=NOW, acc=acc,
+                                    params={"silence_tau_hours": 2.0,
+                                            "social_tau_hours": 18.0})
+        self.assertLess(parts["lonely"], 0.2)
+
+    def test_lonely_damped_within_30_minutes(self):
+        base = am.parts_from_state(Core(), {}, now=NOW,
+                                   acc={"last_user_msg_ts": NOW - 5 * 3600,
+                                        "last_self_contact_ts": NOW - 3600},
+                                   params={"silence_tau_hours": 2.0})
+        damped = am.parts_from_state(Core(), {}, now=NOW,
+                                     acc={"last_user_msg_ts": NOW - 5 * 3600,
+                                          "last_self_contact_ts": NOW - 1},
+                                     params={"silence_tau_hours": 2.0})
+        self.assertLess(damped["lonely"], base["lonely"])
+
+
+class SendBookkeepingTest(unittest.TestCase):
+    def test_send_records_self_contact_and_sent_count(self):
+        class Deps:
+            def __init__(self):
+                self.acc = {"V": 1.0, "theta": 0.55, "pending_fire": True}
+                self.sent = []
+
+            def load_acc(self):
+                return dict(self.acc)
+
+            def save_acc(self, acc):
+                self.acc = dict(acc)
+
+            def list_sessions(self):
+                return [{"umo": "u1"}]
+
+            def get_core(self, umo):
+                return Core()
+
+            def any_core(self):
+                return Core()
+
+            def snapshot(self, core):
+                return {}
+
+            def params(self):
+                return {"theta": 0.55}
+
+            def step(self, V, drift, theta):
+                return {"V": V, "fire": True}
+
+            def gate(self, core, acc, silence, now):
+                return True, "fired"
+
+            def build_text(self, core, acc):
+                return "在。"
+
+            def send_text(self, umo, text):
+                self.sent.append(umo)
+                return True
+
+        deps = Deps()
+        out = at.tick_once(deps, NOW)
+        self.assertEqual(out["sent"], ["u1"])
+        self.assertEqual(deps.acc["last_self_contact_ts"], NOW)
+        self.assertEqual(deps.acc["V"], 0.0)
+        self.assertEqual(deps.acc["sent_count"], 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_autonomy_frustration.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import autonomy_model as am
+
+NOW = 1_700_000_000
+
+class FrustrationTest(unittest.TestCase):
+    def test_frustration_increments(self):
+        out = am.block_feedback({'frustration': 0}, NOW)
+        self.assertEqual(out['acc']['frustration'], 1); self.assertAlmostEqual(out['drive_mult'], 1.04)
+    def test_drive_mult_after_four(self):
+        out = am.block_feedback({'frustration': 3}, NOW)
+        self.assertAlmostEqual(out['drive_mult'], 1.16)
+    def test_drive_mult_cap_130(self):
+        out = am.block_feedback({'frustration': 10}, NOW)
+        self.assertAlmostEqual(out['drive_mult'], 1.30)
+    def test_cap_after_12_blocks(self):
+        acc = {}
+        for _ in range(12):
+            out = am.block_feedback(acc, NOW)
+            acc = out['acc']
+        self.assertAlmostEqual(out['drive_mult'], 1.30)
+    def test_emotion_directions(self):
+        out = am.block_feedback({}, NOW)
+        self.assertGreater(out['stress'], 0); self.assertGreater(out['arousal'], 0); self.assertEqual(out['valence'], 0.0)  # v7: limits only touch stress/arousal
+    def test_no_v_decay_field(self):
+        self.assertNotIn('drive_scale', am.block_feedback({}, NOW))
+    def test_clear_on_success(self):
+        acc = am.clear_frustration({'frustration': 5, 'drive_mult': 1.15})
+        self.assertEqual(acc['frustration'], 0); self.assertAlmostEqual(acc['drive_mult'], 1.0)
+    def test_window_reset_clears_frustration(self):
+        acc = am.hourly_window({'hour_window_start': NOW - 3700, 'frustration': 4, 'drive_mult': 1.12}, NOW)
+        self.assertEqual(acc['frustration'], 0)
+    def test_limit_view_fields(self):
+        view = am.limit_view({'frustration': 4, 'drive_mult': 1.12}, 3, NOW)
+        self.assertEqual(view['frustration'], 4); self.assertAlmostEqual(view['drive_mult'], 1.12)
+    def test_counters_still_count(self):
+        out = am.block_feedback({'blocked_count': 6}, NOW)
+        self.assertEqual(out['total_blocked'], 7); self.assertEqual(out['acc']['hour_blocked_count'], 1)
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_autonomy_hourly_limit.py

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+import time, unittest
+from biocore_model import autonomy_model as am
+
+NOW = 1_700_000_000
+
+class HourlyLimitTest(unittest.TestCase):
+    def test_under_cap_allowed(self):
+        ok, acc, cap = am.hourly_allowed({'hour_sent_count': 2}, NOW, 3)
+        self.assertTrue(ok); self.assertEqual(cap, 3)
+    def test_cap_reached_blocked(self):
+        ok, _, _ = am.hourly_allowed({'hour_sent_count': 3}, NOW, 3)
+        self.assertFalse(ok)
+    def test_window_roll_resets(self):
+        acc = am.hourly_window({'hour_window_start': NOW - 3700, 'hour_sent_count': 3, 'hour_blocked_count': 2}, NOW)
+        self.assertEqual(acc['hour_sent_count'], 0); self.assertEqual(acc['hour_blocked_count'], 0)
+    def test_window_not_reset_within_hour(self):
+        acc = am.hourly_window({'hour_window_start': NOW - 100, 'hour_sent_count': 2}, NOW)
+        self.assertEqual(acc['hour_sent_count'], 2)
+    def test_block_feedback_counters(self):
+        out = am.block_feedback({'blocked_count': 6}, NOW)
+        self.assertEqual(out['total_blocked'], 7); self.assertEqual(out['acc']['hour_blocked_count'], 1)
+    def test_block_feedback_emotion_deltas(self):
+        out = am.block_feedback({}, NOW)
+        self.assertGreater(out['stress'], 0); self.assertEqual(out['valence'], 0.0); self.assertGreater(out['drive_mult'], 1.0)
+    def test_clingy_retry_always_allowed(self):
+        self.assertTrue(am.withdraw_retry_allowed(NOW - 60, NOW, clingy=True))
+    def test_non_clingy_retry_waits_6h(self):
+        self.assertFalse(am.withdraw_retry_allowed(NOW - 60, NOW, clingy=False))
+        self.assertTrue(am.withdraw_retry_allowed(NOW - 7 * 3600, NOW, clingy=False))
+    def test_limit_view_fields(self):
+        view = am.limit_view({'hour_sent_count': 2, 'hour_blocked_count': 5, 'blocked_count': 9}, 3, NOW)
+        for key in ('hourly_cap', 'hour_sent', 'hour_blocked', 'total_blocked', 'window_reset_in'):
+            self.assertIn(key, view)
+    def test_limit_view_values(self):
+        view = am.limit_view({'hour_sent_count': 2, 'hour_blocked_count': 5, 'blocked_count': 9}, 3, NOW)
+        self.assertEqual(view['hour_sent'], 2); self.assertEqual(view['hour_blocked'], 5); self.assertEqual(view['total_blocked'], 9)
+    def test_cap_clamped(self):
+        ok, _, cap = am.hourly_allowed({}, NOW, 99)
+        self.assertEqual(cap, 12)
+    def test_status_snapshot_includes_limit(self):
+        snap = am.status_snapshot({'limit': {'hour_sent': 1, 'hourly_cap': 3}})
+        self.assertIn('limit', snap)
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_autonomy_loop.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import autonomy_loop as loop
+
+NOW = 1_700_000_000
+
+class LoopTest(unittest.TestCase):
+    def test_record_attempt(self):
+        acc = loop.record_attempt({}, NOW, 'lonely', 0.4, 12)
+        self.assertEqual(acc['sent_count'], 1); self.assertEqual(acc['last_attempt']['code'], 'lonely')
+    def test_quick_reply_counts(self):
+        acc = loop.record_attempt({}, NOW, 'lonely', 0.4, 10)
+        acc = loop.on_user_reply(acc, NOW + 600)
+        self.assertEqual(acc['responded_count'], 1); self.assertAlmostEqual(acc['last_response_latency_s'], 600.0)
+    def test_late_reply_not_counted(self):
+        acc = loop.record_attempt({}, NOW)
+        acc = loop.on_user_reply(acc, NOW + 7 * 3600)
+        self.assertEqual(acc.get('responded_count', 0), 0)
+    def test_settle_ignored(self):
+        acc = loop.record_attempt({}, NOW)
+        acc = loop.settle(acc, NOW + 7 * 3600)
+        self.assertEqual(acc['ignored_count'], 1); self.assertTrue(acc['last_attempt']['closed'])
+    def test_settle_recent_not_ignored(self):
+        acc = loop.record_attempt({}, NOW)
+        acc = loop.settle(acc, NOW + 60)
+        self.assertEqual(acc.get('ignored_count', 0), 0)
+    def test_response_rate(self):
+        self.assertAlmostEqual(loop.response_rate({'responded_count': 5, 'ignored_count': 7}), round(5/12, 4))
+    def test_rate_empty(self):
+        self.assertEqual(loop.response_rate({}), 0.0)
+    def test_per_code_ewma_up(self):
+        learning = loop.per_code_stats({}, 'lonely', True)
+        self.assertGreater(learning['per_code']['lonely']['rate'], 0.5)
+    def test_per_code_ewma_down(self):
+        learning = loop.per_code_stats({}, 'lonely', False)
+        self.assertLess(learning['per_code']['lonely']['rate'], 0.5)
+    def test_tune_every_ten(self):
+        learning = {'per_code': {'social_gap': {'sent': 10, 'rate': 0.8}}, 'last_tune_ts': NOW - 10}
+        weights = {'social_gap': 0.5, 'lonely': 0.5}
+        new, learning2 = loop.tune_weights(learning, weights, NOW, total_sent=10)
+        self.assertNotEqual(new['social_gap'], 0.5)
+        self.assertAlmostEqual(sum(new.values()), 1.0, places=6)
+        self.assertLessEqual(abs(new['social_gap'] - 0.5), 0.05 + 1e-9)
+    def test_tune_step_cap(self):
+        learning = {'per_code': {'social_gap': {'sent': 10, 'rate': 1.0}}, 'last_tune_ts': NOW - 10}
+        old = {'social_gap': 0.5, 'lonely': 0.5}
+        new, _ = loop.tune_weights(learning, old, NOW, total_sent=10)
+        self.assertGreater(new['social_gap'], 0.5); self.assertLessEqual(new['social_gap'], 0.55)
+    def test_tune_not_due(self):
+        learning = {'per_code': {'x': {'sent': 1, 'rate': 0.9}}, 'last_tune_ts': NOW - 10}
+        weights = {'x': 1.0}
+        new, _ = loop.tune_weights(learning, weights, NOW, total_sent=3)
+        self.assertEqual(new, weights)
+    def test_loop_view_fields(self):
+        view = loop.loop_view({'sent_count': 12, 'responded_count': 5, 'ignored_count': 7, 'last_attempt': {'code': 'lonely', 'ts': NOW}}, {'per_code': {'lonely': {'sent': 3, 'rate': 0.4}}})
+        for key in ('sent', 'responded', 'ignored', 'response_rate', 'avg_latency_s', 'last_attempt', 'per_code'):
+            self.assertIn(key, view)
+    def test_stall_detection(self):
+        self.assertTrue(loop.tick_stalled({'last_tick_ts': NOW - 700}, NOW, 300))
+        self.assertFalse(loop.tick_stalled({'last_tick_ts': NOW - 100}, NOW, 300))
+        self.assertFalse(loop.tick_stalled({}, NOW))
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_autonomy_mode.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import autonomy_mode
+
+class FakePlugin:
+    def __init__(self):
+        self.config = {"proactive_autonomy": False, "proactive_send": False,
+                       "proactive_autonomy_threshold": 0.6, "proactive_autonomy_max_chars": 120}
+        self.saved = []
+    async def _persist_plugin_config(self, updates):
+        self.saved.append(dict(updates)); self.config.update(updates)
+
+class AutonomyRouteTest(unittest.IsolatedAsyncioTestCase):
+    async def test_valid_save(self):
+        plugin = FakePlugin()
+        result = await autonomy_mode.apply(plugin, {"enabled": True, "send": True, "threshold": 0.7, "max_chars": 200})
+        self.assertTrue(result["ok"]); self.assertEqual(plugin.saved[-1]["proactive_autonomy"], True)
+        self.assertEqual(result["values"]["threshold"], 0.7); self.assertEqual(result["values"]["max_chars"], 200)
+    async def test_invalid_threshold(self):
+        with self.assertRaises(autonomy_mode.AutonomyError) as caught:
+            await autonomy_mode.apply(FakePlugin(), {"threshold": 1.7})
+        self.assertEqual(caught.exception.status, 400)
+    async def test_invalid_max_chars(self):
+        with self.assertRaises(autonomy_mode.AutonomyError):
+            await autonomy_mode.apply(FakePlugin(), {"max_chars": 5})
+    async def test_bad_bool_type(self):
+        with self.assertRaises(autonomy_mode.AutonomyError):
+            await autonomy_mode.apply(FakePlugin(), {"enabled": "yes"})
+    async def test_partial_update_only(self):
+        plugin = FakePlugin()
+        await autonomy_mode.apply(plugin, {"send": True})
+        self.assertEqual(list(plugin.saved[-1].keys()), ["proactive_send"])
+    async def test_returns_current(self):
+        plugin = FakePlugin()
+        result = await autonomy_mode.apply(plugin, {})
+        self.assertEqual(result["values"]["threshold"], 0.6)
+if __name__ == "__main__": unittest.main()

package/python/biocore_model/tests/test_autonomy_model.py

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+import math, unittest
+from biocore_model import autonomy_model as am
+
+class AutonomyModelTest(unittest.TestCase):
+    def test_gap_zero_near_zero(self):
+        self.assertLess(am.social_gap(0, 18, 1.0, 1.0), 0.01)
+
+    def test_gap_12h_about_half(self):
+        self.assertAlmostEqual(am.social_gap(12, 18, 1.0, 1.0), 0.487, delta=0.05)
+
+    def test_gap_48h_about_09(self):
+        value = am.social_gap(48, 18, 1.0, 1.0) * (0.6 + 0.4 * 1.0)
+        self.assertGreater(value, 0.85)
+
+    def test_closeness_scales_gap(self):
+        self.assertGreater(am.social_gap(24, 18, 1.0, 1.0), am.social_gap(24, 18, 1.0, 0.0))
+
+    def test_lonely_multiplies_prob_intensity(self):
+        self.assertAlmostEqual(am.lonely(0.8, 0.5), 0.4)
+
+    def test_quiet_raises_cost(self):
+        quiet = am.gate(0.8, 0.6, 0.5, 0.35, quiet=True)
+        normal = am.gate(0.8, 0.6, 0.5, 0.35, quiet=False)
+        self.assertGreater(quiet['cost'], normal['cost'])
+
+    def test_recent_activity_lowers_cost(self):
+        active = am.gate(0.8, 0.6, 0.5, 0.35, recent_user_active=True)
+        idle = am.gate(0.8, 0.6, 0.5, 0.35, recent_user_active=False)
+        self.assertLess(active['cost'], idle['cost'])
+
+    def test_lonely_discounts_cost(self):
+        high = am.gate(0.8, 0.6, 0.5, 0.35, lonely_value=1.0)
+        low = am.gate(0.8, 0.6, 0.5, 0.35, lonely_value=0.0)
+        self.assertLess(high['cost'], low['cost'])
+
+    def test_habit_power(self):
+        self.assertAlmostEqual(am.habit(1.0, 0), 1.0)
+        self.assertAlmostEqual(am.habit(1.0, 1), 0.7)
+        self.assertAlmostEqual(am.habit(1.0, 2), 0.49)
+
+    def test_compute_fields(self):
+        out = am.compute({'social_gap': 0.5, 'lonely': 0.2, 'stress_load': 0.1, 'drive_dev': 0.1, 'echo': 0.0, 'noise': 0.2}, 0.6)
+        for key in ('drive', 'parts', 'gate', 'ready'):
+            self.assertIn(key, out)
+        for key in ('social_gap', 'lonely', 'anxiety_fear', 'sadness', 'joy', 'anger_conflict', 'boredom', 'stress_load', 'drive_dev'):
+            self.assertIn(key, out['parts'])
+        for key in ('p_ready', 'benefit', 'cost', 'expected'):
+            self.assertIn(key, out['gate'])
+
+    def test_weights_normalised(self):
+        out = am.compute({'social_gap': 1.0, 'lonely': 1.0, 'stress_load': 1.0, 'drive_dev': 1.0, 'echo': 1.0, 'noise': 1.0}, 0.6)
+        self.assertLessEqual(out['drive'], 1.0)
+
+    def test_ready_requires_gate_and_threshold(self):
+        out = am.compute({'social_gap': 0.0, 'lonely': 0.0, 'stress_load': 0.0, 'drive_dev': 0.0, 'echo': 0.0, 'noise': 0.0}, 0.6)
+        self.assertFalse(out['ready'])
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_autonomy_model_v2.py

@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import autonomy_model as am
+
+BASE = {'social_gap': 0.3, 'lonely': 0.1, 'anxiety_fear': 0.1, 'sadness': 0.1, 'joy': 0.1,
+        'anger_conflict': 0.1, 'boredom': 0.1, 'stress_load': 0.1, 'drive_dev': 0.1}
+
+def d(parts): return am.drive(parts)
+
+class AutonomyV2Test(unittest.TestCase):
+    def test_weight_sum_is_one(self):
+        total = sum(am.DEFAULTS[k] for k in am.WEIGHT_KEYS)
+        self.assertAlmostEqual(total, 1.0, places=6)
+
+    def test_anxiety_raises_drive(self):
+        self.assertGreater(d(dict(BASE, anxiety_fear=0.9)), d(BASE))
+
+    def test_sadness_raises_drive(self):
+        self.assertGreater(d(dict(BASE, sadness=0.9)), d(BASE))
+
+    def test_joy_raises_drive(self):
+        self.assertGreater(d(dict(BASE, joy=0.9)), d(BASE))
+
+    def test_anger_raises_drive(self):
+        self.assertGreater(d(dict(BASE, anger_conflict=0.9)), d(BASE))
+
+    def test_boredom_raises_drive(self):
+        self.assertGreater(d(dict(BASE, boredom=0.9)), d(BASE))
+
+    def test_anger_raises_cost(self):
+        high = am.gate(0.8, 0.6, 0.5, anger=1.0)
+        low = am.gate(0.8, 0.6, 0.5, anger=0.0)
+        self.assertGreater(high['cost'], low['cost'])
+
+    def test_joy_lowers_cost(self):
+        high = am.gate(0.8, 0.6, 0.5, joy=1.0)
+        low = am.gate(0.8, 0.6, 0.5, joy=0.0)
+        self.assertLess(high['cost'], low['cost'])
+
+    def test_anxiety_lowers_cost(self):
+        self.assertLess(am.gate(0.8, 0.6, 0.5, anxiety=1.0)['cost'], am.gate(0.8, 0.6, 0.5, anxiety=0.0)['cost'])
+
+    def test_missing_emotions_no_crash(self):
+        out = am.compute({}, 0.6)
+        self.assertEqual(out['drive'], 0.0)
+        self.assertIn('anxiety_fear', out['parts'])
+
+    def test_parts_complete(self):
+        out = am.compute(BASE, 0.6)
+        for key in ('social_gap', 'lonely', 'anxiety_fear', 'sadness', 'joy', 'anger_conflict', 'boredom', 'stress_load', 'drive_dev'):
+            self.assertIn(key, out['parts'])
+
+    def test_gate_fields(self):
+        out = am.compute(BASE, 0.6)
+        for key in ('p_ready', 'benefit', 'cost', 'expected'):
+            self.assertIn(key, out['gate'])
+
+    def test_habit_still_applies(self):
+        self.assertAlmostEqual(am.habit(1.0, 2), 0.49, places=6)
+
+    def test_missing_weights_fall_back(self):
+        self.assertGreaterEqual(am.drive(dict(BASE, joy=1.0), {'w_joy': 0.5}), 0.0)
+
+    def test_ready_false_without_gate(self):
+        self.assertFalse(am.compute({}, 0.6)['ready'])
+
+if __name__ == '__main__':
+    unittest.main()