dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_co_recall.py

@@ -0,0 +1,350 @@
+# -*- coding: utf-8 -*-
+"""task-187 共召回统计单测：配对、去重、阈值、30 天时间窗、标记、畸形/空输入。
+
+只依赖 biocore_memory.co_recall；使用临时 SQLite 文件，不碰真实 memory 库，
+不导入 main.py，不新增 LLM 调用。
+"""
+import sqlite3
+import tempfile
+import unittest
+from pathlib import Path
+
+from biocore_memory import co_recall as cr
+
+NOW = 1_700_000_000.0
+DAY = 86400.0
+
+
+class CoRecallStorageTest(unittest.TestCase):
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.db = Path(self._tmp.name) / "memory" / "memory.sqlite3"
+
+    def tearDown(self):
+        self._tmp.cleanup()
+
+
+class PureFunctionTest(unittest.TestCase):
+    def test_normalize_id(self):
+        self.assertEqual(cr.normalize_id("  a  "), "a")
+        self.assertEqual(cr.normalize_id(3), "3")
+        for bad in (None, "", "   ", {}, [], ("x",)):
+            self.assertEqual(cr.normalize_id(bad), "")
+
+    def test_unique_ids(self):
+        self.assertEqual(cr.unique_ids(["b", "a", "b", "", None, "a"]),
+                         ["b", "a"])
+        self.assertEqual(cr.unique_ids("a,b"), [])
+        self.assertEqual(cr.unique_ids(None), [])
+
+    def test_pair_key_is_unordered(self):
+        self.assertEqual(cr.pair_key("b", "a"), ("a", "b"))
+        self.assertEqual(cr.pair_key("a", "b"), ("a", "b"))
+        self.assertIsNone(cr.pair_key("a", "a"))
+        self.assertIsNone(cr.pair_key("", "b"))
+        self.assertIsNone(cr.pair_key(None, "b"))
+
+    def test_pairs_unordered_and_deduped(self):
+        self.assertEqual(cr.pairs(["c", "a", "b", "a", None, ""]),
+                         [("a", "b"), ("a", "c"), ("b", "c")])
+        self.assertEqual(cr.pairs([]), [])
+        self.assertEqual(cr.pairs(None), [])
+        self.assertEqual(cr.pairs("not-a-list"), [])
+
+    def test_pairs_skips_container_ids(self):
+        self.assertEqual(cr.pairs(["a", "b", {"id": "c"}, ["d"]]),
+                         [("a", "b")])
+
+    def test_qualifies_rule(self):
+        self.assertTrue(cr.qualifies(3, NOW - DAY, 3, 30, now=NOW))
+        self.assertFalse(cr.qualifies(2, NOW - DAY, 3, 30, now=NOW))
+        self.assertFalse(cr.qualifies(5, NOW - 40 * DAY, 3, 30, now=NOW))
+        self.assertTrue(cr.qualifies(5, NOW - 40 * DAY, 3, 0, now=NOW))
+        self.assertFalse(cr.qualifies("x", None, 3, 30, now=NOW))
+
+
+class RecordTest(CoRecallStorageTest):
+    def test_record_inserts_pairs(self):
+        out = cr.record_recall(["m1", "m2", "m3"], ts=NOW, db_path=self.db)
+        self.assertEqual(out["pairs"], 3)
+        self.assertEqual(out["ids"], 3)
+        rows = cr.candidates(threshold=1, window_days=0, now=NOW,
+                             db_path=self.db)
+        self.assertEqual(len(rows), 3)
+        for row in rows:
+            self.assertEqual(row["count"], 1)
+            self.assertEqual(row["first_ts"], NOW)
+            self.assertEqual(row["last_ts"], NOW)
+            self.assertEqual(row["marked"], False)
+
+    def test_repeat_updates_count_and_last_ts(self):
+        cr.record_recall(["a", "b"], ts=NOW - 10 * DAY, db_path=self.db)
+        cr.record_recall(["a", "b"], ts=NOW - DAY, db_path=self.db)
+        row = cr.candidates(threshold=1, window_days=0, now=NOW,
+                            db_path=self.db)[0]
+        self.assertEqual(row["count"], 2)
+        self.assertEqual(row["first_ts"], NOW - 10 * DAY)
+        self.assertEqual(row["last_ts"], NOW - DAY)
+
+    def test_unordered_pairs_merge(self):
+        cr.record_recall(["a", "b"], ts=NOW, db_path=self.db)
+        cr.record_recall(["b", "a"], ts=NOW, db_path=self.db)
+        rows = cr.candidates(threshold=1, window_days=0, now=NOW,
+                             db_path=self.db)
+        self.assertEqual(len(rows), 1)
+        self.assertEqual(rows[0]["count"], 2)
+        self.assertEqual(rows[0]["pair"], ("a", "b"))
+
+    def test_duplicate_id_in_one_batch_counts_once(self):
+        out = cr.record_recall(["a", "a", "b", "a"], ts=NOW, db_path=self.db)
+        self.assertEqual(out["pairs"], 1)
+        self.assertEqual(out["ids"], 2)
+        rows = cr.candidates(threshold=1, window_days=0, now=NOW,
+                             db_path=self.db)
+        self.assertEqual(rows[0]["count"], 1)
+
+    def test_empty_batch_is_noop(self):
+        out = cr.record_recall([], ts=NOW, db_path=self.db)
+        self.assertEqual(out["pairs"], 0)
+        self.assertFalse(self.db.exists())
+        self.assertEqual(cr.stats(db_path=self.db)["pairs"], 0)
+
+    def test_invalid_ids_are_skipped(self):
+        out = cr.record_recall(["a", "b", "", None, {"x": 1}, ["c"]],
+                               ts=NOW, db_path=self.db)
+        self.assertEqual(out["pairs"], 1)
+        self.assertEqual(out["ids"], 2)
+
+
+class ThresholdAndWindowTest(CoRecallStorageTest):
+    def test_threshold_boundary(self):
+        for tick in range(2):
+            cr.record_recall(["a", "b"], ts=NOW - tick * DAY, db_path=self.db)
+        self.assertEqual(cr.candidates(threshold=3, window_days=30, now=NOW,
+                                       db_path=self.db), [])
+        cr.record_recall(["a", "b"], ts=NOW, db_path=self.db)
+        rows = cr.candidates(threshold=3, window_days=30, now=NOW,
+                             db_path=self.db)
+        self.assertEqual(len(rows), 1)
+        self.assertEqual(rows[0]["count"], 3)
+
+    def test_window_excludes_old_pairs(self):
+        for stamp in (40, 39, 38):
+            cr.record_recall(["old", "pair"], ts=NOW - stamp * DAY,
+                             db_path=self.db)
+        for stamp in (2, 1, 0):
+            cr.record_recall(["new", "pair"], ts=NOW - stamp * DAY,
+                             db_path=self.db)
+        recent = cr.candidates(threshold=3, window_days=30, now=NOW,
+                               db_path=self.db)
+        self.assertEqual([row["pair"] for row in recent], [("new", "pair")])
+        every = cr.candidates(threshold=3, window_days=0, now=NOW,
+                              db_path=self.db)
+        self.assertEqual(len(every), 2)
+
+    def test_candidates_sorted_by_count_then_recency(self):
+        for _ in range(2):
+            cr.record_recall(["a", "b"], ts=NOW - DAY, db_path=self.db)
+        for _ in range(4):
+            cr.record_recall(["c", "d"], ts=NOW, db_path=self.db)
+        rows = cr.candidates(threshold=2, window_days=30, now=NOW,
+                             db_path=self.db)
+        self.assertEqual(rows[0]["pair"], ("c", "d"))
+        self.assertEqual(rows[1]["pair"], ("a", "b"))
+        self.assertGreaterEqual(rows[0]["count"], rows[1]["count"])
+
+    def test_30_day_sample(self):
+        for stamp in (20, 10, 1):
+            cr.record_recall(["m1", "m2", "m3"], ts=NOW - stamp * DAY,
+                             db_path=self.db)
+        for stamp in (40, 39, 38):
+            cr.record_recall(["m4", "m5"], ts=NOW - stamp * DAY,
+                             db_path=self.db)
+        rows = cr.candidates(threshold=3, window_days=30, now=NOW,
+                             db_path=self.db)
+        self.assertEqual([row["pair"] for row in rows],
+                         [("m1", "m2"), ("m1", "m3"), ("m2", "m3")])
+        for row in rows:
+            self.assertEqual(row["count"], 3)
+            self.assertEqual(row["age_days"], 1.0)
+
+
+class MarkTest(CoRecallStorageTest):
+    def _seed(self):
+        for stamp in (3, 2, 1):
+            cr.record_recall(["a", "b"], ts=NOW - stamp * DAY, db_path=self.db)
+        for _ in range(2):
+            cr.record_recall(["c", "d"], ts=NOW, db_path=self.db)
+
+    def test_mark_only_over_threshold(self):
+        self._seed()
+        out = cr.mark_candidates(threshold=3, window_days=30, now=NOW,
+                                 db_path=self.db)
+        self.assertEqual(out["marked"], 1)
+        marked = cr.read_marked(db_path=self.db)
+        self.assertEqual([row["pair"] for row in marked], [("a", "b")])
+        self.assertEqual(marked[0]["count"], 3)
+
+    def test_mark_is_additive_not_destructive(self):
+        self._seed()
+        cr.mark_candidates(threshold=3, window_days=30, now=NOW,
+                           db_path=self.db)
+        rows = cr.candidates(threshold=1, window_days=0, now=NOW,
+                             db_path=self.db)
+        self.assertEqual(len(rows), 2)
+        self.assertTrue(any(row["pair"] == ("a", "b") and row["marked"]
+                            for row in rows))
+        self.assertEqual(cr.stats(db_path=self.db)["pairs"], 2)
+
+    def test_mark_is_idempotent(self):
+        self._seed()
+        cr.mark_candidates(threshold=3, window_days=30, now=NOW,
+                           db_path=self.db)
+        out = cr.mark_candidates(threshold=3, window_days=30, now=NOW + DAY,
+                                 db_path=self.db)
+        self.assertEqual(out["marked"], 1)
+        marked = cr.read_marked(db_path=self.db)
+        self.assertEqual(len(marked), 1)
+        self.assertEqual(marked[0]["marked_ts"], NOW + DAY)
+
+    def test_mark_then_candidates_show_flag(self):
+        self._seed()
+        cr.mark_candidates(threshold=3, window_days=30, now=NOW,
+                           db_path=self.db)
+        rows = cr.candidates(threshold=3, window_days=30, now=NOW,
+                             db_path=self.db)
+        self.assertTrue(rows[0]["marked"])
+
+    def test_read_marked_limit(self):
+        self._seed()
+        for stamp in (2, 1, 0):
+            cr.record_recall(["e", "f"], ts=NOW - stamp * DAY,
+                             db_path=self.db)
+        cr.mark_candidates(threshold=3, window_days=30, now=NOW,
+                           db_path=self.db)
+        self.assertEqual(len(cr.read_marked(db_path=self.db)), 2)
+        self.assertEqual(len(cr.read_marked(db_path=self.db, limit=1)), 1)
+
+
+class ReadOnlyTest(CoRecallStorageTest):
+    def test_stats(self):
+        cr.record_recall(["a", "b", "c"], ts=NOW, db_path=self.db)
+        cr.record_recall(["a", "b"], ts=NOW, db_path=self.db)
+        cr.mark_candidates(threshold=2, window_days=30, now=NOW,
+                           db_path=self.db)
+        out = cr.stats(db_path=self.db)
+        self.assertEqual(out["pairs"], 3)
+        self.assertEqual(out["recalls"], 4)
+        self.assertEqual(out["marked"], 1)
+
+    def test_readout_shape(self):
+        cr.record_recall(["a", "b", "c", "d"], ts=NOW, db_path=self.db)
+        out = cr.readout(threshold=1, window_days=30, now=NOW,
+                         db_path=self.db, limit=2)
+        self.assertEqual(out["threshold"], 1)
+        self.assertIn("stats", out)
+        self.assertEqual(len(out["candidates"]), 2)
+        self.assertEqual(out["stats"]["pairs"], 6)
+
+    def test_default_path_is_memory_sqlite3(self):
+        path = cr.default_db_path()
+        self.assertEqual(path.name, "memory.sqlite3")
+        self.assertEqual(path.parent.name, "memory")
+
+    def test_entries_table_is_untouched(self):
+        self.db.parent.mkdir(parents=True, exist_ok=True)
+        raw = sqlite3.connect(str(self.db))
+        raw.execute("CREATE TABLE entries(id TEXT PRIMARY KEY, text TEXT)")
+        raw.execute("INSERT INTO entries VALUES('m1', 'hello')")
+        raw.commit()
+        raw.close()
+        cr.record_recall(["m1", "m2"], ts=NOW, db_path=self.db)
+        cr.record_recall(["m1", "m2"], ts=NOW, db_path=self.db)
+        cr.record_recall(["m1", "m2"], ts=NOW, db_path=self.db)
+        cr.mark_candidates(threshold=3, window_days=30, now=NOW,
+                           db_path=self.db)
+        raw = sqlite3.connect(str(self.db))
+        rows = raw.execute("SELECT id, text FROM entries").fetchall()
+        tables = {row[0] for row in raw.execute(
+            "SELECT name FROM sqlite_master WHERE type='table'")}
+        raw.close()
+        self.assertEqual(rows, [("m1", "hello")])
+        self.assertIn("entries", tables)
+        self.assertIn("co_recall", tables)
+        self.assertIn("co_recall_marks", tables)
+
+
+class SchemaAndConnectionTest(CoRecallStorageTest):
+    def test_schema_columns(self):
+        conn = cr.connect(self.db)
+        try:
+            names = [row[1] for row in conn.execute(
+                "PRAGMA table_info(co_recall)")]
+            self.assertEqual(names, ["pair_a", "pair_b", "count",
+                                     "first_ts", "last_ts"])
+            mark_names = [row[1] for row in conn.execute(
+                "PRAGMA table_info(co_recall_marks)")]
+            for column in ("pair_a", "pair_b", "marked_ts", "threshold",
+                           "window_days"):
+                self.assertIn(column, mark_names)
+        finally:
+            conn.close()
+
+    def test_ensure_schema_is_idempotent(self):
+        conn = cr.connect(self.db)
+        try:
+            cr.ensure_schema(conn)
+            cr.ensure_schema(conn)
+        finally:
+            conn.close()
+        cr.record_recall(["a", "b"], ts=NOW, db_path=self.db)
+        self.assertEqual(cr.stats(db_path=self.db)["pairs"], 1)
+
+    def test_injected_connection_stays_open(self):
+        conn = sqlite3.connect(":memory:")
+        conn.row_factory = sqlite3.Row
+        try:
+            cr.record_recall(["a", "b"], ts=NOW, conn=conn)
+            cr.record_recall(["a", "b"], ts=NOW, conn=conn)
+            cr.record_recall(["a", "b"], ts=NOW, conn=conn)
+            rows = cr.candidates(threshold=3, window_days=30, now=NOW,
+                                 conn=conn)
+            self.assertEqual(rows[0]["count"], 3)
+            self.assertEqual(conn.execute(
+                "SELECT COUNT(*) FROM co_recall").fetchone()[0], 1)
+        finally:
+            conn.close()
+
+    def test_parent_dir_is_created(self):
+        self.assertFalse(self.db.exists())
+        cr.record_recall(["a", "b"], ts=NOW, db_path=self.db)
+        self.assertTrue(self.db.exists())
+
+
+class RobustnessTest(CoRecallStorageTest):
+    def test_bad_threshold_and_window(self):
+        for stamp in range(3):
+            cr.record_recall(["a", "b"], ts=NOW - stamp * DAY,
+                             db_path=self.db)
+        for threshold in (None, "x", 0, -3):
+            rows = cr.candidates(threshold=threshold, window_days=30,
+                                 now=NOW, db_path=self.db)
+            self.assertIsInstance(rows, list)
+        for days in (None, "x", -5):
+            rows = cr.candidates(threshold=1, window_days=days, now=NOW,
+                                 db_path=self.db)
+            self.assertIsInstance(rows, list)
+
+    def test_record_tolerates_odd_args(self):
+        out = cr.record_recall(None, ts="x", db_path=self.db)
+        self.assertEqual(out["pairs"], 0)
+        self.assertIsInstance(out["ts"], float)
+
+    def test_mark_empty_db(self):
+        out = cr.mark_candidates(db_path=self.db)
+        self.assertEqual(out["marked"], 0)
+        self.assertEqual(out["pairs"], [])
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_commitment_extractor.py

