dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_batch2_wiring.py

@@ -0,0 +1,231 @@
+# -*- coding: utf-8 -*-
+"""task-173 批二接线测试：granularity / affective_labor / self_verification。
+
+同时覆盖 task-173 的开关拆分：boundary_enabled 只表示内容安全闸，
+boundary_lines_enabled 才是「她的底线」。三个模块的 directives 必须走现有
+唯一 merge_named 入口。
+"""
+import ast
+import json
+import unittest
+from pathlib import Path
+
+from biocore_model import affective_labor as al
+from biocore_model import granularity as gr
+from biocore_model import self_verification as sv
+from biocore_model import x_directives as xd
+
+ROOT = Path(__file__).resolve().parents[2]
+MAIN = (ROOT / "main.py").read_text(encoding="utf-8")
+ROUTES = (ROOT / "biocore_model" / "plugin_routes.py").read_text(encoding="utf-8")
+SCHEMA = json.loads((ROOT / "_conf_schema.json").read_text(encoding="utf-8"))
+DASH = ROOT / "pages" / "dashboard"
+SRC_HTML = (DASH / "index.src.html").read_text(encoding="utf-8")
+INDEX_HTML = (DASH / "index.html").read_text(encoding="utf-8")
+APP_JS = (DASH / "app.js").read_text(encoding="utf-8")
+
+NOW = 1_700_000_000
+
+
+class FlagTest(unittest.TestCase):
+    def test_schema_defaults(self):
+        expected = {"boundary_lines_enabled": False,
+                    "granularity_enabled": True,
+                    "affective_labor_enabled": True,
+                    "self_verification_enabled": True}
+        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_main_reads_flags(self):
+        expected = {"boundary_lines_enabled": "False",
+                    "granularity_enabled": "True",
+                    "affective_labor_enabled": "True",
+                    "self_verification_enabled": "True"}
+        for key, default in expected.items():
+            self.assertIn('self.config.get("%s", %s)' % (key, default), MAIN)
+
+
+class BoundarySplitTest(unittest.TestCase):
+    def test_hints_are_distinct(self):
+        safety = SCHEMA["boundary_enabled"]
+        lines = SCHEMA["boundary_lines_enabled"]
+        self.assertIn("内容安全", safety.get("description", ""))
+        self.assertIn("不诊断", safety.get("hint", ""))
+        self.assertNotIn("她的底线——", safety.get("hint", ""))
+        self.assertIn("独立", lines.get("hint", ""))
+        self.assertIn("boundary_enabled", lines.get("hint", ""))
+
+    def test_relational_block_uses_lines_switch(self):
+        self.assertIn(
+            'if bool(getattr(self, "boundary_lines_enabled", False)):', MAIN)
+        block = MAIN[MAIN.index("task-172 batch-1: boundary judgment first"):
+                     MAIN.index("# A4: capture open loops")]
+        self.assertNotIn('getattr(self, "boundary_enabled"', block)
+        # content-safety gate module is untouched and still keys off its switch
+        gate = (ROOT / "biocore_model" / "boundary_gate.py").read_text(
+            encoding="utf-8")
+        self.assertIn("boundary_enabled", gate)
+
+
+class GranularityWiringTest(unittest.TestCase):
+    def test_wiring(self):
+        self.assertIn("from .biocore_model import granularity as _gr_mod", MAIN)
+        self.assertIn("from .biocore_model import emotion_geometry as _eg_mod",
+                      MAIN)
+        self.assertIn("core.emotion_granularity = _gr_view", MAIN)
+        self.assertIn("[biocore] emotion granularity primary=%s line=%s", MAIN)
+        self.assertIn("if bool(getattr(self, \"granularity_enabled\", True)):", MAIN)
+
+    def test_read_only_no_directive(self):
+        block = MAIN[MAIN.index("task-173 granularity"):
+                     MAIN.index("# task-173 affective_labor")]
+        self.assertNotIn("_x_pairs.append", block)
+        self.assertIn("_gr_mod.view(", block)
+
+    def test_labels(self):
+        aggrieved = gr.refine({"sadness": 0.50, "anger": 0.20})
+        self.assertEqual(aggrieved["labels"], ["委屈"])
+        disappointed = gr.refine({"sadness": 0.50, "trust": 0.20})
+        self.assertEqual(disappointed["labels"], ["失望"])
+        ignored = gr.refine({"loneliness": 0.60, "sadness": 0.15})
+        self.assertEqual(ignored["labels"], ["被忽视"])
+        panel = gr.view({"sadness": 0.50, "anger": 0.20})
+        self.assertEqual(panel["line"], "委屈（难过）")
+
+    def test_panel_projection(self):
+        self.assertIn('"emotion_granularity": (self._granularity_payload()',
+                      MAIN)
+        self.assertIn('"emotion_granularity": (self._granularity_payload()',
+                      ROUTES)
+        self.assertIn('id="granularityNote"', SRC_HTML)
+        self.assertIn('id="granularityNote"', INDEX_HTML)
+        self.assertIn('$("granularityNote")', APP_JS)
+
+    def test_payload_method(self):
+        tree = ast.parse(MAIN)
+        nodes = [n for n in ast.walk(tree) if isinstance(n, ast.FunctionDef)
+                 and n.name == "_granularity_payload"]
+        self.assertEqual(len(nodes), 1)
+        module = ast.Module(body=nodes, type_ignores=[])
+        ns = {}
+        exec(compile(module, "<granularity_panel>", "exec"), ns)
+        import types
+        core = types.SimpleNamespace(emotion_granularity={
+            "enabled": True, "display": "委屈", "line": "委屈（难过）",
+            "primary": "sadness", "primary_zh": "难过",
+            "secondary": [{"key": "aggrieved", "label": "委屈"}],
+            "fallback": False})
+        plugin = types.SimpleNamespace(
+            cores={"k": core}, granularity_enabled=True)
+        out = ns["_granularity_payload"](plugin)
+        self.assertTrue(out["enabled"])
+        self.assertEqual(out["line"], "委屈（难过）")
+        self.assertEqual(out["secondary"][0]["label"], "委屈")
+
+
+class AffectiveLaborWiringTest(unittest.TestCase):
+    def test_wiring(self):
+        self.assertIn("from .biocore_model import affective_labor as _al_mod",
+                      MAIN)
+        self.assertIn("from .biocore_model import affective_labor as _al_mod2",
+                      MAIN)
+        self.assertIn("core.affective_labor = _al_mod2.update(", MAIN)
+        self.assertIn("core.affective_labor_view = _al_panel", MAIN)
+        self.assertIn("self._labor_felt = {", MAIN)
+        self.assertIn("/** task-173", MAIN) if False else None
+
+    def test_high_load_restrains_through_bus(self):
+        self.assertIn('self._x_pairs.append((\n                        "affective_labor",', MAIN) or \
+            self.assertIn('"affective_labor",', MAIN)
+        self.assertIn('"length_scale": 0.85', MAIN)
+        self.assertIn('>= 0.60', MAIN)
+
+    def test_load_accumulates(self):
+        first = al.update(al.initial(NOW - 10),
+                          {"v": 0.6, "a": 0.4}, {"v": -0.6, "a": 0.4},
+                          honesty=0.0, now=NOW)
+        second = al.update(first, {"v": 0.6}, {"v": -0.6},
+                           honesty=0.0, now=NOW + 60)
+        self.assertGreater(second["load"], first["load"])
+        paused = al.update(second, {"v": 0.6}, {"v": -0.6},
+                           honesty=0.0, now=NOW + 60)
+        self.assertEqual(paused["load"], second["load"])
+        view = al.view(second)
+        self.assertIn("risk", view)
+        self.assertGreaterEqual(view["risk"], 0.0)
+
+
+class SelfVerificationWiringTest(unittest.TestCase):
+    def test_wiring(self):
+        self.assertIn("from .biocore_model import self_verification as _sv_mod",
+                      MAIN)
+        self.assertIn("core.self_verification = _sv_state", MAIN)
+        self.assertIn("core.self_verification_view = _sv_mod.view(_sv_state)",
+                      MAIN)
+        self.assertIn("_sv_mod.observe(", MAIN)
+        self.assertIn("_sv_mod.intent(_sv_state)", MAIN)
+
+    def test_urge_allows_correction(self):
+        misread = sv.observe(sv.initial(NOW - 10), True,
+                             clarity=0.9, relation=0.9, severity=1.0, now=NOW)
+        accurate = sv.observe(sv.initial(NOW - 10), False,
+                              clarity=0.9, relation=0.9, now=NOW)
+        self.assertGreater(misread["urge"], accurate["urge"])
+        self.assertEqual(accurate["urge"], 0.0)
+        decided = sv.intent(misread)
+        self.assertTrue(decided["want_correct"])
+        self.assertIn("allow_correction",
+                      str(xd.normalize({"allow_correction": True}, "sv")))
+
+
+class BusTest(unittest.TestCase):
+    def test_still_single_merge(self):
+        self.assertEqual(MAIN.count("merge_named("), 1)
+        self.assertIn("merge_named(self._x_pairs)", MAIN)
+
+    def test_batch2_directives_merge(self):
+        merged = xd.merge_named([
+            ("affective_labor", {"length_scale": 0.85, "tone": "累了，话少一点",
+                                 "initiative": 0.35}),
+            ("self_verification", {"allow_correction": True,
+                                   "tone": "可以补一句纠正"}),
+            ("attributor", {"length_scale": 0.9, "tone": "语气硬一点"}),
+        ])
+        self.assertIn("affective_labor", merged["sources"])
+        self.assertIn("self_verification", merged["sources"])
+        self.assertTrue(merged["allow_correction"])
+        self.assertLessEqual(merged["length_scale"], 0.85)
+        self.assertLessEqual(merged["initiative"], 0.5)
+
+
+class RollbackTest(unittest.TestCase):
+    def test_each_block_guarded(self):
+        for key in ("granularity_enabled", "affective_labor_enabled",
+                    "self_verification_enabled"):
+            self.assertIn('if bool(getattr(self, "%s", True)):' % key, MAIN)
+        self.assertIn('if bool(getattr(self, "boundary_lines_enabled", False)):',
+                      MAIN)
+
+
+class PurityTest(unittest.TestCase):
+    def test_modules_stay_pure(self):
+        for name in ("granularity", "affective_labor", "self_verification"):
+            tree = ast.parse((ROOT / "biocore_model" / (name + ".py"))
+                             .read_text(encoding="utf-8"))
+            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()

