dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_autonomy_module_text.py

@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+"""Step-3 dispatcher text tests: prompt / fallback / punctuation cleanup.
+
+The two methods live on BioCorePlugin in main.py, which cannot be imported
+without AstrBot. They are pure (no astrbot names inside), so the test extracts
+them from the main.py AST and binds them to a fake plugin object -- the same
+technique as the step-3 engine smoke harness.
+"""
+import ast
+import re
+import sys
+import unittest
+from pathlib import Path
+
+PLUG = Path(__file__).resolve().parents[2]
+if str(PLUG) not in sys.path:
+    sys.path.insert(0, str(PLUG))
+import interpretation  # noqa: E402
+
+
+class _Log:
+    def __getattr__(self, _name):
+        return lambda *a, **k: None
+
+
+def load_methods():
+    tree = ast.parse((PLUG / "main.py").read_text(encoding="utf-8"))
+    cls = next(n for n in tree.body
+               if isinstance(n, ast.ClassDef) and n.name == "BioCorePlugin")
+    names = ("_build_proactive_text", "_sanitize_proactive_text")
+    nodes = [f for f in cls.body if isinstance(f, ast.FunctionDef) and f.name in names]
+    if len(nodes) != 2:
+        raise AssertionError("expected 2 methods, got %d" % len(nodes))
+    ns = {"re": re, "interpretation": interpretation, "logger": _Log()}
+    for node in nodes:
+        exec(compile(ast.Module(body=[node], type_ignores=[]),
+                     "<main-extract>", "exec"), ns)
+    _sanitize_fn = ns["_sanitize_proactive_text"]
+    return (ns["_build_proactive_text"],
+            lambda value, max_chars=0: _sanitize_fn(None, value, max_chars))
+
+
+class _Core:
+    relationship_context = {"state": {"closeness": 0.4, "trust": 0.55}}
+
+    def __init__(self, parts):
+        self._parts = parts
+
+    def autonomy_state(self, relationship=None, now=None, persist=False):
+        return {"enabled": True, "max_chars": 80, "parts": dict(self._parts)}
+
+    def snapshot(self):
+        return {"labels": {"emotion": "loneliness", "need": "talk"},
+                "v": -0.2, "a": 0.4, "d": 0.5, "social": 0.4,
+                "stress": 0.3, "energy": 0.5, "parts": dict(self._parts)}
+
+
+class _Plugin:
+    persona_text = "你是小灰，短句。"
+
+    def _relationship_of(self, user_data):
+        return {"state": {"closeness": 0.4, "trust": 0.55}}
+
+    def _autonomy_template(self, core):
+        return "在。"
+
+
+class AutonomyModuleTextTest(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        _build, _sanitize = load_methods()
+        cls.build = staticmethod(_build)
+        cls.sanitize = staticmethod(_sanitize)
+        cls.plugin = _Plugin()
+        cls.now = 1761700000.0
+        cls.acc = {"last_user_msg_ts": cls.now - 2 * 3600.0}
+
+    def test_prompt_non_empty(self):
+        built = self.build(self.plugin, _Core({"social_gap": 0.6, "lonely": 0.3}),
+                           self.acc, self.now)
+        self.assertTrue(str(built.get("prompt") or "").strip())
+        self.assertNotIn("【输出格式", built["prompt"])
+        self.assertTrue(str(built.get("text") or "").strip())
+        # 2026-10-31: hard cap removed by product decision (no truncation).
+        self.assertEqual(int(built.get("max_chars") or 0), 0)
+
+    def test_fallback_path(self):
+        built = self.build(self.plugin, _Core({}), self.acc, self.now)
+        text = str(built.get("text") or "")
+        self.assertTrue(text.startswith("（"))
+        self.assertTrue(text.endswith("在。"))
+        self.assertIn("你是小灰", built["prompt"])  # persona/system block present
+
+    def test_sanitize_punctuation_and_cap(self):
+        self.assertEqual(self.sanitize("想听听你今天的碎片。。 。", 0),
+                         "想听听你今天的碎片。")
+        self.assertEqual(self.sanitize('你好<bc>{"e":"joy"}</bc>。。', 0), "你好。")
+        capped = self.sanitize("一二三四五六。", 3)
+        self.assertLessEqual(len(capped), 3)
+        self.assertEqual(self.sanitize("  在。。。  ", 0), "在。")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_autonomy_params.py

@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+"""Persona-derived autonomy rhythm (theta/tau/cooldown) tests."""
+import ast
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+
+import interpretation
+from biocore_model import autonomy_model as am
+from biocore_model import autonomy_params as ap
+
+MAIN = Path(__file__).resolve().parents[2] / "main.py"
+SOURCE = MAIN.read_text(encoding="utf-8")
+NOW = 1_000_000.0
+REAL = {"O": 0.82, "C": 0.38, "E": 0.93, "A": 0.70, "N": 0.52,
+        "recovery_rate": 0.78, "social_baseline": 0.88}
+REL = {"state": {"closeness": 0.5, "conflict": 0.3, "repair": 0.2},
+       "attachment": {"safe": 0.6}, "attachment_style": "secure"}
+
+
+class CalmCore:
+    v = 0.0
+    a = 0.45
+    d = 0.55
+    social = 0.6
+    stress = 0.1
+    energy = 0.5
+    allostatic_load = 0.0
+    boredom = 0.0
+    homeostasis = {"L_int": 0.05}
+    labels = {"emotion": "neutral", "intensity": 0.0}
+    open_loops = []
+    open_loops_due = 0
+
+    def snapshot(self):
+        return {"v": self.v, "a": self.a, "d": self.d, "social": self.social,
+                "stress": self.stress, "energy": self.energy,
+                "allostatic_load": self.allostatic_load, "boredom": self.boredom,
+                "homeostasis": dict(self.homeostasis),
+                "open_loops": [], "open_loops_due": 0}
+
+
+class MonotonicTest(unittest.TestCase):
+    def test_extraversion_up_theta_down(self):
+        low = ap.from_profile(dict(REAL, E=0.2), REL)
+        high = ap.from_profile(dict(REAL, E=0.95), REL)
+        self.assertLess(high["theta"], low["theta"])
+
+    def test_closeness_up_theta_and_tau_down(self):
+        far = {"state": {"closeness": 0.2}}
+        near = {"state": {"closeness": 0.9}}
+        a = ap.from_profile(REAL, far)
+        b = ap.from_profile(REAL, near)
+        self.assertLess(b["theta"], a["theta"])
+        self.assertLess(b["tau_hours"], a["tau_hours"])
+
+    def test_avoidance_up_theta_and_cooldown_up(self):
+        secure = ap.from_profile(REAL, {"attachment_style": "secure"})
+        avoid = ap.from_profile(REAL, {"attachment_style": "avoidant"})
+        self.assertGreater(avoid["theta"], secure["theta"])
+        self.assertGreater(avoid["cooldown_s"], secure["cooldown_s"])
+
+    def test_ignore_rate_up_cooldown_up(self):
+        calm = ap.from_profile(REAL, REL, ignore_rate=0.0)
+        ignored = ap.from_profile(REAL, REL, ignore_rate=0.9)
+        self.assertGreater(ignored["cooldown_s"], calm["cooldown_s"])
+
+
+class RealProfileTest(unittest.TestCase):
+    def test_real_profile_values(self):
+        params = ap.from_profile(REAL, REL, responsiveness=0.5, ignore_rate=0.0)
+        self.assertAlmostEqual(params["theta"], 0.5239, places=3)
+        self.assertAlmostEqual(params["tau_hours"], 16.0, places=1)
+        self.assertEqual(params["cooldown_s"], 1625)
+        self.assertAlmostEqual(params["silence_tau_hours"], 2.001, places=2)
+        self.assertEqual(params["daily_cap"], 3)
+
+    def test_flat_and_nested_profile_agree(self):
+        flat = ap.from_profile(REAL, REL)
+        nested = ap.from_profile({"big5": {"E": 0.93, "N": 0.52}}, REL)
+        self.assertAlmostEqual(flat["theta"], nested["theta"], places=2)
+
+    def test_override_applies_and_clamps(self):
+        base = ap.from_profile(REAL, REL)
+        out = ap.apply_overrides(base, {"theta": 0.9, "daily_cap": 99,
+                                        "cooldown_s": 5})
+        self.assertAlmostEqual(out["theta"], 0.9, places=3)
+        self.assertLessEqual(out["daily_cap"], 12)
+        self.assertGreaterEqual(out["cooldown_s"], 300)
+
+
+class CadenceTest(unittest.TestCase):
+    def _trigger_minutes(self):
+        params = ap.from_profile(REAL, REL)
+        acc = {"last_user_msg_ts": NOW}
+        value = 0.0
+        for minute in range(0, 300):
+            parts = am.parts_from_state(
+                CalmCore(), REL, now=NOW + minute * 60.0, acc=acc,
+                params=params, social_baseline=REAL["social_baseline"])
+            out = am.step(value, am.drift_value(parts), leak=0.15,
+                          sigma=0.0, theta=params["theta"])
+            value = out["V"]
+            if out["fire"]:
+                return minute
+        return None
+
+    def test_real_profile_cadence_60_to_120_minutes(self):
+        minutes = self._trigger_minutes()
+        self.assertIsNotNone(minutes)
+        self.assertGreaterEqual(minutes, 60)
+        self.assertLessEqual(minutes, 120)
+
+    def test_params_change_parts_taus(self):
+        fast = ap.from_profile(REAL, REL)
+        slow = dict(fast, silence_tau_hours=8.0, social_tau_hours=36.0)
+        acc = {"last_user_msg_ts": NOW - 2 * 3600}
+        a = am.parts_from_state(CalmCore(), REL, now=NOW, acc=acc, params=fast,
+                                social_baseline=REAL["social_baseline"])
+        b = am.parts_from_state(CalmCore(), REL, now=NOW, acc=acc, params=slow,
+                                social_baseline=REAL["social_baseline"])
+        self.assertGreater(a["lonely"], b["lonely"])
+        self.assertGreater(a["social_gap"], b["social_gap"])
+
+
+class Big5FlatReadTest(unittest.TestCase):
+    def _load_big5(self):
+        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 == "_big5_effect")
+        ns = {"interpretation": interpretation}
+        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)
+        exec(compile(ast.Module(body=[clone], type_ignores=[]), "<big5>", "exec"), ns)
+        return ns[node.name]
+
+    def test_flat_ocean_keys_are_read(self):
+        fn = self._load_big5()
+        core = SimpleNamespace(profile=dict(REAL), a=0.5, v=0.0)
+        out = fn(None, core)
+        cue = 0.5
+        self.assertEqual(out["extraversion"],
+                         interpretation.big5_trait_effect(0.93, cue))
+        self.assertEqual(out["neuroticism"],
+                         interpretation.big5_trait_effect(0.52, cue))
+
+
+class WiringStaticTest(unittest.TestCase):
+    def test_main_uses_params_for_theta_cooldown_and_ui_override(self):
+        self.assertIn("_autonomy_params()", SOURCE)
+        self.assertIn("params.get(\"cooldown_s\"", SOURCE)
+        self.assertIn("params.get(\"theta\"", SOURCE)
+        self.assertIn("\"params\"", SOURCE)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_autonomy_reason.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import autonomy_reason as ar
+
+class ReasonTest(unittest.TestCase):
+    def test_social_gap(self):
+        r = ar.extract({'social_gap': 0.8})
+        self.assertEqual(r['code'], 'social_gap'); self.assertIn('很久', r['text'])
+    def test_lonely(self):
+        self.assertEqual(ar.extract({'lonely': 0.5})['code'], 'lonely')
+    def test_anxiety(self):
+        self.assertEqual(ar.extract({'anxiety_fear': 0.6})['code'], 'anxiety')
+    def test_anger(self):
+        self.assertEqual(ar.extract({'anger_conflict': 0.7})['code'], 'anger')
+    def test_repair(self):
+        self.assertEqual(ar.extract({'repair_urge': 0.4})['code'], 'repair')
+    def test_memory_due_with_title(self):
+        r = ar.extract({'memory_due': 0.5}, memory_title='明天体检')
+        self.assertEqual(r['code'], 'memory_due'); self.assertIn('明天体检', r['text'])
+    def test_prompt_contains_motive(self):
+        prompt = ar.build_prompt({'code': 'lonely', 'text': '有点闷', 'weight': 0.3})
+        self.assertIn('你现在主动找对方说话', prompt)
+        self.assertIn('因为你：孤独', prompt)
+    def test_fallback_contains_reason(self):
+        text = ar.fallback_text({'text': '很久没联系了'}, '在。')
+        self.assertIn('很久没联系了', text); self.assertIn('在。', text)
+    def test_empty_parts_default(self):
+        self.assertEqual(ar.extract({})['code'], 'lonely')
+    def test_priority_social_gap_over_memory(self):
+        r = ar.extract({'social_gap': 0.2, 'memory_due': 0.9}, memory_due=0.0)
+        self.assertEqual(r['code'], 'memory_due')
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_autonomy_self.py