@@ -0,0 +1,197 @@
+# -*- coding: utf-8 -*-
+import datetime
+import unittest
+
+from biocore_model import commitment_extractor as ce
+from biocore_model import prospective
+
+NOW_DT = datetime.datetime(2026, 11, 2, 22, 25)  # Monday
+NOW = NOW_DT.timestamp()
+
+
+def stamp(year, month, day, hour=9, minute=0):
+    return datetime.datetime(year, month, day, hour, minute).timestamp()
+
+
+class CommitmentTimeTest(unittest.TestCase):
+    def test_relative_tomorrow(self):
+        out = ce.extract("明天提醒我交报告", now=NOW)
+        self.assertTrue(out["has_commitment"])
+        self.assertAlmostEqual(out["due_ts"], stamp(2026, 11, 3))
+        self.assertEqual(out["surface_phrase"], "明天")
+        self.assertIn("交报告", out["what"])
+
+    def test_relative_day_after_tomorrow(self):
+        out = ce.extract("后天体检", now=NOW)
+        self.assertAlmostEqual(out["due_ts"], stamp(2026, 11, 4))
+
+    def test_relative_three_days_out(self):
+        out = ce.extract("大后天交报告", now=NOW)
+        self.assertAlmostEqual(out["due_ts"], stamp(2026, 11, 5))
+
+    def test_relative_day_with_afternoon_time(self):
+        out = ce.extract("我明天下午三点开会", now=NOW)
+        self.assertAlmostEqual(out["due_ts"], stamp(2026, 11, 3, 15, 0))
+        self.assertEqual(out["surface_phrase"], "明天下午三点")
+        self.assertEqual(out["what"], "开会")
+
+    def test_relative_day_with_evening_digits(self):
+        out = ce.extract("明天晚上8点开会", now=NOW)
+        self.assertAlmostEqual(out["due_ts"], stamp(2026, 11, 3, 20, 0))
+
+    def test_weekday_next_week(self):
+        out = ce.extract("下周三开会", now=NOW)
+        self.assertAlmostEqual(out["due_ts"], stamp(2026, 11, 11))
+
+    def test_weekday_this_week(self):
+        out = ce.extract("本周五交报告", now=NOW)
+        self.assertAlmostEqual(out["due_ts"], stamp(2026, 11, 6))
+
+    def test_weekday_bare_is_next_occurrence(self):
+        out = ce.extract("周五体检", now=NOW)
+        self.assertAlmostEqual(out["due_ts"], stamp(2026, 11, 6))
+
+    def test_absolute_date_this_year(self):
+        out = ce.extract("11月5日交报告", now=NOW)
+        self.assertAlmostEqual(out["due_ts"], stamp(2026, 11, 5))
+
+    def test_absolute_date_already_passed_rolls_to_next_year(self):
+        out = ce.extract("3月5日交报告", now=NOW)
+        self.assertAlmostEqual(out["due_ts"], stamp(2027, 3, 5))
+
+    def test_bare_clock_rolls_to_tomorrow_when_passed(self):
+        out = ce.extract("下午3点开会", now=NOW)
+        self.assertAlmostEqual(out["due_ts"], stamp(2026, 11, 3, 15, 0))
+
+
+class CommitmentBoundaryTest(unittest.TestCase):
+    def test_vague_changeday_has_no_due(self):
+        out = ce.extract("改天一起吃饭", now=NOW)
+        self.assertTrue(out["has_commitment"])
+        self.assertIsNone(out["due_ts"])
+        self.assertEqual(out["reason"], "vague")
+        self.assertLess(out["confidence"], 0.5)
+
+    def test_vague_find_time_has_no_due(self):
+        out = ce.extract("找时间聊", now=NOW)
+        self.assertTrue(out["has_commitment"])
+        self.assertIsNone(out["due_ts"])
+
+    def test_past_relative_is_not_a_commitment(self):
+        out = ce.extract("昨天开会到很晚", now=NOW)
+        self.assertFalse(out["has_commitment"])
+        self.assertEqual(out["reason"], "past")
+
+    def test_past_weekday_is_not_a_commitment(self):
+        out = ce.extract("上周三开会", now=NOW)
+        self.assertFalse(out["has_commitment"])
+        self.assertEqual(out["reason"], "past")
+
+    def test_no_time_no_commitment(self):
+        out = ce.extract("今天天气不错", now=NOW)
+        self.assertFalse(out["has_commitment"])
+        self.assertEqual(out["reason"], "no_intent")
+
+    def test_most_specific_commitment_wins(self):
+        out = ce.extract("明天提醒我交报告，下周三下午三点开会", now=NOW)
+        self.assertTrue(out["has_commitment"])
+        self.assertAlmostEqual(out["due_ts"], stamp(2026, 11, 11, 15, 0))
+        self.assertIn("下周三", out["surface_phrase"])
+        self.assertEqual(out["what"], "开会")
+
+    def test_confidence_is_bounded(self):
+        for text in ("明天提醒我交报告", "下周三开会", "改天吃饭",
+                     "今天天气不错"):
+            out = ce.extract(text, now=NOW)
+            self.assertGreaterEqual(out["confidence"], 0.0)
+            self.assertLessEqual(out["confidence"], 1.0)
+
+
+class CommitmentWhoTest(unittest.TestCase):
+    def test_request_to_her_is_her_promise(self):
+        out = ce.extract("你明天记得问我体检结果", now=NOW)
+        self.assertEqual(out["who"], "her")
+        self.assertEqual(out["kind"], "her_promise")
+        self.assertIn("体检结果", out["what"])
+
+    def test_first_person_is_his_event(self):
+        out = ce.extract("我周五体检", now=NOW)
+        self.assertEqual(out["who"], "him")
+        self.assertEqual(out["kind"], "his_event")
+        self.assertEqual(out["what"], "体检")
+
+    def test_reminder_request_is_her_promise(self):
+        out = ce.extract("明天提醒我交报告", now=NOW)
+        self.assertEqual(out["who"], "her")
+
+
+class CommitmentTagsTest(unittest.TestCase):
+    def test_structured_due_overrides_text(self):
+        due = NOW + 86400
+        out = ce.extract("记得那件事", tags={"due_ts": due}, now=NOW)
+        self.assertTrue(out["has_commitment"])
+        self.assertAlmostEqual(out["due_ts"], due)
+        self.assertGreaterEqual(out["confidence"], 0.95)
+
+    def test_structured_time_and_fact(self):
+        out = ce.extract("回头弄一下",
+                         tags={"time": "明天下午3点", "fact": "弄材料",
+                               "entities": ["材料"]},
+                         now=NOW)
+        self.assertTrue(out["has_commitment"])
+        self.assertAlmostEqual(out["due_ts"], stamp(2026, 11, 3, 15, 0))
+        self.assertEqual(out["what"], "弄材料")
+        self.assertEqual(out["entities"], ["材料"])
+
+    def test_disabled_switch(self):
+        for config in (False, {"enabled": False}):
+            out = ce.extract("明天提醒我交报告", now=NOW, config=config)
+            self.assertFalse(out["enabled"])
+            self.assertFalse(out["has_commitment"])
+            self.assertEqual(out["reason"], "disabled")
+
+    def test_malformed_inputs_do_not_crash(self):
+        for text in (None, 123, "", "   "):
+            out = ce.extract(text, now=NOW)
+            self.assertIn("has_commitment", out)
+            self.assertFalse(out["has_commitment"])
+        missing_now = ce.extract("明天开会", now=None)
+        self.assertFalse(missing_now["has_commitment"])
+
+    def test_reason_is_always_present(self):
+        for text in ("明天开会", "改天吃饭", "昨天开会", "今天天气不错"):
+            self.assertTrue(ce.extract(text, now=NOW)["reason"])
+
+
+class CommitmentProspectiveBridgeTest(unittest.TestCase):
+    def test_bridge_builds_prospective_record(self):
+        result = ce.extract("你明天记得问我体检结果", now=NOW)
+        record = ce.to_prospective(result, now=NOW)
+        self.assertIsNotNone(record)
+        self.assertEqual(record["kind"], "her_promise")
+        self.assertEqual(record["text"], result["what"])
+        self.assertAlmostEqual(record["due_ts"], result["due_ts"])
+        self.assertEqual(record["status"], "pending")
+        self.assertTrue(record["id"])
+        self.assertEqual(record["meta"]["surface_phrase"], "明天")
+
+    def test_bridge_rejects_vague(self):
+        result = ce.extract("改天一起吃饭", now=NOW)
+        self.assertIsNone(ce.to_prospective(result, now=NOW))
+
+    def test_bridge_rejects_no_commitment(self):
+        result = ce.extract("今天天气不错", now=NOW)
+        self.assertIsNone(ce.to_prospective(result, now=NOW))
+
+    def test_bridge_record_roundtrips_into_prospective_store(self):
+        result = ce.extract("明天下午三点开会", now=NOW)
+        record = ce.to_prospective(result, now=NOW)
+        store, changed = prospective.add([], record)
+        self.assertTrue(changed)
+        self.assertEqual(len(store), 1)
+        due = prospective.due_now(store, record["due_ts"])
+        self.assertEqual(len(due), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_compassion_fatigue.py

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+"""Compassion fatigue: decay, floor, recovery."""
+import unittest
+
+from biocore_model import compassion_fatigue as cf
+
+
+class DecayTest(unittest.TestCase):
+    def test_baseline_full_empathy(self):
+        out = cf.fatigue(0, 0.0, 0.0)
+        self.assertEqual(out["empathy"], 1.0)
+        self.assertEqual(out["fatigue"], 0.0)
+
+    def test_consecutive_comfort_lowers(self):
+        one = cf.fatigue(1, 0.0, 0.0)
+        five = cf.fatigue(5, 0.0, 0.0)
+        self.assertLess(five["empathy"], one["empathy"])
+
+    def test_negative_density_lowers(self):
+        calm = cf.fatigue(2, 0.0, 0.0)
+        heavy = cf.fatigue(2, 0.9, 0.0)
+        self.assertLess(heavy["empathy"], calm["empathy"])
+
+    def test_empathy_never_below_floor(self):
+        out = cf.fatigue(999, 1.0, 0.0)
+        self.assertGreaterEqual(out["empathy"], cf.EMPATHY_FLOOR)
+        self.assertEqual(out["band"], "low")
+
+    def test_fatigue_bounded(self):
+        out = cf.fatigue(999, 1.0, 0.0)
+        self.assertLessEqual(out["fatigue"], 1.0)
+        self.assertGreaterEqual(out["fatigue"], 0.0)
+
+
+class RecoveryTest(unittest.TestCase):
+    def test_idle_restores(self):
+        tired = cf.fatigue(6, 0.8, 0.0)
+        rested = cf.fatigue(6, 0.8, 12.0)
+        self.assertGreater(rested["empathy"], tired["empathy"])
+
+    def test_recovery_reported(self):
+        out = cf.fatigue(4, 0.5, 6.0)
+        self.assertGreater(out["recovery"], 0.0)
+
+    def test_full_rest_clears(self):
+        out = cf.fatigue(4, 0.5, 200.0)
+        self.assertGreater(out["empathy"], 0.95)
+
+
+class BandTest(unittest.TestCase):
+    def test_bands_present(self):
+        for count, density in ((0, 0.0), (3, 0.4), (10, 1.0)):
+            out = cf.fatigue(count, density, 0.0)
+            self.assertIn(out["band"], ("high", "mid", "low"))
+            self.assertTrue(out["advice"])
+
+    def test_low_band_advice(self):
+        out = cf.fatigue(20, 1.0, 0.0)
+        self.assertEqual(out["advice"], cf.ADVICE["low"])
+
+
+class FallbackTest(unittest.TestCase):
+    def test_disabled(self):
+        out = cf.fatigue(10, 1.0, 0.0, flags={"enabled": False})
+        self.assertFalse(out["enabled"])
+        self.assertEqual(out["empathy"], 1.0)
+
+    def test_malformed(self):
+        out = cf.fatigue("x", "y", "z")
+        self.assertGreaterEqual(out["empathy"], cf.EMPATHY_FLOOR)
+
+
+class DirectiveTest(unittest.TestCase):
+    def test_low_empathy_shortens(self):
+        out = cf.directives(cf.fatigue(20, 1.0, 0.0))
+        self.assertLess(out["length_scale"], 1.0)
+        self.assertTrue(out["tone"])
+
+    def test_disabled(self):
+        self.assertEqual(cf.directives({"enabled": False})["tone"], "")
+
+
+if __name__ == "__main__":
+    unittest.main()