package/python/biocore_model/tests/test_batch3_wiring.py

@@ -0,0 +1,223 @@
+# -*- coding: utf-8 -*-
+"""task-174 批三接线测试：九个模块 + 唯一 x_directives 总线。
+
+源码断言确认接线位置/开关回退；纯函数断言确认每个模块的自然行为。
+全部开关默认 ON，关掉后该块整段跳过。
+"""
+import ast
+import json
+import unittest
+from pathlib import Path
+
+from biocore_model import attachment_behavior as ab
+from biocore_model import compassion_fatigue as cf
+from biocore_model import dissonance as di
+from biocore_model import narrative as na
+from biocore_model import possible_selves as ps
+from biocore_model import reconstruction as rc
+from biocore_model import relation_stage as rs
+from biocore_model import secrecy as se
+from biocore_model import source_monitoring as sm
+from biocore_model import value_order as vo
+from biocore_model import x_directives as xd
+
+ROOT = Path(__file__).resolve().parents[2]
+MAIN = (ROOT / "main.py").read_text(encoding="utf-8")
+ROUTES = (ROOT / "biocore_model" / "plugin_routes.py").read_text(encoding="utf-8")
+SCHEMA = json.loads((ROOT / "_conf_schema.json").read_text(encoding="utf-8"))
+DASH = ROOT / "pages" / "dashboard"
+SRC_HTML = (DASH / "index.src.html").read_text(encoding="utf-8")
+INDEX_HTML = (DASH / "index.html").read_text(encoding="utf-8")
+APP_JS = (DASH / "app.js").read_text(encoding="utf-8")
+
+SWITCHES = ("value_order_enabled", "dissonance_enabled",
+            "attachment_behavior_enabled", "relation_stage_enabled",
+            "narrative_enabled", "reconstruction_enabled",
+            "source_monitoring_enabled", "possible_selves_enabled",
+            "compassion_fatigue_enabled", "secrecy_enabled")
+
+
+class FlagTest(unittest.TestCase):
+    def test_schema_defaults_true(self):
+        for key in SWITCHES:
+            entry = SCHEMA.get(key)
+            self.assertIsInstance(entry, dict, key)
+            self.assertEqual(entry.get("type"), "bool", key)
+            self.assertIs(entry.get("default"), True, key)
+
+    def test_main_reads_flags(self):
+        for key in SWITCHES:
+            self.assertIn('self.config.get("%s", True)' % key, MAIN)
+
+
+class PositionTest(unittest.TestCase):
+    def test_single_merge_still(self):
+        self.assertEqual(MAIN.count("merge_named("), 1)
+        self.assertIn("merge_named(self._x_pairs)", MAIN)
+
+    def test_value_order(self):
+        self.assertIn("from .biocore_model import value_order as _vo_mod", MAIN)
+        self.assertIn("core.value_order = _vo_mod.rank(", MAIN)
+        block = MAIN[MAIN.index("task-174 batch-3 (nine modules"):
+                     MAIN.index("# task-173 granularity")]
+        self.assertNotIn("_x_pairs.append((\"value_order\"", block)
+
+    def test_relation_and_attachment_bus(self):
+        self.assertIn("core.relation_stage = _rs_result", MAIN)
+        self.assertIn('self._x_pairs.append(("relation_stage", _rs_dir))', MAIN)
+        self.assertIn("core.attachment_behavior = _ab_result", MAIN)
+        self.assertIn(
+            'self._x_pairs.append(\n                    ("attachment_behavior", _ab_mod.directives(_ab_result)))',
+            MAIN)
+
+    def test_dissonance_and_narrative(self):
+        self.assertIn("core.dissonance = _di_mod3.strength(", MAIN)
+        self.assertIn('self._x_pairs.append(\n                        ("dissonance", _di_mod2.directives(_di_prev)))',
+                      MAIN)
+        self.assertIn("core.narrative = _na_mod.summarize(", MAIN)
+        self.assertIn('self._x_pairs.append(("narrative", _na_dir))', MAIN)
+
+    def test_reconstruction_meta_only(self):
+        self.assertIn("core.recall_meta = {", MAIN)
+        self.assertIn("core.recall_meta = {\n                    \"enabled\": True,",
+                      MAIN)
+        self.assertIn("_rm_mod.drift(", MAIN)
+        self.assertIn("_sm_mod.monitor(", MAIN)
+        block = MAIN[MAIN.index("task-174 reconstruction"):
+                     MAIN.index("from .biocore_model import runtime")]
+        for forbidden in ("_save_memory", "write_text", "_remember(", "json.dump"):
+            self.assertNotIn(forbidden, block)
+        self.assertIn("self._load_memory(event)", block)
+
+    def test_possible_selves_and_secrecy(self):
+        self.assertIn("core.possible_selves = _ps_mod.rank(", MAIN)
+        self.assertIn("core.secret = _se_state", MAIN)
+        self.assertIn("core.secret_view = _se_mod.view(_se_state)", MAIN)
+        # neither module contributes to the length/tone bus
+        self.assertNotIn('_x_pairs.append(("possible_selves"', MAIN)
+        self.assertNotIn('_x_pairs.append(("secrecy"', MAIN)
+
+    def test_compassion_fatigue(self):
+        self.assertIn("core.compassion_fatigue = _cf_result", MAIN)
+        self.assertIn('self._x_pairs.append(("compassion_fatigue", _cf_dir))',
+                      MAIN)
+
+
+class PanelTest(unittest.TestCase):
+    def test_status_keys(self):
+        for key in ("narrative", "possible_selves", "secrecy"):
+            self.assertIn('"%s": (self._%s_payload()' % (key, key), MAIN)
+            self.assertIn('"%s": (self._%s_payload()' % (key, key), ROUTES)
+
+    def test_dashboard_rows(self):
+        for ident in ("narrativeNote", "possibleSelfNote", "secrecyNote"):
+            self.assertIn('id="%s"' % ident, SRC_HTML)
+            self.assertIn('id="%s"' % ident, INDEX_HTML)
+            self.assertIn('$("%s")' % ident, APP_JS)
+        self.assertIn("一致 ", SRC_HTML)
+        self.assertIn("矛盾", SRC_HTML)
+        self.assertIn("修复", SRC_HTML)
+
+
+class ValueOrderBehaviourTest(unittest.TestCase):
+    def test_security_keeps_status_quo(self):
+        weights = vo.normalize({"security": 0.95, "tradition": 0.9})
+        result = vo.rank([{"name": "改", "gains": {"security": 0.2}},
+                          {"name": "不变", "gains": {"security": 0.0},
+                           "keeps_status_quo": True}],
+                         weights, {"relationship_age_days": 365})
+        self.assertEqual(result["chosen"], "不变")
+        self.assertIn("ranked", result)
+
+
+class StageAttachmentTest(unittest.TestCase):
+    def test_low_stage_and_avoidant(self):
+        low = rs.evaluate({"interactions": 0})
+        self.assertIn(low["stage"], ("陌生", "熟悉"))
+        self.assertTrue(rs.directives(low)["length_scale"] <= 1.0)
+        av = ab.evaluate("avoidant", {"closeness": 0.3, "stress": 0.8})
+        self.assertGreater(av["withdrawal"], av["initiative"])
+        self.assertLessEqual(ab.directives(av)["proactive"], 0.5)
+
+
+class DissonanceNarrativeTest(unittest.TestCase):
+    def test_dissonance_high_has_tone(self):
+        out = di.strength([{"text": "我不熬夜"}],
+                          {"kind": "stay_up", "contradicts": ["熬夜"],
+                           "salience": 1.0})
+        self.assertGreater(out["dissonance"], 0.0)
+        self.assertTrue(di.directives(out)["tone"])
+
+    def test_narrative_metrics(self):
+        events = [
+            {"ts": 1, "text": "吵架", "kind": "rupture", "valence": -0.8,
+             "importance": 0.9},
+            {"ts": 2, "text": "和好", "kind": "repair", "valence": 0.7,
+             "importance": 0.8},
+        ]
+        out = na.summarize(events)
+        for key in ("consistency", "contradiction", "repair"):
+            self.assertIn(key, out["metrics"])
+        self.assertTrue(out["entries"])
+
+
+class RecallMetaTest(unittest.TestCase):
+    def test_important_memory_does_not_drift(self):
+        out = rc.drift({"text": "重要的事", "importance": 0.95},
+                       mood=0.9, recalls=5)
+        self.assertEqual(out["delta"], 0.0)
+        self.assertIn("重要记忆不漂", out["reason"])
+
+    def test_source_monitoring_reports(self):
+        out = sm.monitor({"source": "told", "age_days": 300,
+                          "valence": -0.5, "importance": 0.7},
+                         {"valence": -0.6, "arousal": 0.6})
+        self.assertTrue(out["enabled"])
+        self.assertIn(out["source"], sm.SOURCES)
+        self.assertGreaterEqual(out["misattribution"], 0.0)
+
+
+class PossibleSelvesSecrecyTest(unittest.TestCase):
+    def test_possible_selves_sentence(self):
+        out = ps.rank([{"name": "更会照顾人",
+                        "target": {"benevolence": 0.9}, "importance": 0.8}],
+                      {"benevolence": 0.3})
+        self.assertTrue(out["sentence"].startswith("她还想成为"))
+        self.assertEqual(out["top"], "更会照顾人")
+
+    def test_secrecy_withhold_high_sensitivity(self):
+        out = se.decide(0.95, 0.15, 0.2)
+        self.assertEqual(out["action"], "withhold")
+        self.assertGreater(out["pressure_add"], 0.0)
+        state = se.update(se.initial(1), 0.95, 0.15, 0.2, now=10)
+        self.assertGreaterEqual(state["withholds"], 1)
+        self.assertIn("pressure", se.view(state))
+
+
+class RollbackTest(unittest.TestCase):
+    def test_guard_literals(self):
+        for key in SWITCHES:
+            self.assertIn('if bool(getattr(self, "%s", True)):' % key, MAIN)
+
+
+class PurityTest(unittest.TestCase):
+    def test_modules_stay_pure(self):
+        for name in ("value_order", "dissonance", "attachment_behavior",
+                     "relation_stage", "narrative", "reconstruction",
+                     "source_monitoring", "possible_selves",
+                     "compassion_fatigue", "secrecy"):
+            tree = ast.parse((ROOT / "biocore_model" / (name + ".py"))
+                             .read_text(encoding="utf-8"))
+            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)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_bio_tick.py

