dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_migrate.py

@@ -0,0 +1,245 @@
+# -*- coding: utf-8 -*-
+"""Real old-layout migration test: 1.3.4 data -> 1.4.0, then idempotency."""
+import ast
+import json
+import os
+import tempfile
+import time
+import types
+import unittest
+from pathlib import Path
+
+from biocore_model import migrate
+
+
+class FakePlugin:
+    def __init__(self, data_dir):
+        self.data_dir = str(data_dir)
+
+    def _autonomy_params(self):
+        return {"theta": 0.5239, "cooldown_s": 1625, "daily_cap": 3,
+                "tau_hours": 16.0}
+
+
+def _old_layout(root):
+    data = Path(root) / "plugins" / "astrbot_plugin_biocore" / "data"
+    (data / "memory").mkdir(parents=True, exist_ok=True)
+    (data / "states").mkdir(parents=True, exist_ok=True)
+    (data / "ui_settings.json").write_text(json.dumps({
+        "autonomy": {"enabled": True, "threshold": 0.7,
+                     "accumulator": {"V": -0.16, "drift": 0.02,
+                                     "last_tick_ts": 123.0}},
+        "proactive_autonomy_threshold": 0.7,
+        "proactive_autonomy_max_chars": 120,
+        "schema": 1,
+    }, ensure_ascii=False), encoding="utf-8")
+    mem = data / "memory" / "s1.json"
+    mem.write_text(json.dumps({"entries": [
+        {"id": "m1", "text": "老记忆一"},
+        {"id": "m2", "text": "老记忆二"},
+        {"id": "m3", "text": "老记忆三"},
+    ]}, ensure_ascii=False), encoding="utf-8")
+    old = time.time() - 10 * 86400
+    os.utime(mem, (old, old))
+    (data / "states" / "u1.json").write_text(
+        json.dumps({"umo": "user-x"}), encoding="utf-8")
+    return data
+
+
+def _load_methods(names, namespace=None):
+    source = (Path(__file__).resolve().parents[2] / "main.py").read_text(
+        encoding="utf-8")
+    tree = ast.parse(source)
+    cls = next(n for n in tree.body
+               if isinstance(n, ast.ClassDef) and n.name == "BioCorePlugin")
+    ns = dict(namespace or {})
+    fns = {}
+    for node in cls.body:
+        if isinstance(node, ast.FunctionDef) and node.name in names:
+            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=[]), "<mig>", "exec"), ns)
+            fns[node.name] = ns[node.name]
+    return fns
+
+class _Recorder:
+    """Minimal logger stub; keeps tests free of the stdlib logging import."""
+
+    def __init__(self):
+        self.lines = []
+
+    def _log(self, msg, *args, **kwargs):
+        try:
+            self.lines.append(str(msg) % args if args else str(msg))
+        except Exception:
+            self.lines.append(str(msg))
+
+    debug = info = warning = error = exception = critical = _log
+
+
+class MigrationTest(unittest.TestCase):
+    def test_old_data_migrates_and_backfills(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            data = _old_layout(tmp)
+            plugin = FakePlugin(data)
+            rec = _Recorder()
+            saved_logger = migrate.logger
+            migrate.logger = rec
+            try:
+                report = migrate.migrate(plugin)
+            finally:
+                migrate.logger = saved_logger
+            self.assertEqual(report["applied"],
+                             ["settings", "accumulator", "memory"])
+            auth = (Path(tmp) / "plugin_data" / "astrbot_plugin_biocore"
+                    / "ui_settings.json")
+            saved = json.loads(auth.read_text(encoding="utf-8"))
+            self.assertEqual(saved.get("schema_version"),
+                             migrate.SCHEMA_VERSION)
+            acc = saved["autonomy"]["accumulator"]
+            self.assertAlmostEqual(float(acc["theta"]), 0.5239, places=3)
+            self.assertGreaterEqual(float(acc["V"]), 0.0)
+            self.assertEqual(acc["cooldown_seconds"], 1625)
+            self.assertEqual(acc["daily_cap"], 3)
+            self.assertEqual(acc["last_umo"], "user-x")
+            mem = json.loads((data / "memory" / "s1.json").read_text(
+                encoding="utf-8"))
+            self.assertEqual(len(mem["entries"]), 3)
+            for entry in mem["entries"]:
+                self.assertIn("storage_s", entry)
+                self.assertIn("retrieval_s", entry)
+                self.assertIn("access_count", entry)
+                self.assertIn("arousal_at_encoding", entry)
+                self.assertFalse(entry["hidden"])
+                self.assertGreater(entry["storage_s"], 0.0)
+            # Old 10-day file -> power-law retrieval below a fresh file.
+            self.assertLess(mem["entries"][0]["retrieval_s"], 0.5)
+            joined = "\n".join(rec.lines)
+            for token in ("migrate done:", "settings=", "accumulator=",
+                          "memory=", "warnings="):
+                self.assertIn(token, joined)
+
+    def test_schema_version_survives_ui_settings_save(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            data = _old_layout(tmp)
+            plugin = FakePlugin(data)
+            migrate.migrate(plugin)
+            from biocore_model import ui_settings
+            ui_settings.save(plugin, {"autonomy": {"send": True}})
+            auth = (Path(tmp) / "plugin_data" / "astrbot_plugin_biocore"
+                    / "ui_settings.json")
+            saved = json.loads(auth.read_text(encoding="utf-8"))
+            self.assertEqual(saved.get("schema_version"),
+                             migrate.SCHEMA_VERSION)
+            self.assertEqual(migrate.migrate(plugin)["applied"], [])
+
+    def test_second_run_is_idempotent(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            data = _old_layout(tmp)
+            plugin = FakePlugin(data)
+            migrate.migrate(plugin)
+            auth = (Path(tmp) / "plugin_data" / "astrbot_plugin_biocore"
+                    / "ui_settings.json")
+            mem = data / "memory" / "s1.json"
+            before_settings = auth.read_bytes()
+            before_mem = mem.read_bytes()
+            report = migrate.migrate(plugin)
+            self.assertEqual(report["applied"], [])
+            self.assertEqual(auth.read_bytes(), before_settings)
+            self.assertEqual(mem.read_bytes(), before_mem)
+
+    def test_fresh_install_is_noop_and_safe(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            fresh = Path(tmp) / "plugin_data" / "astrbot_plugin_biocore"
+            fresh.mkdir(parents=True)
+            plugin = FakePlugin(fresh)
+            report = migrate.migrate(plugin)
+            self.assertEqual(report["applied"], [])
+            self.assertEqual(report["warnings"], [])
+            auth = fresh / "ui_settings.json"
+            self.assertTrue(auth.is_file())
+            self.assertEqual(json.loads(auth.read_text(encoding="utf-8"))
+                             .get("schema_version"),
+                             migrate.SCHEMA_VERSION)
+
+
+if __name__ == "__main__":
+    unittest.main()
+
+class HardeningTest(unittest.TestCase):
+    def test_atomic_write_failure_leaves_no_tmp_or_partial(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            target = Path(tmp) / "x.json"
+            target.write_text('{"old": 1}', encoding="utf-8")
+            from unittest import mock
+            with mock.patch.object(migrate.os, "replace", side_effect=OSError("boom")):
+                with self.assertRaises(OSError):
+                    migrate._write(target, {"new": 2})
+            self.assertEqual(target.read_text(encoding="utf-8"), '{"old": 1}')
+            self.assertFalse((Path(tmp) / "x.json.tmp").exists())
+
+    def test_backup_contains_three_classes_and_migrates(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            data = _old_layout(tmp)
+            plugin = FakePlugin(data)
+            report = migrate.migrate(plugin)
+            backup = Path(report["backup_dir"])
+            self.assertTrue(backup.is_dir())
+            self.assertTrue((backup / "settings" / "ui_settings.json").is_file())
+            self.assertEqual(len(list((backup / "memory").glob("*.json"))), 1)
+            self.assertEqual(len(list((backup / "states").glob("*.json"))), 1)
+            self.assertIn("memory", report["applied"])
+
+    def test_failed_migration_keeps_old_files(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            data = _old_layout(tmp)
+            old_legacy = (data / "ui_settings.json").read_bytes()
+            plugin = FakePlugin(data)
+            from unittest import mock
+            with mock.patch.object(migrate, "_write", side_effect=OSError("disk")):
+                report = migrate.migrate(plugin)
+            self.assertTrue(report["warnings"])
+            self.assertEqual((data / "ui_settings.json").read_bytes(), old_legacy)
+            auth = Path(tmp) / "plugin_data" / "astrbot_plugin_biocore" / "ui_settings.json"
+            self.assertFalse(auth.exists())
+
+    def test_restore_brings_backup_back(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            data = _old_layout(tmp)
+            plugin = FakePlugin(data)
+            report = migrate.migrate(plugin)
+            backup = report["backup_dir"]
+            auth = (Path(tmp) / "plugin_data" / "astrbot_plugin_biocore"
+                    / "ui_settings.json")
+            auth.write_text("{}", encoding="utf-8")
+            mem = data / "memory" / "s1.json"
+            mem.write_text("{}", encoding="utf-8")
+            result = migrate.restore(backup, plugin)
+            self.assertTrue(result["ok"])
+            restored = json.loads(auth.read_text(encoding="utf-8"))
+            self.assertIn("autonomy", restored)
+            self.assertIn("entries", json.loads(mem.read_text(encoding="utf-8")))
+            self.assertGreaterEqual(result["restored"]["states"], 1)
+
+    def test_retry_path_runs_once(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            data = _old_layout(tmp)
+            plugin = FakePlugin(data)
+            ns = {"time": time, "logger": types.SimpleNamespace(
+                warning=lambda *a, **k: None, info=lambda *a, **k: None)}
+            fns = _load_methods(("_migration_payload", "_ensure_migration_retry_once"),
+                                namespace=ns)
+            for name, fn in fns.items():
+                setattr(plugin, name, types.MethodType(fn, plugin))
+            plugin._migration_retry_done = False
+            plugin._migration_report = {}
+            payload = plugin._ensure_migration_retry_once()
+            self.assertGreaterEqual(payload["schema_version"], 2)
+            first = (data / "ui_settings.json").read_bytes()
+            plugin._ensure_migration_retry_once()
+            self.assertEqual((data / "ui_settings.json").read_bytes(), first)
+

package/python/biocore_model/tests/test_migrate_store.py

@@ -0,0 +1,194 @@
+# -*- coding: utf-8 -*-
+"""Offline tests for biocore_model.migrate_store (temp dirs only)."""
+import json
+import os
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+from biocore_model import migrate_store
+
+
+def entry(**overrides):
+    value = {"id": "abc123", "text": "hello memory", "ts": 1700000000.0, "role": "user",
+             "importance": 0.8, "pin": True, "scope": "default", "tags": ["plan"]}
+    value.update(overrides)
+    return value
+
+
+class ConvertTest(unittest.TestCase):
+    def test_normal_mapping(self):
+        core, report = migrate_store.convert([entry()])
+        self.assertEqual(report["converted"], 1)
+        self.assertEqual(core[0]["id"], "abc123")
+        self.assertEqual(core[0]["text"], "hello memory")
+        self.assertEqual(core[0]["ts"], 1700000000.0)
+        self.assertEqual(core[0]["role"], "user")
+        self.assertEqual(core[0]["importance"], 0.8)
+        self.assertTrue(core[0]["pin"])
+        self.assertEqual(core[0]["tags"], ["plan"])
+        self.assertEqual(core[0]["client_scope"], "global")
+
+    def test_defaults_for_missing_optional_fields(self):
+        core, _ = migrate_store.convert([{"id": "x", "text": "only text"}])
+        self.assertEqual(core[0]["role"], "user")
+        self.assertEqual(core[0]["tags"], [])
+        self.assertEqual(core[0]["importance"], 0.5)
+        self.assertFalse(core[0]["pin"])
+        self.assertEqual(core[0]["client_scope"], "global")
+
+    def test_unknown_fields_are_reported_not_dropped_silently(self):
+        core, report = migrate_store.convert([entry(vector=[0.1, 0.2], sender_id="42", memory_tier="hot")])
+        self.assertEqual(report.get("unmapped_fields", {}).get("vector", 0), 0)
+        self.assertEqual(report["vectors_migrated"], 1)
+        self.assertEqual(report["unmapped_fields"]["sender_id"], 1)
+        self.assertEqual(report["unmapped_fields"]["memory_tier"], 1)
+        self.assertIn("vector", core[0])
+
+    def test_missing_text_is_skipped_and_counted(self):
+        core, report = migrate_store.convert([{"id": "a", "text": ""}, {"id": "b", "text": "ok"}])
+        self.assertEqual(report["converted"], 1)
+        self.assertEqual(report["skipped"], 1)
+        self.assertEqual(report["missing_required"]["text"], 1)
+        self.assertEqual(core[0]["id"], "b")
+
+    def test_empty_and_non_dict_entries(self):
+        core, report = migrate_store.convert([])
+        self.assertEqual((report["converted"], report["skipped"]), (0, 0))
+        core, report = migrate_store.convert([None, "nope", entry()])
+        self.assertEqual(report["converted"], 1)
+        self.assertEqual(report["skipped"], 2)
+
+    def test_generated_id_is_deterministic(self):
+        row = {"text": "no id here", "ts": 1700000001.0, "role": "user"}
+        first, report = migrate_store.convert([row])
+        second, _ = migrate_store.convert([row])
+        self.assertEqual(first[0]["id"], second[0]["id"])
+        self.assertEqual(len(first[0]["id"]), 12)
+        self.assertEqual(report["generated_ids"], 1)
+
+    def test_scope_mapping(self):
+        core, _ = migrate_store.convert([entry(scope="session:dsh-1"), dict(entry(), id="b", scope="default")])
+        self.assertEqual(core[0]["client_scope"], "session:dsh-1")
+        self.assertEqual(core[1]["client_scope"], "global")
+
+    def test_valid_at_is_carried(self):
+        core, _ = migrate_store.convert([entry(valid_at=1700000000.0)])
+        self.assertEqual(core[0]["valid_at"], 1700000000.0)
+
+    def test_convert_is_idempotent(self):
+        rows = [entry(), entry(id="b", text="second")]
+        first, report_first = migrate_store.convert(rows)
+        second, report_second = migrate_store.convert(rows)
+        self.assertEqual(first, second)
+        self.assertEqual(report_first, report_second)
+
+
+class SourceAndRunTest(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.root = Path(self.tmp.name)
+        self.store_file = self.root / "memory.json"
+        self.store_file.write_text(json.dumps({"entries": [entry()]}), encoding="utf-8")
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def test_detect_source_via_env(self):
+        with mock.patch.dict(os.environ, {migrate_store.SOURCE_ENV: str(self.store_file)}):
+            self.assertEqual(migrate_store.detect_source(), str(self.store_file))
+
+    def test_detect_source_from_launcher_layout(self):
+        plugin = self.root / "instances" / "inst1" / "core" / "data" / "plugin_data" / "astrbot_plugin_biocore_standalone"
+        memory = plugin / "memory"
+        memory.mkdir(parents=True)
+        (memory / "a.json").write_text(json.dumps({"entries": [entry()]}), encoding="utf-8")
+        with mock.patch.dict(os.environ, {migrate_store.SOURCE_ENV: ""}):
+            found = migrate_store.detect_source(candidates=[self.root / "instances"])
+        self.assertEqual(found, str(memory))
+
+    def test_detect_source_missing_returns_none(self):
+        empty = self.root / "nothing"
+        empty.mkdir()
+        with mock.patch.dict(os.environ, {migrate_store.SOURCE_ENV: ""}):
+            self.assertIsNone(migrate_store.detect_source(candidates=[empty]))
+
+    def test_corrupt_source_reports_and_skips(self):
+        corrupt = self.root / "bad.json"
+        corrupt.write_text("{ not json", encoding="utf-8")
+        result = migrate_store.run(src=str(corrupt))
+        self.assertEqual(result["corrupt_files"], 1)
+        self.assertEqual(result["error"], "corrupt_source")
+        self.assertFalse(result["applied"])
+
+    def test_dry_run_does_not_write(self):
+        dst = self.root / "out" / "memory.json"
+        result = migrate_store.run(src=str(self.store_file), dst=str(dst), apply=False)
+        self.assertTrue(result["ok"])
+        self.assertTrue(result["dry_run"])
+        self.assertFalse(result["applied"])
+        self.assertFalse(dst.exists())
+        self.assertEqual(result["converted"], 1)
+
+    def test_apply_writes_atomically(self):
+        dst = self.root / "out" / "memory.json"
+        result = migrate_store.run(src=str(self.store_file), dst=str(dst), apply=True)
+        self.assertTrue(result["applied"])
+        doc = json.loads(dst.read_text(encoding="utf-8"))
+        self.assertEqual(len(doc["entries"]), 1)
+        self.assertEqual(doc["schema_version"], 1)
+        self.assertEqual(list(dst.parent.glob("*.tmp")), [])
+
+    def test_target_non_empty_requires_force(self):
+        dst = self.root / "out" / "memory.json"
+        dst.parent.mkdir(parents=True)
+        dst.write_text(json.dumps({"entries": [{"id": "keep"}]}), encoding="utf-8")
+        blocked = migrate_store.run(src=str(self.store_file), dst=str(dst), apply=True)
+        self.assertEqual(blocked["error"], "target_not_empty")
+        self.assertFalse(blocked["applied"])
+        self.assertIn("keep", dst.read_text(encoding="utf-8"))
+        forced = migrate_store.run(src=str(self.store_file), dst=str(dst), apply=True, force=True)
+        self.assertTrue(forced["applied"])
+        self.assertEqual(len(json.loads(dst.read_text(encoding="utf-8"))["entries"]), 1)
+
+    def test_source_not_found_reports_error(self):
+        with mock.patch.dict(os.environ, {migrate_store.SOURCE_ENV: ""}):
+            result = migrate_store.run(src=str(self.root / "missing" / "memory.json"))
+        self.assertEqual(result["error"], "source_not_found")
+        self.assertFalse(result["ok"])
+
+    def test_apply_without_target_errors(self):
+        result = migrate_store.run(src=str(self.store_file), apply=True)
+        self.assertEqual(result["error"], "target_required")
+
+    def test_sample_contains_three_entries_max(self):
+        rows = [entry(id=str(index), text="memory " + str(index)) for index in range(5)]
+        src = self.root / "many.json"
+        src.write_text(json.dumps({"entries": rows}), encoding="utf-8")
+        result = migrate_store.run(src=str(src))
+        self.assertEqual(result["converted"], 5)
+        self.assertEqual(len(result["sample"]), 3)
+
+
+class VectorMigrationTest(unittest.TestCase):
+    def test_vector_is_kept_with_model(self):
+        entries = [{"id": "v1", "text": "hello", "vector": [0.1, 0.2, 0.3], "embedding_model": "m1"}]
+        core, report = migrate_store.convert(entries)
+        self.assertEqual(core[0]["vector"], [0.1, 0.2, 0.3])
+        self.assertEqual(core[0]["vector_model"], "m1")
+        self.assertEqual(report["vectors_migrated"], 1)
+        self.assertEqual(report["vectors_dropped"], 0)
+
+    def test_invalid_vector_is_dropped_and_counted(self):
+        entries = [{"id": "v2", "text": "hello", "vector": [0.1, "x", 0.3]}]
+        core, report = migrate_store.convert(entries)
+        self.assertNotIn("vector", core[0])
+        self.assertEqual(report["vectors_dropped"], 1)
+        self.assertEqual(report["vectors_migrated"], 0)
+
+    def test_empty_vector_is_dropped(self):
+        entries = [{"id": "v3", "text": "hello", "vector": []}]
+        core, report = migrate_store.convert(entries)
+        self.assertNotIn("vector", core[0])
+        self.assertEqual(report["vectors_dropped"], 0)

package/python/biocore_model/tests/test_mind_wander.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+"""HUMAN-4 mind wandering tests: weights, deterministic sampling, rumination bias."""
+import unittest
+
+from biocore_model import mind_wander as mw
+
+LOOPS = [{"topic": "calm", "tension": 0.0}, {"topic": "tense", "tension": 1.0}]
+
+
+class WeightTest(unittest.TestCase):
+    def test_weights_positive(self):
+        for weight in mw.weights(LOOPS, rumination=0.5):
+            self.assertGreater(weight, 0.0)
+
+    def test_rumination_boosts_tension(self):
+        calm, tense = mw.weights(LOOPS, rumination=1.0)
+        self.assertGreater(tense, calm)
+
+    def test_no_rumination_equal_tension(self):
+        loops = [{"topic": "a", "tension": 0.5}, {"topic": "b", "tension": 0.5}]
+        a, b = mw.weights(loops, rumination=0.0)
+        self.assertEqual(a, b)
+
+
+class ChooseTest(unittest.TestCase):
+    def test_deterministic(self):
+        self.assertEqual(mw.choose(LOOPS, 0.5, seed=4, now=9),
+                         mw.choose(LOOPS, 0.5, seed=4, now=9))
+
+    def test_fields(self):
+        row = mw.choose(LOOPS, 0.0, seed=1, now=1)
+        self.assertIn(row["topic"], ("calm", "tense"))
+        self.assertIn("weight", row)
+        self.assertIn("total", row)
+
+    def test_empty_returns_none(self):
+        self.assertIsNone(mw.choose([], 0.5, seed=1, now=1))
+
+    def test_single_item_always(self):
+        row = mw.choose([{"topic": "only", "tension": 0.1}], 0.9, seed=7, now=7)
+        self.assertEqual(row["topic"], "only")
+
+    def test_rumination_biases_tense(self):
+        picks = [mw.choose(LOOPS, 1.0, seed=index, now=index)["topic"]
+                 for index in range(30)]
+        self.assertGreaterEqual(picks.count("tense"), 18)
+
+
+class WanderTest(unittest.TestCase):
+    def test_limit_and_distinct(self):
+        rows = mw.wander(LOOPS, 0.2, seed=3, now=3, limit=2)
+        self.assertEqual(len(rows), 2)
+        self.assertNotEqual(rows[0]["topic"], rows[1]["topic"])
+
+    def test_does_not_mutate(self):
+        snapshot = [dict(row) for row in LOOPS]
+        mw.wander(LOOPS, 0.5, seed=2, now=2)
+        self.assertEqual(LOOPS, snapshot)
+
+    def test_seeded_helper(self):
+        self.assertIn(mw.seeded(5, now=5)["topic"], ("work", "friend", "rest"))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_mood.py

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import mood as mood_bio
+
+class MoodTest(unittest.TestCase):
+    def test_update_toward_target(self):
+        m = mood_bio.mood_update({'valence': 0.0, 'arousal': 0.0}, 1.0, 0.0)
+        self.assertGreater(m['valence'], 0); self.assertLess(m['valence'], 1)
+    def test_rate(self):
+        m = mood_bio.mood_update({'valence': 0.0, 'arousal': 0.0}, 1.0, 0.0, rate=0.05)
+        self.assertAlmostEqual(m['valence'], 0.05)
+    def test_idempotent_same_now(self):
+        m = mood_bio.mood_update({'valence': 0.0, 'arousal': 0.0}, 1.0, 0.0, now=100)
+        again = mood_bio.mood_update(m, 1.0, 0.0, now=100)
+        self.assertEqual(again['valence'], m['valence'])
+    def test_label_quadrants(self):
+        self.assertEqual(mood_bio.label({'valence': -0.5, 'arousal': 0.8}), '低落')
+        self.assertEqual(mood_bio.label({'valence': 0.5, 'arousal': 0.8}), '愉快')
+        self.assertEqual(mood_bio.label({'valence': 0.2, 'arousal': 0.2}), '平静偏正')
+        self.assertEqual(mood_bio.label({'valence': -0.2, 'arousal': 0.2}), '平静')
+    def test_view_fields(self):
+        v = mood_bio.mood_view({'valence': 0.1, 'arousal': 0.2})
+        for key in ('valence', 'arousal', 'label'): self.assertIn(key, v)
+    def test_half_life_ticks(self):
+        ticks = mood_bio.ticks_to_target(0.0, 1.0)
+        self.assertGreater(ticks, 40); self.assertLess(ticks, 100)
+    def test_clamp(self):
+        self.assertLessEqual(mood_bio.mood_update({'valence': 1.0}, 5.0, 0.0)['valence'], 1.0)
+        self.assertGreaterEqual(mood_bio.mood_update({'valence': -1.0}, -5.0, 0.0)['valence'], -1.0)
+    def test_zero_dt_no_change_without_now(self):
+        m = {'valence': 0.3, 'arousal': 0.2}
+        self.assertEqual(mood_bio.mood_update(m, 0.3, 0.2)['valence'], 0.3)
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_narrative.py

@@ -0,0 +1,114 @@
+# -*- coding: utf-8 -*-
+"""Narrative: chapters plus the three coherence metrics."""
+import unittest
+
+from biocore_model import narrative as nv
+
+DAY = 86400.0
+BASE = 1790000000.0
+
+
+def ev(kind, text, valence, day=0.0, importance=0.6):
+    return {"kind": kind, "text": text, "valence": valence,
+            "ts": BASE + day * DAY, "importance": importance}
+
+
+class EntriesTest(unittest.TestCase):
+    def test_empty(self):
+        self.assertEqual(nv.entries([]), [])
+
+    def test_theme_mapping(self):
+        rows = nv.entries([ev("rupture", "吵了一架", -0.6)])
+        self.assertEqual(rows[0]["theme"], "关系裂缝")
+
+    def test_unknown_kind_falls_back(self):
+        rows = nv.entries([ev("weird", "小事", 0.1)])
+        self.assertEqual(rows[0]["theme"], nv.DEFAULT_THEME)
+
+    def test_limit_and_newest_first(self):
+        events = [ev("gift", "第%d次" % i, 0.4, day=i) for i in range(10)]
+        rows = nv.entries(events, limit=3)
+        self.assertEqual(len(rows), 3)
+        self.assertEqual(rows[0]["ts"], BASE + 9 * DAY)
+
+    def test_dedupes_same_text(self):
+        events = [ev("gift", "同一句话", 0.4, day=0),
+                  ev("gift", "同一句话", 0.4, day=1)]
+        self.assertEqual(len(nv.entries(events)), 1)
+
+    def test_malformed_skipped(self):
+        rows = nv.entries([None, "x", {"text": ""}, ev("gift", "好", 0.3)])
+        self.assertEqual(len(rows), 1)
+
+
+class ConsistencyTest(unittest.TestCase):
+    def test_empty_is_zero(self):
+        self.assertEqual(nv.consistency([]), 0.0)
+
+    def test_all_positive(self):
+        events = [ev("gift", "a", 0.5), ev("gift", "b", 0.3)]
+        self.assertEqual(nv.consistency(events), 1.0)
+
+    def test_mixed_lowers(self):
+        events = [ev("gift", "a", 0.5), ev("gift", "b", -0.5)]
+        self.assertLess(nv.consistency(events), 1.0)
+
+
+class ContradictionTest(unittest.TestCase):
+    def test_none_when_same_sign(self):
+        events = [ev("rupture", "a", -0.5), ev("rupture", "b", -0.2)]
+        self.assertEqual(nv.contradiction(events), 0.0)
+
+    def test_detects_opposites(self):
+        events = [ev("rupture", "a", -0.5), ev("rupture", "b", 0.4)]
+        self.assertEqual(nv.contradiction(events), 1.0)
+
+
+class RepairTest(unittest.TestCase):
+    def test_none_without_negative(self):
+        self.assertEqual(nv.repair([ev("gift", "a", 0.5)]), 0.0)
+
+    def test_repair_within_window(self):
+        events = [ev("rupture", "吵", -0.6, day=0),
+                  ev("repair", "和好", 0.5, day=2)]
+        self.assertEqual(nv.repair(events), 1.0)
+
+    def test_no_repair_outside_window(self):
+        events = [ev("rupture", "吵", -0.6, day=0),
+                  ev("repair", "和好", 0.5, day=30)]
+        self.assertEqual(nv.repair(events), 0.0)
+
+    def test_repair_needs_same_theme(self):
+        events = [ev("rupture", "吵", -0.6, day=0),
+                  ev("gift", "收到礼物", 0.5, day=1)]
+        self.assertEqual(nv.repair(events), 0.0)
+
+
+class SummaryTest(unittest.TestCase):
+    def test_summary_shape(self):
+        events = [ev("rupture", "吵", -0.6, day=0), ev("repair", "和好", 0.5, day=1)]
+        out = nv.summarize(events)
+        self.assertEqual(out["events"], 2)
+        self.assertIn("consistency", out["metrics"])
+        self.assertIn("contradiction", out["metrics"])
+        self.assertIn("repair", out["metrics"])
+        self.assertTrue(out["entries"])
+
+    def test_disabled(self):
+        out = nv.summarize([ev("gift", "a", 0.5)], flags={"enabled": False})
+        self.assertEqual(out["entries"], [])
+        self.assertEqual(out["metrics"]["consistency"], 0.0)
+
+
+class DirectiveTest(unittest.TestCase):
+    def test_contradiction_invites_clarify(self):
+        out = nv.directives({"enabled": True, "metrics": {"contradiction": 0.9}})
+        self.assertTrue(out["allow_clarify"])
+
+    def test_clean_story_no_prompt(self):
+        out = nv.directives({"enabled": True, "metrics": {"contradiction": 0.0}})
+        self.assertFalse(out["allow_clarify"])
+
+
+if __name__ == "__main__":
+    unittest.main()