@@ -0,0 +1,153 @@
+# -*- coding: utf-8 -*-
+"""task-222: self layer (persona/narrative/drift) + autonomy decision/limits."""
+import json
+import tempfile
+import time
+import unittest
+from pathlib import Path
+
+from biocore_runtime import autonomy, pipeline, self_layer
+
+
+def write_json(path, data):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+class Case(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.data_dir = Path(self.tmp.name) / "data"
+        self.store = self.data_dir / "memory"
+        self.persona = Path(self.tmp.name) / "missing.json"
+        (self.store / "sessions").mkdir(parents=True, exist_ok=True)
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def payload(self, session_id="s1", **extra):
+        data = {"store": str(self.store), "session_id": session_id,
+                "persona_profile": str(self.persona)}
+        data.update(extra)
+        return data
+
+    def configure(self, **extra):
+        data = {"data_dir": str(self.data_dir)}
+        data.update(extra)
+        pipeline.dispatch("configure", data)
+
+    def actions(self, rows):
+        lines = []
+        for row in rows:
+            line = {"ts": time.time(), "kind": "write", "args": {},
+                    "reason": "test", "result": {"ok": True}}
+            line.update(row)
+            lines.append(json.dumps(line, ensure_ascii=False))
+        (self.data_dir / "actions.jsonl").write_text(
+            "\n".join(lines) + "\n", encoding="utf-8")
+
+
+class SelfLayerTest(Case):
+    def test_persona_locked(self):
+        self.configure(persona_text="我是安吉拉")
+        doc = self_layer.update(self.store, self_layer.hash_persona("我是安吉拉"))
+        self.assertTrue(doc["persona_locked"])
+        summary = self_layer.summary(self.store)
+        self.assertTrue(summary["persona_locked"])
+        self.assertEqual(summary["drift_count"], 0)
+
+    def test_drift_detected(self):
+        self.configure(persona_text="旧人设")
+        self_layer.update(self.store, self_layer.hash_persona("旧人设"))
+        self_layer.update(self.store, self_layer.hash_persona("新人设"))
+        summary = self_layer.summary(self.store)
+        self.assertEqual(summary["drift_count"], 1)
+
+    def test_same_hash_is_idempotent(self):
+        h = self_layer.hash_persona("稳定人设")
+        self_layer.update(self.store, h)
+        self_layer.update(self.store, h)
+        self.assertEqual(self_layer.summary(self.store)["drift_count"], 0)
+
+    def test_narrative_accumulates(self):
+        self_layer.update(self.store, "", {"kind": "warmth", "text": "谢谢你"})
+        self_layer.update(self.store, "", {"kind": "repair", "text": "对不起"})
+        summary = self_layer.summary(self.store)
+        self.assertEqual(summary["narrative_count"], 2)
+        self.assertEqual(summary["last_narrative"], "对不起")
+
+
+class AutonomyTest(Case):
+    def test_default_limits(self):
+        lim = autonomy.limits(self.store)
+        self.assertEqual(lim["max_actions_per_hour"], 20)
+        self.assertEqual(lim["max_sends_per_hour"], 5)
+        self.assertEqual(lim["max_sends_per_day"], 30)
+        self.assertEqual(lim["quiet_hours"], [])
+        self.assertTrue(lim["auto_decay_on_silence"])
+
+    def test_send_when_social_low(self):
+        out = autonomy.decide(self.store, now=time.time(),
+                              state={"core": {"social": 0.2, "energy": 0.7}})
+        self.assertEqual(out["action"]["kind"], "send")
+
+    def test_retrieve_when_memory_exists(self):
+        write_json(self.store / "sessions" / "autonomy" / "memory.json",
+                   {"entries": [{"id": "a", "text": "hello", "ts": 1.0}]})
+        out = autonomy.decide(self.store, now=time.time(),
+                              state={"core": {"social": 0.9}})
+        self.assertEqual(out["action"]["kind"], "retrieve")
+
+    def test_write_when_idle(self):
+        out = autonomy.decide(self.store, now=time.time(),
+                              state={"core": {"social": 0.9, "energy": 0.8}})
+        self.assertEqual(out["action"]["kind"], "write")
+
+    def test_hourly_action_cap_blocks(self):
+        now = time.time()
+        self.actions([{"ts": now - 5}] * 20)
+        out = autonomy.decide(self.store, now=now, state={"core": {"social": 0.2}})
+        self.assertIsNone(out["action"])
+        self.assertEqual(out["reason"], "limit_actions_hour")
+
+    def test_send_hour_cap_blocks_send(self):
+        now = time.time()
+        self.actions([{"ts": now - 10, "kind": "send"}] * 5)
+        out = autonomy.decide(self.store, now=now, state={"core": {"social": 0.2}})
+        self.assertNotEqual((out["action"] or {}).get("kind"), "send")
+
+    def test_quiet_hours_block_send(self):
+        self.configure(autonomy={"quiet_hours": ["00:00-23:59"]})
+        out = autonomy.decide(self.store, now=time.time(),
+                              state={"core": {"social": 0.2}})
+        self.assertNotEqual((out["action"] or {}).get("kind"), "send")
+
+    def test_decay_on_silence_throttles(self):
+        now = time.time()
+        self.actions([{"ts": now - 60}])  # last action 1 min ago
+        out = autonomy.decide(self.store, now=now,
+                              state={"core": {"social": 0.2}},
+                              silence_minutes=24 * 60)
+        self.assertIsNone(out["action"])
+        self.assertEqual(out["reason"], "decayed_silence")
+
+    def test_core_disabled_no_action(self):
+        self.configure(switches={"core_enabled": False})
+        out = pipeline.dispatch("autonomy_tick", self.payload())
+        self.assertTrue(out["ok"])
+        self.assertIsNone(out["action"])
+        self.assertEqual(out["reason"], "disabled")
+
+    def test_state_exposes_autonomy_numbers(self):
+        self.actions([{"ts": time.time(), "kind": "send"},
+                      {"ts": time.time(), "kind": "write"}])
+        body = pipeline.dispatch("state", self.payload())["state"]
+        self.assertEqual(body["autonomy"]["actions_today"], 2)
+        self.assertEqual(body["autonomy"]["sends_today"], 1)
+        self.assertEqual(body["autonomy"]["limits"]["max_sends_per_hour"], 5)
+        self.assertIn("identity", body)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_autonomy_send_gate.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+import time, unittest
+from biocore_model import autonomy_model as am
+
+NOW = time.mktime((2026, 1, 1, 12, 0, 0, 0, 1, -1))
+
+class SendGateTest(unittest.TestCase):
+    def test_fire_when_v_reaches_theta(self):
+        out = am.step(0.55, 0.1, sigma=0.0, theta=0.55)
+        self.assertTrue(out['fire'])
+    def test_cooldown_blocks(self):
+        ok, why = am.send_gate({'last_sent_ts': NOW - 10}, now=NOW)
+        self.assertFalse(ok); self.assertEqual(why, 'cooldown')
+    def test_daily_cap_blocks(self):
+        day = time.strftime('%Y-%m-%d', time.localtime(NOW))
+        ok, why = am.send_gate({'sent_day': day, 'sent_count': 3}, now=NOW)
+        self.assertFalse(ok); self.assertEqual(why, 'daily_cap')
+    def test_quiet_hours_blocks(self):
+        quiet = time.mktime((2026, 1, 1, 3, 0, 0, 0, 1, -1))
+        ok, why = am.send_gate({}, now=quiet)
+        self.assertFalse(ok); self.assertEqual(why, 'quiet_hours')
+    def test_send_disabled_blocks(self):
+        ok, why = am.send_gate({}, send_enabled=False)
+        self.assertFalse(ok); self.assertEqual(why, 'send_disabled')
+    def test_not_private_blocks(self):
+        ok, why = am.send_gate({}, private=False)
+        self.assertFalse(ok); self.assertEqual(why, 'not_private')
+    def test_allowed(self):
+        ok, why = am.send_gate({}, now=NOW)
+        self.assertTrue(ok); self.assertEqual(why, 'fired')
+    def test_apply_fire_resets(self):
+        acc = am.apply_fire({'V': 0.6, 'ticks_since_fire': 5}, now=NOW, text_len=12)
+        self.assertEqual(acc['V'], 0.0); self.assertEqual(acc['ticks_since_fire'], 0)
+    def test_no_fire_below_theta(self):
+        self.assertFalse(am.step(0.4, 0.0, sigma=0.0, theta=0.55)['fire'])
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_autonomy_silence.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import autonomy_model as am
+
+NOW = 1_700_000_000
+
+class SilenceTest(unittest.TestCase):
+    def test_expect_phase(self):
+        self.assertEqual(am.silence_phase(1.0)['drive_mult'], 1.00)
+    def test_protest_phase(self):
+        self.assertEqual(am.silence_phase(3.0)['phase'], 'protest')
+    def test_loss_phase(self):
+        self.assertEqual(am.silence_phase(10.0)['phase'], 'loss')
+    def test_withdraw_phase(self):
+        self.assertEqual(am.silence_phase(25.0)['phase'], 'withdraw')
+    def test_boundary_2h(self):
+        self.assertEqual(am.silence_phase(2.0)['phase'], 'protest')
+    def test_boundary_6h(self):
+        self.assertEqual(am.silence_phase(6.0)['phase'], 'loss')
+    def test_boundary_24h(self):
+        self.assertEqual(am.silence_phase(24.0)['phase'], 'withdraw')
+    def test_silence_zero_after_reply(self):
+        self.assertEqual(am.silence_hours(NOW - 3600, NOW, NOW), 0.0)
+    def test_silence_hours(self):
+        self.assertAlmostEqual(am.silence_hours(NOW - 7200, NOW - 9000, NOW), 2.0)
+    def test_nudges_direction(self):
+        n = am.silence_nudges(6, 'protest', 0.8)
+        self.assertLess(n['valence'], 0); self.assertEqual(n['arousal'], 0.0)
+        self.assertEqual(n['stress'], 0.0); self.assertGreater(n['lonely'], 0)
+    def test_nudges_dt_capped(self):
+        self.assertLessEqual(am.silence_nudges(100, 'loss', 1.0)['dt_hours'], 6.0)
+    def test_silence_view_fields(self):
+        view = am.silence_view(NOW - 3 * 3600, 0, NOW)
+        self.assertIn('hours', view); self.assertIn('phase', view); self.assertIn('drive_mult', view)
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_autonomy_status.py

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import autonomy_model as am
+
+ACC = {'V': 0.2, 'theta': 0.55, 'drift': 0.1, 'leak': 0.15, 'sigma': 0.06, 'ticks_since_fire': 3}
+
+class StatusSnapshotTest(unittest.TestCase):
+    def test_fields(self):
+        snap = am.status_snapshot(ACC, {'social_gap': 0.5})
+        for key in ('V', 'theta', 'drift', 'leak', 'sigma', 'ticks_since_fire', 'to_threshold', 'parts', 'gate_allowed', 'block_reason', 'last_tick_ts', 'eta_hours'):
+            self.assertIn(key, snap)
+    def test_does_not_mutate(self):
+        acc = dict(ACC)
+        am.status_snapshot(acc, {'social_gap': 0.1})
+        self.assertEqual(acc, ACC)
+    def test_to_threshold(self):
+        self.assertAlmostEqual(am.status_snapshot(ACC)['to_threshold'], 0.35)
+    def test_eta_hours(self):
+        self.assertAlmostEqual(am.status_snapshot(ACC)['eta_hours'], round(0.35 / 0.1 * 300 / 3600.0, 2))
+    def test_zero_drift_eta_none(self):
+        self.assertIsNone(am.status_snapshot(dict(ACC, drift=0.0))['eta_hours'])
+    def test_parts_include_all_weights(self):
+        snap = am.status_snapshot(ACC, {})
+        for key in am.DRIFT_WEIGHTS:
+            self.assertIn(key, snap['parts'])
+    def test_affect_field(self):
+        snap = am.status_snapshot({'affect': {'valence': -0.1}})
+        self.assertIn('affect', snap); self.assertEqual(snap['affect']['valence'], -0.1)
+
+    def test_missing_acc_no_crash(self):
+        snap = am.status_snapshot(None)
+        self.assertEqual(snap['V'], 0.0)
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_autonomy_test_trigger.py

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import autonomy_model as am
+
+class TestTriggerTest(unittest.TestCase):
+    def test_sets_v(self):
+        out = am.test_trigger({'theta': 0.55}, reset=False)
+        self.assertAlmostEqual(out['V_set'], 0.495); self.assertFalse(out['reset'])
+    def test_reset_zero(self):
+        out = am.test_trigger({'theta': 0.55, 'V': 0.9}, reset=True)
+        self.assertEqual(out['V_set'], 0.0); self.assertTrue(out['reset'])
+    def test_theta_read(self):
+        self.assertEqual(am.test_trigger({'theta': 0.8})['theta'], 0.8)
+    def test_default_theta(self):
+        self.assertAlmostEqual(am.test_trigger({})['theta'], 0.55)
+    def test_missing_acc_no_crash(self):
+        self.assertTrue(am.test_trigger(None)['ok'])
+    def test_next_tick_can_fire(self):
+        out = am.test_trigger({'theta': 0.55})
+        tick = am.step(out['V_set'], 0.0, sigma=0.0, theta=out['theta'])
+        self.assertGreaterEqual(tick['V_raw'], 0.4)  # leak applies; drift decides firing
+
+if __name__ == '__main__':
+    unittest.main()