dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_growth.py

@@ -0,0 +1,301 @@
+# -*- coding: utf-8 -*-
+"""task-220: growth metrics + read-only consolidation dry-run."""
+import json
+import tempfile
+import unittest
+from pathlib import Path
+
+from biocore_runtime import growth
+
+
+NOW = 1700000000.0
+
+
+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")
+
+
+def memory(entry_id, text, ts=NOW, importance=0.5, affect=None):
+    row = {"id": entry_id, "text": text, "role": "user", "ts": ts,
+           "importance": importance, "hits": 1}
+    if affect is not None:
+        row["affect"] = affect
+    return row
+
+
+def trace_row(ts, ids, top=None, intent=""):
+    mem = {"recalled_ids": list(ids), "captured_id": ""}
+    if top is not None:
+        mem["top_score"] = top
+    return {"ts": ts, "session_id": "s1", "state_delta": [],
+            "intent": {"kind": intent, "weight": 0.0, "reason": ""},
+            "constraints": {}, "length": {"scale": 1.0, "source": "state"},
+            "gate": {"action": "pass", "rule": "", "label": ""},
+            "memory": mem, "modules": {"ran": [], "skipped": []}}
+
+
+class StoreCase(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.root = Path(self.tmp.name) / "store"
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def build(self, entries=None, state=None, traces=None,
+              relationship=None, flags=None, history=None):
+        session = self.root / "sessions" / "s1"
+        write_json(session / "memory.json",
+                   {"session_id": "s1", "entries": entries or []})
+        write_json(session / "state.json", state or {"v": 0.2, "a": 0.4})
+        if traces:
+            trace_file = self.root / "traces" / "s1.jsonl"
+            trace_file.parent.mkdir(parents=True, exist_ok=True)
+            trace_file.write_text("\n".join(
+                json.dumps(row, ensure_ascii=False) for row in traces) + "\n",
+                encoding="utf-8")
+        if relationship is not None:
+            write_json(self.root / "relationship.json",
+                       {"schema_version": 1, "version": 3,
+                        "updated_ts": NOW, "relationship": relationship})
+        if flags is not None:
+            write_json(self.root / "flags.json", flags)
+        if history is not None:
+            (self.root / "growth_history.jsonl").write_text(
+                "\n".join(json.dumps(row, ensure_ascii=False)
+                           for row in history) + "\n", encoding="utf-8")
+        return str(self.root)
+
+    def snapshot(self):
+        files = {}
+        base = self.root / "sessions"
+        for path in sorted(base.rglob("*")):
+            if path.is_file():
+                files[str(path)] = path.read_bytes()
+        return files
+
+
+class SwitchTest(StoreCase):
+    def test_default_off(self):
+        self.assertFalse(growth.enabled({}))
+        self.assertTrue(growth.enabled({}, {"BIOCORE_GROWTH_REPORT": "1"}))
+        self.assertTrue(growth.enabled({"growth_report": True}))
+        self.assertFalse(growth.enabled({"growth_report": False},
+                                        {"BIOCORE_GROWTH_REPORT": "1"}))
+
+    def test_disabled_writes_no_report(self):
+        store = self.build(entries=[memory("a", "hello")])
+        out = growth.consolidate(store, now=NOW)
+        self.assertFalse(out["ok"])
+        self.assertEqual(out["reason"], "disabled")
+        self.assertFalse((Path(store) / "consolidate_report.json").exists())
+
+
+class MetricsTest(StoreCase):
+    def test_empty_store(self):
+        store = self.build()
+        out = growth.metrics(store, now=NOW)
+        self.assertEqual(out["memory"]["total"], 0)
+        self.assertEqual(out["memory"]["with_affect_ratio"], 0.0)
+        self.assertEqual(out["recall"]["hits_total"], 0)
+        self.assertIsNone(out["recall"]["avg_top_score"])
+        self.assertEqual(out["narrative"]["top_intents"], [])
+        self.assertEqual(out["relation"]["change_7d"],
+                         {"trust": 0.0, "closeness": 0.0})
+        self.assertEqual(out["relation"]["change_basis"], "no_history")
+
+    def test_fields_present(self):
+        store = self.build(entries=[memory("a", "hello")])
+        out = growth.metrics(store, now=NOW)
+        for key in ("total", "added_this_week", "avg_importance",
+                    "with_affect", "with_affect_ratio"):
+            self.assertIn(key, out["memory"])
+        for key in ("hits_total", "mood_match_hits", "avg_top_score",
+                    "score_source"):
+            self.assertIn(key, out["recall"])
+        for key in ("trust", "closeness", "change_7d", "change_basis"):
+            self.assertIn(key, out["relation"])
+        self.assertIn("top_intents", out["narrative"])
+        for key in growth.LEARNING_FLAGS:
+            self.assertIn(key, out["flags"])
+
+    def test_memory_metrics(self):
+        store = self.build(entries=[
+            memory("a", "one", ts=NOW - 86400, importance=0.6,
+                   affect={"valence": 0.4, "arousal": 0.5}),
+            memory("b", "two", ts=NOW - 2 * 86400, importance=0.8,
+                   affect={"valence": -0.3, "arousal": 0.6}),
+            memory("c", "three", ts=NOW - 10 * 86400, importance=0.4),
+        ])
+        out = growth.metrics(store, now=NOW)["memory"]
+        self.assertEqual(out["total"], 3)
+        self.assertEqual(out["added_this_week"], 2)
+        self.assertAlmostEqual(out["avg_importance"], 0.6, places=4)
+        self.assertEqual(out["with_affect"], 2)
+        self.assertAlmostEqual(out["with_affect_ratio"], 0.6667, places=3)
+
+    def test_recall_metrics(self):
+        store = self.build(
+            entries=[
+                memory("a", "one", affect={"valence": 0.8, "arousal": 0.7}),
+                memory("b", "two", affect={"valence": -0.8, "arousal": 0.1}),
+                memory("c", "three", affect={"valence": -0.9, "arousal": 0.2}),
+            ],
+            state={"v": 0.8, "a": 0.7},
+            traces=[trace_row(NOW - 30, ["a", "b"], top=0.8, intent="陪伴"),
+                    trace_row(NOW - 20, ["c"], intent="陪伴"),
+                    trace_row(NOW - 10, [], intent="好奇")])
+        out = growth.metrics(store, now=NOW)["recall"]
+        self.assertEqual(out["hits_total"], 3)
+        self.assertEqual(out["mood_match_hits"], 1)
+        self.assertAlmostEqual(out["avg_top_score"], 0.8, places=4)
+        self.assertEqual(out["score_source"], "trace")
+
+    def test_avg_top_score_unavailable(self):
+        store = self.build(
+            entries=[memory("a", "one")],
+            traces=[trace_row(NOW, ["a"])])
+        out = growth.metrics(store, now=NOW)["recall"]
+        self.assertIsNone(out["avg_top_score"])
+        self.assertEqual(out["score_source"], "unavailable")
+
+    def test_narrative_top3(self):
+        store = self.build(entries=[memory("a", "one")], traces=[
+            trace_row(NOW - 40, [], intent="陪伴"),
+            trace_row(NOW - 30, [], intent="陪伴"),
+            trace_row(NOW - 20, [], intent="好奇"),
+            trace_row(NOW - 10, [], intent="好奇"),
+            trace_row(NOW, [], intent="关心"),
+        ])
+        rows = growth.metrics(store, now=NOW)["narrative"]["top_intents"]
+        self.assertEqual(rows[0], {"kind": "陪伴", "count": 2})
+        self.assertEqual(len(rows), 3)
+
+    def test_relation_change_7d(self):
+        store = self.build(
+            relationship={"trust": 0.60, "closeness": 0.58},
+            history=[{"ts": NOW - 10 * 86400, "trust": 0.50,
+                      "closeness": 0.50},
+                     {"ts": NOW - 2 * 86400, "trust": 0.55,
+                      "closeness": 0.52}])
+        out = growth.metrics(store, now=NOW)["relation"]
+        self.assertAlmostEqual(out["change_7d"]["trust"], 0.10, places=4)
+        self.assertAlmostEqual(out["change_7d"]["closeness"], 0.08, places=4)
+        self.assertEqual(out["change_basis"], "seven_day")
+
+    def test_relation_change_uses_oldest_sample(self):
+        store = self.build(
+            relationship={"trust": 0.60, "closeness": 0.50},
+            history=[{"ts": NOW - 2 * 86400, "trust": 0.55,
+                      "closeness": 0.45}])
+        out = growth.metrics(store, now=NOW)["relation"]
+        self.assertAlmostEqual(out["change_7d"]["trust"], 0.05, places=4)
+        self.assertEqual(out["change_basis"], "oldest_sample")
+
+    def test_flags_from_parent_data_dir(self):
+        store = self.build(entries=[memory("a", "hello")])
+        write_json(Path(store).parent / "flags.json",
+                   {"memory_feedback": True})
+        out = growth.metrics(store, now=NOW)["flags"]["memory_feedback"]
+        self.assertEqual(out, {"enabled": True, "source": "flags.json"})
+
+    def test_flags_sources(self):
+        store = self.build(flags={"mood_recall": True})
+        out = growth.metrics(
+            store, now=NOW, flags={"affect_encoding": True},
+            env={"BIOCORE_PREFERENCE_DRIFT": "1"})["flags"]
+        self.assertEqual(out["mood_recall"],
+                         {"enabled": True, "source": "flags.json"})
+        self.assertEqual(out["affect_encoding"],
+                         {"enabled": True, "source": "flags"})
+        self.assertEqual(out["preference_drift"],
+                         {"enabled": True, "source": "env"})
+        self.assertEqual(out["memory_feedback"],
+                         {"enabled": False, "source": "default"})
+
+
+class ConsolidateTest(StoreCase):
+    def test_dry_run_does_not_write_memory(self):
+        store = self.build(entries=[
+            memory("a", "注意安全", ts=NOW - 30),
+            memory("b", "出门注意安全", ts=NOW - 20),
+            memory("c", "记得注意安全", ts=NOW - 10),
+        ])
+        before = self.snapshot()
+        growth.consolidate(store, now=NOW, enabled=True)
+        self.assertEqual(self.snapshot(), before)
+
+    def test_report_is_written(self):
+        store = self.build(entries=[memory("a", "注意安全")])
+        out = growth.consolidate(store, now=NOW, enabled=True)
+        path = Path(store) / "consolidate_report.json"
+        self.assertTrue(path.exists())
+        report = json.loads(path.read_text(encoding="utf-8"))
+        self.assertEqual(report["schema"], "bc.consolidate_report.v1")
+        self.assertTrue(report["dry_run"])
+        self.assertFalse(report["memory_written"])
+        self.assertIn("candidates", report)
+        self.assertEqual(out["report"], report)
+        self.assertTrue((Path(store) / "growth_history.jsonl").exists())
+
+    def test_idempotent_same_day(self):
+        store = self.build(
+            entries=[memory("a", "注意安全", ts=NOW - 30),
+                     memory("b", "注意安全", ts=NOW - 20)],
+            relationship={"trust": 0.8, "closeness": 0.7})
+        first = growth.consolidate(store, now=NOW, enabled=True)["report"]
+        second = growth.consolidate(store, now=NOW, enabled=True)["report"]
+        self.assertEqual(first, second)
+        lines = (Path(store) / "growth_history.jsonl").read_text(
+            encoding="utf-8").strip().splitlines()
+        self.assertEqual(len(lines), 1)
+
+    def test_repeated_topic_candidate(self):
+        store = self.build(entries=[
+            memory("a", "注意安全", ts=NOW - 30),
+            memory("b", "出门注意安全", ts=NOW - 20),
+            memory("c", "记得注意安全", ts=NOW - 10),
+        ])
+        report = growth.consolidate(store, now=NOW, enabled=True)["report"]
+        topic = [row for row in report["candidates"]
+                 if row["kind"] == "repeated_topic"]
+        self.assertTrue(topic)
+        self.assertEqual(topic[0]["topic"], "安全")
+        self.assertEqual(topic[0]["count"], 3)
+        self.assertEqual(topic[0]["dimension"], "security")
+        self.assertEqual(report["counts"]["repeated_topic"], len(topic))
+
+    def test_stable_relation_candidate(self):
+        store = self.build(
+            entries=[memory("a", "hello")],
+            relationship={"trust": 0.72, "closeness": 0.66,
+                          "conflict": 0.05, "days_known": 12,
+                          "attachment_style": "secure"})
+        report = growth.consolidate(store, now=NOW, enabled=True)["report"]
+        stable = [row for row in report["candidates"]
+                  if row["kind"] == "stable_relation"]
+        self.assertEqual(len(stable), 1)
+        self.assertAlmostEqual(stable[0]["trust"], 0.72, places=4)
+        self.assertIn("12", stable[0]["fact"])
+
+    def test_low_relation_has_no_candidate(self):
+        store = self.build(
+            entries=[memory("a", "hello")],
+            relationship={"trust": 0.4, "closeness": 0.5})
+        report = growth.consolidate(store, now=NOW, enabled=True)["report"]
+        self.assertEqual(report["counts"]["stable_relation"], 0)
+
+    def test_empty_store_report(self):
+        store = self.build()
+        report = growth.consolidate(store, now=NOW, enabled=True)["report"]
+        self.assertEqual(report["candidates"], [])
+        self.assertEqual(report["episodes"]["scanned"], 0)
+        self.assertEqual(report["counts"],
+                         {"repeated_topic": 0, "stable_relation": 0})
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_intent_render.py

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+"""HUMAN-6 intent rendering tests: tendency text without numbers/emotion words."""
+import unittest
+
+from biocore_model import intent_render as ir
+
+ACTIONS = ("approach", "share", "question", "withdraw", "repair", "rest")
+
+
+class RenderTest(unittest.TestCase):
+    def test_every_action_has_phrase(self):
+        for action in ACTIONS:
+            text = ir.render({"action": action})
+            self.assertEqual(text, ir.PHRASES[action])
+
+    def test_no_digits(self):
+        for action in ACTIONS:
+            self.assertTrue(ir.check(ir.render({"action": action}, tone="3 天后"))["ok"])
+
+    def test_no_emotion_words(self):
+        for action in ACTIONS:
+            text = ir.render({"action": action}, tone="难过 5 分", guard="别生气")
+            result = ir.check(text)
+            self.assertTrue(result["ok"], text)
+
+    def test_unknown_action_fallback(self):
+        self.assertIn(ir.FALLBACK, ir.render({"action": "explode"}))
+
+    def test_empty_intent_safe(self):
+        self.assertTrue(ir.render(None))
+        self.assertTrue(ir.render({}))
+
+    def test_deterministic(self):
+        self.assertEqual(ir.render({"action": "repair"}, tone="慢一点"),
+                         ir.render({"action": "repair"}, tone="慢一点"))
+
+
+class CheckSanitizeTest(unittest.TestCase):
+    def test_check_detects_problems(self):
+        result = ir.check("我有点难过 3 分")
+        self.assertFalse(result["ok"])
+        self.assertTrue(result["digits"])
+        self.assertIn("难过", result["emotion_words"])
+
+    def test_check_clean_text(self):
+        self.assertTrue(ir.check("想和你说说话")["ok"])
+
+    def test_sanitize_removes(self):
+        text = ir.sanitize("焦虑 12 分，想靠近")
+        self.assertTrue(ir.check(text)["ok"])
+
+    def test_tendency_mapping(self):
+        self.assertEqual(ir.tendency({"action": "approach"}), "approach")
+        self.assertEqual(ir.tendency({"action": "withdraw"}), "withdraw")
+        self.assertEqual(ir.tendency({"action": "rest"}), "withdraw")
+        self.assertEqual(ir.tendency(None), "neutral")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_intero_regulation.py

@@ -0,0 +1,224 @@
+# -*- coding: utf-8 -*-
+"""Interoception core + regulation loop tests (formulas, bands, actions)."""
+import math
+import unittest
+
+from biocore_model import intero_core as ic
+from biocore_model import regulation_loop as rl
+
+STATE = {"stress": 0.5, "arousal": 0.6, "sleep_debt": 0.4, "conflict": 0.2,
+         "v": 0.2, "social": 0.6, "trust": 0.7, "closeness": 0.5,
+         "sadness": 0.3, "allostatic_load": 0.2, "energy": 0.4,
+         "loneliness": 0.5, "noise": 0.3}
+
+GOOD = {"tension": 0.30, "warmth": 0.60, "heaviness": 0.30, "clarity": 0.70}
+SHUT = {"tension": 0.10, "warmth": 0.05, "heaviness": 0.05, "clarity": 0.05}
+OPEN = {"tension": 0.95, "warmth": 0.95, "heaviness": 0.95, "clarity": 0.95}
+
+
+class FormulaTest(unittest.TestCase):
+    def test_four_dimensions_exact(self):
+        out = ic.target(STATE)
+        self.assertAlmostEqual(out["tension"], 0.475, places=4)
+        self.assertAlmostEqual(out["warmth"], 0.605, places=4)
+        self.assertAlmostEqual(out["heaviness"], 0.35, places=4)
+        self.assertAlmostEqual(out["clarity"], 0.70, places=4)
+
+    def test_formula_matches_spec(self):
+        x = ic.inputs(STATE)
+        expect_tension = (0.45 * x["stress"] + 0.25 * x["arousal"]
+                          + 0.20 * x["sleep_debt"] + 0.10 * x["conflict"])
+        expect_warmth = (0.40 * ((x["v"] + 1.0) / 2.0) + 0.25 * x["social"]
+                         + 0.20 * x["trust"] + 0.15 * x["closeness"])
+        expect_heavy = (0.40 * x["sadness"] + 0.30 * x["allostatic_load"]
+                        + 0.20 * (1.0 - x["energy"]) + 0.10 * x["loneliness"])
+        expect_clarity = (0.40 * (1.0 - x["noise"]) + 0.30 * (1.0 - x["sleep_debt"])
+                          + 0.30 * (1.0 - abs(x["arousal"] - 0.5) * 2.0))
+        out = ic.target(STATE)
+        self.assertAlmostEqual(out["tension"], round(expect_tension, 4))
+        self.assertAlmostEqual(out["warmth"], round(expect_warmth, 4))
+        self.assertAlmostEqual(out["heaviness"], round(expect_heavy, 4))
+        self.assertAlmostEqual(out["clarity"], round(expect_clarity, 4))
+
+    def test_clamped_boundaries(self):
+        out = ic.target({"stress": 5, "arousal": -3, "sleep_debt": -2,
+                         "conflict": 9, "v": -9, "social": 9, "trust": -4,
+                         "closeness": 9, "sadness": 9, "allostatic_load": -1,
+                         "energy": -9, "loneliness": 9, "noise": 9})
+        for dim in ic.DIMS:
+            self.assertGreaterEqual(out[dim], 0.0)
+            self.assertLessEqual(out[dim], 1.0)
+
+    def test_defaults_on_empty_state(self):
+        out = ic.target({})
+        self.assertAlmostEqual(out["tension"], 0.125, places=4)
+        self.assertAlmostEqual(out["warmth"], 0.50, places=4)
+        self.assertAlmostEqual(out["heaviness"], 0.09, places=4)
+        self.assertAlmostEqual(out["clarity"], 1.00, places=4)
+
+    def test_arousal_alias_and_label_fallbacks(self):
+        self.assertAlmostEqual(ic.inputs({"a": 0.9})["arousal"], 0.9)
+        sad = ic.inputs({"labels": {"emotion": "sadness"}, "intensity": 0.8})
+        self.assertAlmostEqual(sad["sadness"], 0.8)
+        lone = ic.inputs({"labels": {"emotion": "loneliness"}, "intensity": 0.6})
+        self.assertAlmostEqual(lone["loneliness"], 0.6)
+
+    def test_noise_dict_is_averaged(self):
+        self.assertAlmostEqual(ic.inputs({"noise": {"a": 0.2, "b": -0.4}})["noise"], 0.3)
+
+
+class UpdateTest(unittest.TestCase):
+    def test_ema_moves_toward_target(self):
+        prev = dict(GOOD)
+        new = ic.update(prev, STATE, dt_hours=1.0, rate=0.25)
+        alpha = 1.0 - math.exp(-0.25)
+        goal = ic.target(STATE)
+        for dim in ic.DIMS:
+            expect = round(prev[dim] + alpha * (goal[dim] - prev[dim]), 4)
+            self.assertAlmostEqual(new[dim], expect, places=4)
+
+    def test_zero_dt_is_identity(self):
+        prev = {"tension": 0.1, "warmth": 0.7, "heaviness": 0.2, "clarity": 0.9}
+        out = ic.update(prev, STATE, dt_hours=0.0)
+        for dim in ic.DIMS:
+            self.assertAlmostEqual(out[dim], prev[dim])
+
+    def test_same_now_is_idempotent(self):
+        prev = {"tension": 0.1, "warmth": 0.7, "heaviness": 0.2,
+                "clarity": 0.9, "ts": 1000.0}
+        out = ic.update(prev, STATE, dt_hours=1.0, now=1000.0)
+        for dim in ic.DIMS:
+            self.assertAlmostEqual(out[dim], prev[dim])
+        self.assertEqual(out["ts"], 1000.0)
+
+    def test_dt_derived_from_now_and_ts(self):
+        prev = {"tension": 0.1, "warmth": 0.7, "heaviness": 0.2,
+                "clarity": 0.9, "ts": 0.0}
+        a = ic.update(prev, STATE, dt_hours=1.0)
+        b = ic.update(prev, STATE, now=3600.0)
+        for dim in ic.DIMS:
+            self.assertAlmostEqual(a[dim], b[dim])
+
+    def test_converges_after_many_steps(self):
+        cur = {"tension": 0.0, "warmth": 0.0, "heaviness": 0.0, "clarity": 0.0}
+        goal = ic.target(STATE)
+        for _ in range(200):
+            cur = ic.update(cur, STATE, dt_hours=1.0, rate=0.25)
+        for dim in ic.DIMS:
+            self.assertAlmostEqual(cur[dim], goal[dim], places=2)
+
+
+class DiscomfortTest(unittest.TestCase):
+    def test_inside_band_is_zero(self):
+        self.assertEqual(ic.discomfort(GOOD)["total"], 0.0)
+        self.assertEqual(ic.discomfort(GOOD)["parts"], dict.fromkeys(ic.DIMS, 0.0))
+
+    def test_outside_band_positive_and_bounded(self):
+        shut = ic.discomfort(SHUT)
+        self.assertGreater(shut["total"], 0.0)
+        self.assertLessEqual(shut["total"], 1.0)
+        self.assertGreater(shut["parts"]["tension"], 0.0)
+        self.assertGreater(shut["parts"]["warmth"], 0.0)
+
+    def test_extremes_are_bounded_and_high(self):
+        self.assertGreater(ic.discomfort(OPEN)["total"], 0.6)
+        worst = {"tension": 1.0, "warmth": 0.0, "heaviness": 1.0, "clarity": 0.0}
+        self.assertAlmostEqual(ic.discomfort(worst)["total"], 1.0, places=2)
+
+    def test_setpoint_override(self):
+        override = {"comfort": {"tension": 0.90}, "band": {"tension": 0.05}}
+        flat = ic.discomfort(GOOD)
+        moved = ic.discomfort(GOOD, override)
+        self.assertGreater(moved["total"], flat["total"])
+
+    def test_view_shape(self):
+        out = ic.view(SHUT)
+        for dim in ic.DIMS:
+            self.assertIn(dim, out)
+        self.assertIn("discomfort", out)
+        self.assertAlmostEqual(out["discomfort"], ic.discomfort(SHUT)["total"])
+
+
+class ChooseActionTest(unittest.TestCase):
+    def _pick(self, intero, context=None):
+        out = rl.choose_action(intero, context)
+        self.assertIn(out["action"], rl.ACTIONS)
+        self.assertTrue(out["reason"])
+        self.assertGreaterEqual(out["expected_gain"], 0.0)
+        self.assertLessEqual(out["expected_gain"], 1.0)
+        return out["action"]
+
+    def test_conflict_plus_tension_repairs(self):
+        self.assertEqual(self._pick({"tension": 0.80, "warmth": 0.40,
+                                     "heaviness": 0.20, "clarity": 0.70},
+                                    {"conflict": 0.6}), "repair")
+
+    def test_tense_but_warm_approaches(self):
+        self.assertEqual(self._pick({"tension": 0.70, "warmth": 0.50,
+                                     "heaviness": 0.20, "clarity": 0.70},
+                                    {"conflict": 0.0}), "approach")
+
+    def test_heavy_exhausted_rests(self):
+        self.assertEqual(self._pick({"tension": 0.30, "warmth": 0.50,
+                                     "heaviness": 0.80, "clarity": 0.60},
+                                    {"energy": 0.10}), "rest")
+
+    def test_heavy_low_energy_withdraws(self):
+        self.assertEqual(self._pick({"tension": 0.30, "warmth": 0.50,
+                                     "heaviness": 0.80, "clarity": 0.60},
+                                    {"energy": 0.30}), "withdraw")
+
+    def test_unclear_asks(self):
+        self.assertEqual(self._pick({"tension": 0.30, "warmth": 0.55,
+                                     "heaviness": 0.20, "clarity": 0.20},
+                                    {"conflict": 0.4}), "question")
+
+    def test_cold_no_conflict_shares(self):
+        self.assertEqual(self._pick({"tension": 0.30, "warmth": 0.20,
+                                     "heaviness": 0.20, "clarity": 0.80},
+                                    {"conflict": 0.0}), "share")
+
+    def test_unclear_cold_shares(self):
+        self.assertEqual(self._pick({"tension": 0.30, "warmth": 0.40,
+                                     "heaviness": 0.20, "clarity": 0.20},
+                                    {"conflict": 0.0}), "share")
+
+    def test_warm_defaults_to_approach(self):
+        self.assertEqual(self._pick({"tension": 0.20, "warmth": 0.85,
+                                     "heaviness": 0.10, "clarity": 0.90}), "approach")
+
+
+class OutcomeEfficacyTest(unittest.TestCase):
+    def test_outcome_improved(self):
+        out = rl.outcome(SHUT, GOOD, "repair")
+        self.assertLess(out["delta_discomfort"], 0)
+        self.assertTrue(out["success"])
+        self.assertEqual(out["action"], "repair")
+
+    def test_outcome_worse(self):
+        out = rl.outcome(GOOD, SHUT, "share")
+        self.assertGreater(out["delta_discomfort"], 0)
+        self.assertFalse(out["success"])
+
+    def test_outcome_accepts_discomfort_dicts(self):
+        before = ic.discomfort(SHUT)
+        after = ic.discomfort(GOOD)
+        out = rl.outcome(before, after, "rest")
+        self.assertTrue(out["success"])
+
+    def test_efficacy_prior_and_ewma(self):
+        self.assertAlmostEqual(rl.efficacy([], "approach"), 0.5)
+        self.assertAlmostEqual(rl.efficacy([("approach", True)], "approach"), 0.625)
+        self.assertAlmostEqual(
+            rl.efficacy([("approach", True), ("approach", False)], "approach"), 0.4688)
+        self.assertAlmostEqual(rl.efficacy([("share", False)], "approach"), 0.5)
+
+    def test_efficacy_dict_rows_and_bounds(self):
+        rows = [{"action": "rest", "success": True} for _ in range(20)]
+        self.assertGreater(rl.efficacy(rows, "rest"), 0.9)
+        self.assertLessEqual(rl.efficacy(rows, "rest"), 1.0)
+        self.assertEqual(rl.sample("rest", True)["action"], "rest")
+
+
+if __name__ == "__main__":
+    unittest.main()