@@ -0,0 +1,202 @@
+# -*- coding: utf-8 -*-
+"""Life-maintenance tick tests: decay, intero, needs, threshold, idempotency."""
+import os
+import time
+import unittest
+from pathlib import Path
+from unittest import mock
+
+from biocore_model import bio_tick as bt
+from biocore_model import sleep_circadian as sleep
+
+
+class FakeCore:
+    def __init__(self, **kw):
+        self.v = 0.0
+        self.a = 0.5
+        self.d = 0.55
+        self.social = 0.5
+        self.stress = 0.2
+        self.energy = 0.6
+        self.trust = 0.5
+        self.labels = {"emotion": "neutral"}
+        self.emotion_decay_factors = {"neutral": 1.0}
+        self.valence_decay_minutes = 120.0
+        self.arousal_decay_minutes = 30.0
+        self.social_decay_minutes = 180.0
+        self.circadian_alertness = 0.5
+        self.allostatic_load = 0.0
+        self.needs = None
+        self.sleep_debt = 0.0
+        self.last_debt_ts = 0.0
+        self.last_bio_tick_ts = 0.0
+        self._bio_tick_count = 0
+        self.relationship_context = {"state": {"conflict": 0.0, "closeness": 0.5}}
+        self.pending_intent = None
+        self.intero = None
+        self._metabolic_energy_offset = 0.0
+        for key, value in kw.items():
+            setattr(self, key, value)
+
+    def snapshot(self):
+        return {"v": self.v, "a": self.a, "d": self.d, "social": self.social,
+                "stress": self.stress, "energy": self.energy,
+                "trust": self.trust, "labels": dict(self.labels),
+                "sleep_debt": self.sleep_debt,
+                "allostatic_load": self.allostatic_load}
+
+
+def _now(hour=12):
+    return time.mktime((2026, 1, 1, hour, 0, 0, 0, 0, -1))
+
+
+class DecayTest(unittest.TestCase):
+    def test_valence_decays_to_zero(self):
+        core = FakeCore(v=-0.5)
+        out = bt.bio_tick(core, now=1000.0, dt_hours=1.0)
+        self.assertAlmostEqual(core.v, -0.5 * 0.5 ** 0.5, places=4)
+        self.assertTrue(out["changed"])
+
+    def test_arousal_regresses_to_baseline(self):
+        core = FakeCore(a=0.8)
+        bt.bio_tick(core, now=1000.0, dt_hours=1.0)
+        self.assertAlmostEqual(core.a, 0.50, places=4)
+
+    def test_social_regresses_to_baseline(self):
+        core = FakeCore(social=0.2)
+        bt.bio_tick(core, now=1000.0, dt_hours=1.0)
+        expected = 0.55 + (0.2 - 0.55) * (0.5 ** (60.0 / 180.0))
+        self.assertAlmostEqual(core.social, expected, places=4)
+
+    def test_stress_re_derived_from_affect(self):
+        core = FakeCore(v=-0.4, a=0.7, d=0.6, social=0.5)
+        bt.bio_tick(core, now=1000.0, dt_hours=1.0)
+        expected = (0.45 * max(0.0, -core.v) * core.a + 0.35 * (1.0 - core.d)
+                    + 0.20 * (1.0 - core.social))
+        self.assertAlmostEqual(core.stress, expected, places=2)
+
+    def test_dt_cap_at_six_hours(self):
+        core = FakeCore(v=-1.0)
+        out = bt.bio_tick(core, now=1000.0, dt_hours=100.0)
+        self.assertEqual(out["dt_hours"], 6.0)
+        self.assertAlmostEqual(core.v, -1.0 * 0.5 ** (360.0 / 120.0), places=4)
+
+
+class InteroNeedsTest(unittest.TestCase):
+    def test_intero_updated_and_ts_set(self):
+        core = FakeCore(stress=0.6, a=0.7)
+        out = bt.bio_tick(core, now=1234.0, dt_hours=1.0)
+        self.assertEqual(out["intero"]["ts"], 1234.0)
+        self.assertIs(core.intero, out["intero"])
+        for dim in ("tension", "warmth", "heaviness", "clarity"):
+            self.assertGreaterEqual(out["intero"][dim], 0.0)
+            self.assertLessEqual(out["intero"][dim], 1.0)
+
+    def test_needs_step_runs(self):
+        core = FakeCore()
+        out = bt.bio_tick(core, now=5000.0, dt_hours=1.0)
+        self.assertEqual(core.needs["last_tick_ts"], 5000.0)
+        bt.bio_tick(core, now=8600.0, dt_hours=1.0)  # second tick applies the silence delta
+        self.assertLess(core.needs["belonging"], 0.6)
+        self.assertIn("needs", out["log"])
+
+    def test_sleep_debt_accumulates(self):
+        core = FakeCore()
+        bt.bio_tick(core, now=5000.0, dt_hours=2.0)
+        self.assertAlmostEqual(core.sleep_debt, 1.0, places=3)
+        self.assertEqual(core.last_debt_ts, 5000.0)
+
+    def test_circadian_alertness_set_from_now(self):
+        core = FakeCore()
+        now = _now(3)
+        bt.bio_tick(core, now=now, dt_hours=1.0)
+        self.assertAlmostEqual(core.circadian_alertness,
+                               sleep.circadian(time.localtime(now).tm_hour), places=4)
+
+    def test_allostatic_load_grows_under_stress(self):
+        core = FakeCore(stress=0.9)
+        bt.bio_tick(core, now=1000.0, dt_hours=0.0)  # no affect decay: keep stress high
+        self.assertGreater(core.allostatic_load, 0.0)
+
+
+class IdempotencyTest(unittest.TestCase):
+    def test_same_now_only_applies_once(self):
+        core = FakeCore(v=-0.6, a=0.8)
+        first = bt.bio_tick(core, now=2000.0, dt_hours=1.0)
+        v1, a1, count1 = core.v, core.a, core._bio_tick_count
+        second = bt.bio_tick(core, now=2000.0, dt_hours=1.0)
+        self.assertFalse(first["idempotent"])
+        self.assertTrue(second["idempotent"])
+        self.assertFalse(second["changed"])
+        self.assertEqual((core.v, core.a, core._bio_tick_count), (v1, a1, count1))
+
+    def test_log_throttled_every_ten_ticks(self):
+        core = FakeCore()
+        emits = []
+        for index in range(10):
+            out = bt.bio_tick(core, now=1000.0 + index * 3600.0, dt_hours=1.0)
+            emits.append(out["log"]["emit"])
+        self.assertTrue(emits[0])  # first tick always emits (first-run visibility)
+        self.assertEqual(emits[1:9], [False] * 8)
+        self.assertTrue(emits[9])
+        self.assertEqual(out["log"]["count"], 10)
+
+    def test_env_forces_every_tick(self):
+        core = FakeCore()
+        with mock.patch.dict(os.environ, {"BIOCORE_BIO_TICK_LOG": "1"}):
+            emits = [bt.bio_tick(core, now=5000.0 + index * 3600.0,
+                                 dt_hours=1.0)["log"]["emit"] for index in range(5)]
+        self.assertEqual(emits, [True] * 5)
+
+
+class PendingIntentTest(unittest.TestCase):
+    def test_high_discomfort_triggers_intent(self):
+        core = FakeCore(stress=0.9, a=0.8, sleep_debt=0.8, v=-0.6, social=0.3,
+                        trust=0.3, d=0.4, energy=0.2, allostatic_load=0.5,
+                        labels={"emotion": "sadness"})
+        core.relationship_context = {"state": {"conflict": 0.6, "closeness": 0.2}}
+        core.intero = {"tension": 0.90, "warmth": 0.10, "heaviness": 0.90,
+                      "clarity": 0.20, "ts": 0.0}
+        out = bt.bio_tick(core, now=3000.0, dt_hours=0.1)
+        self.assertGreater(out["discomfort"], bt.DISCOMFORT_TRIGGER)
+        intent = out["pending_intent"]
+        self.assertIsInstance(intent, dict)
+        self.assertIn(intent["action"], ("approach", "share", "question",
+                                         "withdraw", "repair", "rest"))
+        self.assertEqual(intent["source"], "bio_tick")
+        self.assertTrue(intent["reason"])
+
+    def test_calm_state_keeps_pending_intent_empty(self):
+        core = FakeCore()
+        out = bt.bio_tick(core, now=3000.0, dt_hours=1.0)
+        self.assertLessEqual(out["discomfort"], bt.DISCOMFORT_TRIGGER)
+        self.assertIsNone(out["pending_intent"])
+        self.assertIsNone(out["action"])
+
+
+class PurityTest(unittest.TestCase):
+    def test_source_has_no_llm_or_main_import(self):
+        source = Path(bt.__file__).read_text(encoding="utf-8").lower()
+        self.assertNotIn("llm", source)
+        self.assertNotIn("import main", source)
+        self.assertNotIn("from main", source)
+        self.assertNotIn("requests", source)
+        self.assertNotIn("httpx", source)
+
+    def test_memory_maintenance_throttle_and_forget(self):
+        core = FakeCore()
+        core.memory_entries = [
+            {"id": "a", "retrieval_s": 0.8},
+            {"id": "b", "retrieval_s": 0.01},
+        ]
+        first = bt.memory_maintenance(core, now=1000.0, dt_hours=1.0)
+        self.assertFalse(first["skipped"])
+        self.assertEqual(first["decayed"], 2)
+        self.assertGreaterEqual(first["forgotten"], 1)
+        second = bt.memory_maintenance(core, now=1200.0, dt_hours=1.0)
+        self.assertTrue(second["skipped"])
+        self.assertEqual(second["reason"], "throttled")
+
+
+if __name__ == "__main__":
+    unittest.main()