dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_memory_dual_wiring.py

@@ -0,0 +1,219 @@
+# -*- coding: utf-8 -*-
+"""Wiring tests: validate the memory_dual snippets used/needed in main.py.
+
+- sort: executes the ACTUAL snippet currently in main.py (search anchors, then
+  exec with fake scored list) and asserts ordering follows memory_dual scores.
+- forget: executes the proposed replacement for _memory_save_doc_for_session
+  (main.py:9768-9770) with fake MEMORY_DIR/json/logger and asserts hidden marks.
+- testing effect: executes the proposed on_recall write-back snippet.
+- policy: reward direction, Q update direction, ui_settings persistence key.
+"""
+import json
+import tempfile
+import textwrap
+import unittest
+from pathlib import Path
+
+from biocore_model import memory_dual as md
+from biocore_model import policy_learning as pl
+from biocore_model import ui_settings
+
+MAIN = Path(__file__).resolve().parents[2] / "main.py"
+NOW = 1_700_000_000.0
+
+
+class FakePlugin:
+    def __init__(self, data_dir):
+        self.data_dir = str(data_dir)
+
+
+class FakeSelf:
+    def __init__(self):
+        self._last_memory_context = None
+
+
+def _extract_sort_snippet():
+    """The real insertion in main.py: from the memory_dual import to the fallback."""
+    source = MAIN.read_text(encoding="utf-8").splitlines()
+    import_line = None
+    for index, line in enumerate(source):
+        if "from biocore_model import memory_dual as _md" in line:
+            import_line = index
+            break
+    if import_line is None:
+        raise AssertionError("memory_dual sorting snippet not found in main.py")
+    start = import_line
+    for index in range(import_line - 1, max(-1, import_line - 8), -1):
+        if source[index].strip().startswith("try:"):
+            start = index
+            break
+    if start is None:
+        raise AssertionError("memory_dual sorting snippet not found in main.py")
+    end = None
+    for index in range(start + 1, len(source)):
+        if "scored.sort(key=lambda x: x[0], reverse=True)" in source[index]:
+            end = index
+            break
+    if end is None:
+        raise AssertionError("sort fallback not found")
+    body = "\n".join(source[start:end + 1])
+    return "def _run_snippet(self, scored, now):\n" + textwrap.indent(body, "    ")
+
+
+class DualSortWiringTest(unittest.TestCase):
+    def setUp(self):
+        self.fresh = {"id": "fresh", "text": "fresh", "storage_s": 0.6,
+                      "retrieval_s": 0.55, "access_count": 0,
+                      "last_access_ts": NOW - 2 * 3600, "open_loop": False}
+        self.stale = {"id": "stale", "text": "stale", "storage_s": 0.5,
+                      "retrieval_s": 0.35, "access_count": 0,
+                      "last_access_ts": NOW - 72 * 3600, "open_loop": False}
+
+    def test_snippet_reorders_by_dual_score(self):
+        snippet = _extract_sort_snippet()
+        scored = [(0.99, self.stale), (0.50, self.fresh)]  # legacy order: stale first
+        namespace = {}
+        exec(compile(snippet, "<main.memory_dual.sort>", "exec"), namespace)
+        namespace["_run_snippet"](FakeSelf(), scored, NOW)
+        ordered = [entry["id"] for _score, entry in scored]
+        expected = sorted(
+            ["fresh", "stale"],
+            key=lambda eid: -md.score(self.fresh if eid == "fresh" else self.stale,
+                                      NOW, context_match=1.0))
+        self.assertEqual(ordered, expected)
+        self.assertEqual(ordered[0], "fresh")
+        self.assertGreater(md.score(self.fresh, NOW), md.score(self.stale, NOW))
+
+    def test_snippet_can_fall_back(self):
+        snippet = _extract_sort_snippet()
+        scored = [(0.90, {"id": "a", "retrieval_s": 0.5, "last_access_ts": NOW}),
+                  (0.10, {"id": "b", "retrieval_s": 0.5, "last_access_ts": NOW})]
+        namespace = {}
+        exec(compile(snippet, "<main.memory_dual.sort>", "exec"), namespace)
+        namespace["_run_snippet"](FakeSelf(), scored, NOW)
+        self.assertEqual([e["id"] for _s, e in scored], ["a", "b"])
+
+
+FORGET_PATCH = '''
+def _memory_save_doc_for_session(self, path, doc):
+    try:
+        from biocore_model import memory_dual as _md
+        _rows = doc.get("entries") if isinstance(doc.get("entries"), list) else []
+        _fade = _md.forget(_rows, now=time.time())
+        doc["entries"] = _fade["entries"]
+        if _fade["forgotten_ids"]:
+            logger.info("[biocore] memory_dual hidden=%s", _fade["forgotten_ids"])
+    except Exception:
+        pass
+    MEMORY_DIR.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(doc, ensure_ascii=False), encoding="utf-8")
+'''
+
+
+class ForgetWiringTest(unittest.TestCase):
+    def test_patch_marks_hidden_without_deleting(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp_path = Path(tmp)
+            class Logger:
+                def info(self, *a, **k): pass
+                def warning(self, *a, **k): pass
+            namespace = {"json": json, "time": __import__("time"),
+                         "logger": Logger(), "MEMORY_DIR": tmp_path}
+            exec(compile(FORGET_PATCH, "<forget_patch>", "exec"), namespace)
+            fake = object.__new__(type("Fake", (), {}))
+            import time as _time
+            now_real = _time.time()
+            doc = {"entries": [
+                {"id": "faint", "retrieval_s": 0.10, "last_access_ts": now_real - 200 * 3600},
+                {"id": "solid", "retrieval_s": 0.50, "last_access_ts": now_real},
+            ]}
+            target = tmp_path / "session.json"
+            namespace["_memory_save_doc_for_session"](fake, target, doc)
+            saved = json.loads(target.read_text(encoding="utf-8"))
+            by_id = {row["id"]: row for row in saved["entries"]}
+            self.assertEqual(len(saved["entries"]), 2)          # nothing deleted
+            self.assertTrue(by_id["faint"]["hidden"])
+            self.assertIn("hidden_ts", by_id["faint"])
+            self.assertNotIn("hidden", by_id["solid"])
+
+    def test_patch_second_call_is_idempotent(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp_path = Path(tmp)
+            class Logger:
+                def info(self, *a, **k): pass
+                def warning(self, *a, **k): pass
+            namespace = {"json": json, "time": __import__("time"),
+                         "logger": Logger(), "MEMORY_DIR": tmp_path}
+            exec(compile(FORGET_PATCH, "<forget_patch>", "exec"), namespace)
+            fake = object.__new__(type("Fake", (), {}))
+            import time as _time
+            doc = {"entries": [{"id": "faint", "retrieval_s": 0.10,
+                                "last_access_ts": _time.time() - 200 * 3600}]}
+            target = tmp_path / "session.json"
+            namespace["_memory_save_doc_for_session"](fake, target, doc)
+            first = json.loads(target.read_text(encoding="utf-8"))
+            namespace["_memory_save_doc_for_session"](fake, target, first)
+            second = json.loads(target.read_text(encoding="utf-8"))
+            self.assertTrue(second["entries"][0]["hidden"])
+            self.assertEqual(len(second["entries"]), 1)
+
+
+TESTING_EFFECT_SNIPPET = '''
+_upd = _md.on_recall(e, now)
+e["storage_s"] = _upd["storage_s"]
+e["retrieval_s"] = _upd["retrieval_s"]
+e["access_count"] = _upd["access_count"]
+e["last_access_ts"] = _upd["last_access_ts"]
+'''
+
+
+class TestingEffectWiringTest(unittest.TestCase):
+    def test_patch_strengthens_selected_entry(self):
+        entry = {"id": "e1", "storage_s": 0.5, "retrieval_s": 0.4,
+                 "access_count": 0, "last_access_ts": NOW - 24 * 3600}
+        namespace = {"e": entry, "now": NOW, "_md": md}
+        exec(compile(TESTING_EFFECT_SNIPPET, "<testing_effect>", "exec"), namespace)
+        self.assertGreater(entry["storage_s"], 0.5)
+        self.assertAlmostEqual(entry["retrieval_s"], 0.75, places=4)
+        self.assertEqual(entry["access_count"], 1)
+        self.assertEqual(entry["last_access_ts"], NOW)
+
+    def test_patch_is_idempotent_same_now(self):
+        entry = {"id": "e1", "storage_s": 0.5, "retrieval_s": 0.4,
+                 "access_count": 0, "last_access_ts": 0.0}
+        namespace = {"e": entry, "now": NOW, "_md": md}
+        exec(compile(TESTING_EFFECT_SNIPPET, "<testing_effect>", "exec"), namespace)
+        first = dict(entry)
+        exec(compile(TESTING_EFFECT_SNIPPET, "<testing_effect>", "exec"), namespace)
+        self.assertEqual(entry, first)
+
+
+class PolicyWiringTest(unittest.TestCase):
+    def test_reward_direction(self):
+        responded = pl.reward(True, 5.0, -0.5)
+        ignored = pl.reward(False, 900.0, 0.0)
+        self.assertGreater(responded, ignored)
+        self.assertAlmostEqual(responded, 0.541667, places=6)
+        self.assertAlmostEqual(ignored, 0.0, places=6)
+
+    def test_update_direction(self):
+        table = pl.update({}, "expect|secure|day", "approach", 1.0, alpha=0.2)
+        self.assertGreater(table["expect|secure|day"]["approach"]["q"], 0.0)
+        down = pl.update(table, "expect|secure|day", "approach", 0.0, alpha=0.2)
+        self.assertLess(down["expect|secure|day"]["approach"]["q"],
+                        table["expect|secure|day"]["approach"]["q"])
+
+    def test_q_table_persists_under_ui_settings(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            plugin = FakePlugin(tmp)
+            table = pl.update({}, "expect|secure|day", "share", 0.5)
+            saved = ui_settings.save(plugin, {"autonomy": {"policy_q": table}})
+            self.assertTrue(saved.get("ok"))
+            data = ui_settings.load(plugin)
+            self.assertEqual(data["autonomy"]["policy_q"],
+                             table)
+            self.assertIn("policy_q", data["autonomy"])
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_memory_feedback.py

@@ -0,0 +1,241 @@
+# -*- coding: utf-8 -*-
+"""task-218: recall feedback into affect (回忆回灌情绪).
+
+Run from the plugin root:
+
+    python -m unittest discover -s biocore_model/tests -p "test_memory_feedback.py"
+"""
+import json
+import os
+import tempfile
+import unittest
+from pathlib import Path
+
+from biocore_memory.engine import MemoryEngine
+from biocore_memory.core import config as engine_config
+
+
+def entry(i, text, affect=None, importance=0.5, ts=1700000000.0):
+    value = {"id": i, "text": text, "role": "user", "ts": ts,
+             "importance": importance, "vector": [], "hits": 1,
+             "self_relevance": 0.0, "pin": False, "memory_source": "direct",
+             "memory_confidence": 0.7, "previous_versions": [],
+             "module": "biocore_memory", "scope": "default"}
+    if affect is not None:
+        value["affect"] = affect
+    return value
+
+
+class MemoryFeedbackTest(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.dir = Path(self.tmp.name)
+        self.clock = [1700000000.0]
+        self._saved = os.environ.get("BIOCORE_MEMORY_FEEDBACK")
+        os.environ.pop("BIOCORE_MEMORY_FEEDBACK", None)
+
+    def tearDown(self):
+        self.tmp.cleanup()
+        if self._saved is None:
+            os.environ.pop("BIOCORE_MEMORY_FEEDBACK", None)
+        else:
+            os.environ["BIOCORE_MEMORY_FEEDBACK"] = self._saved
+
+    def write(self, entries):
+        (self.dir / "memory.json").write_text(
+            json.dumps({"entries": entries, "tombstones": [],
+                        "schema_version": 1}), encoding="utf-8")
+
+    def engine(self, affect, enabled=True):
+        e = MemoryEngine(data_dir=str(self.dir), affect=affect,
+                         now=lambda: self.clock[0])
+        if enabled:
+            e.flags["memory_feedback"] = True
+        return e
+
+    # -- switch ---------------------------------------------------------
+    def test_flag_defaults_off(self):
+        self.assertIs(engine_config.FLAGS.get("memory_feedback"), False)
+
+    def test_off_leaves_affect_unchanged(self):
+        self.write([entry("warm", "beach warm", {"valence": 0.9, "arousal": 0.9})])
+        affect = {"v": 0.0, "a": 0.5}
+        e = self.engine(affect, enabled=False)
+        rows = e.recall("beach", budget=3)
+        self.assertEqual(len(rows), 1)
+        self.assertAlmostEqual(affect["v"], 0.0, places=6)
+        self.assertAlmostEqual(affect["a"], 0.5, places=6)
+        self.assertIsNone(e._last_memory_feedback)
+
+    # -- basic pull -----------------------------------------------------
+    def test_on_pulls_toward_recalled_affect(self):
+        self.write([entry("warm", "beach warm", {"valence": 0.8, "arousal": 0.9})])
+        affect = {"v": 0.0, "a": 0.5}
+        e = self.engine(affect)
+        e.recall("beach", budget=3)
+        report = e._last_memory_feedback
+        self.assertIsNotNone(report)
+        self.assertEqual(report["applied"], ["warm"])
+        self.assertAlmostEqual(report["delta"][0], 0.02, places=6)
+        self.assertAlmostEqual(report["delta"][1], 0.02, places=6)
+        self.assertAlmostEqual(affect["v"], 0.02, places=4)
+        self.assertAlmostEqual(affect["a"], 0.52, places=4)
+
+    def test_per_turn_cap_both_axes(self):
+        self.write([entry("max", "beach max", {"valence": 1.0, "arousal": 1.0})])
+        affect = {"v": -1.0, "a": 0.0}
+        e = self.engine(affect)
+        e.recall("beach", budget=3)
+        report = e._last_memory_feedback
+        self.assertTrue(report["capped"])
+        self.assertAlmostEqual(report["delta"][0], 0.02, places=6)
+        self.assertAlmostEqual(report["delta"][1], 0.02, places=6)
+        self.assertAlmostEqual(affect["v"], -0.98, places=4)
+        self.assertAlmostEqual(affect["a"], 0.02, places=4)
+
+    def test_positive_cap_is_symmetric(self):
+        self.write([entry("max", "beach max", {"valence": 1.0, "arousal": 1.0})])
+        affect = {"v": -0.2, "a": 0.3}
+        e = self.engine(affect)
+        e.recall("beach", budget=3)
+        self.assertAlmostEqual(affect["v"], -0.18, places=4)
+        self.assertAlmostEqual(affect["a"], 0.32, places=4)
+
+    def test_weighted_mean_of_batch(self):
+        self.write([
+            entry("hi", "beach one", {"valence": 0.9, "arousal": 0.9},
+                  importance=1.0),
+            entry("lo", "beach two", {"valence": -0.9, "arousal": 0.1},
+                  importance=0.0),
+        ])
+        affect = {"v": 0.0, "a": 0.5}
+        e = self.engine(affect)
+        e.recall("beach", budget=3)
+        report = e._last_memory_feedback
+        # weight 1.0 vs 0.0 -> target is the weighty memory (0.9, 0.9)
+        self.assertAlmostEqual(report["target"][0], 0.9, places=4)
+        self.assertAlmostEqual(report["target"][1], 0.9, places=4)
+        self.assertAlmostEqual(affect["v"], 0.02, places=4)
+
+    # -- cooldown -------------------------------------------------------
+    def test_cooldown_blocks_same_memory(self):
+        self.write([entry("warm", "beach warm", {"valence": 0.8, "arousal": 0.9})])
+        affect = {"v": 0.0, "a": 0.5}
+        e = self.engine(affect)
+        e.recall("beach", budget=3)
+        moved = affect["v"]
+        self.assertAlmostEqual(moved, 0.02, places=4)
+        e.recall("beach", budget=3)
+        report = e._last_memory_feedback
+        self.assertEqual(report["applied"], [])
+        self.assertEqual(report["delta"], [0.0, 0.0])
+        self.assertIn("cooldown", [x["reason"] for x in report["skipped"]])
+        self.assertAlmostEqual(affect["v"], moved, places=6)
+
+    def test_cooldown_expires_after_window(self):
+        self.write([entry("warm", "beach warm", {"valence": 0.8, "arousal": 0.9})])
+        affect = {"v": 0.0, "a": 0.5}
+        e = self.engine(affect)
+        e.recall("beach", budget=3)
+        self.clock[0] += engine_config.FEEDBACK_COOLDOWN + 1.0
+        e.recall("beach", budget=3)
+        report = e._last_memory_feedback
+        self.assertEqual(report["applied"], ["warm"])
+        self.assertAlmostEqual(affect["v"], 0.04, places=4)
+
+    # -- negative floor / regulation ------------------------------------
+    def test_negative_floor_blocks_descent_and_regulates(self):
+        self.write([entry("bad", "beach bad", {"valence": -0.9, "arousal": 0.5})])
+        affect = {"v": -0.5, "a": 0.5}
+        e = self.engine(affect)
+        e.recall("beach", budget=3)
+        report = e._last_memory_feedback
+        self.assertTrue(report["blocked_negative"])
+        self.assertEqual(report["delta"][0], 0.0)
+        self.assertAlmostEqual(affect["v"], -0.5, places=6)
+        regulation = report.get("regulation")
+        self.assertIsInstance(regulation, dict)
+        self.assertIn(regulation.get("strategy"),
+                      ("situation_selection", "situation_modification",
+                       "attentional_deployment", "cognitive_reappraisal",
+                       "response_modulation"))
+        self.assertEqual(report["applied"], [])
+
+    def test_negative_above_floor_still_pulls(self):
+        self.write([entry("bad", "beach bad", {"valence": -0.9, "arousal": 0.5})])
+        affect = {"v": -0.2, "a": 0.5}
+        e = self.engine(affect)
+        e.recall("beach", budget=3)
+        report = e._last_memory_feedback
+        self.assertFalse(report["blocked_negative"])
+        self.assertIsNone(report["regulation"])
+        self.assertAlmostEqual(affect["v"], -0.22, places=4)
+
+    # -- scope: only the injected top-k ---------------------------------
+    def test_only_injected_topk_matters(self):
+        self.write([
+            entry("hit", "beach picnic", {"valence": 0.9, "arousal": 0.9}),
+            entry("miss", "zebra zebra", {"valence": -1.0, "arousal": 0.0}),
+        ])
+        affect = {"v": 0.0, "a": 0.5}
+        e = self.engine(affect)
+        rows = e.recall("beach picnic", budget=1)
+        self.assertEqual(len(rows), 1)
+        self.assertEqual(rows[0]["entry"]["id"], "hit")
+        report = e._last_memory_feedback
+        self.assertEqual(report["applied"], ["hit"])
+        self.assertAlmostEqual(affect["v"], 0.02, places=4)
+
+    def test_entry_without_affect_is_skipped(self):
+        self.write([entry("plain", "beach plain")])
+        affect = {"v": 0.0, "a": 0.5}
+        e = self.engine(affect)
+        e.recall("beach", budget=3)
+        report = e._last_memory_feedback
+        self.assertEqual(report["applied"], [])
+        self.assertEqual(report["reason"], "no_eligible_memory")
+        self.assertIn("no_affect", [x["reason"] for x in report["skipped"]])
+        self.assertAlmostEqual(affect["v"], 0.0, places=6)
+
+    # -- state-only, env switch, robustness -----------------------------
+    def test_memory_entry_is_not_rewritten(self):
+        warm = entry("warm", "beach warm", {"valence": 0.8, "arousal": 0.9})
+        self.write([warm])
+        affect = {"v": 0.0, "a": 0.5}
+        e = self.engine(affect)
+        e.recall("beach", budget=3)
+        stored = e.store.find("warm")
+        self.assertIsNotNone(stored)
+        self.assertEqual(stored["affect"], {"valence": 0.8, "arousal": 0.9})
+        self.assertEqual(len(e.store.entries), 1)
+
+    def test_env_switch_enables(self):
+        os.environ["BIOCORE_MEMORY_FEEDBACK"] = "1"
+        self.write([entry("warm", "beach warm", {"valence": 0.8, "arousal": 0.9})])
+        affect = {"v": 0.0, "a": 0.5}
+        e = self.engine(affect, enabled=False)
+        e.recall("beach", budget=3)
+        self.assertAlmostEqual(affect["v"], 0.02, places=4)
+
+    def test_no_affect_state_is_noop(self):
+        self.write([entry("warm", "beach warm", {"valence": 0.8, "arousal": 0.9})])
+        e = self.engine(None)
+        rows = e.recall("beach", budget=3)
+        self.assertEqual(len(rows), 1)
+        report = e._last_memory_feedback
+        self.assertEqual(report["reason"], "no_affect_state")
+        self.assertEqual(report["applied"], [])
+
+    def test_missing_affect_dict_is_noop(self):
+        self.write([{"id": "bare", "text": "beach bare", "ts": 1700000000.0,
+                     "importance": 0.5, "hits": 1, "affect": {"v": None}}])
+        affect = {"v": 0.0, "a": 0.5}
+        e = self.engine(affect)
+        e.recall("beach", budget=3)
+        report = e._last_memory_feedback
+        self.assertEqual(report["delta"], [0.0, 0.0])
+        self.assertAlmostEqual(affect["v"], 0.0, places=6)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_memory_fixes.py

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+"""Memory fixes: _save_memory forget path, recall dedup, maintenance entries."""
+import ast
+import json
+import tempfile
+import types
+import unittest
+from pathlib import Path
+
+import memory_meta
+from biocore_model import bio_tick as bt
+
+MAIN = Path(__file__).resolve().parents[2] / "main.py"
+SOURCE = MAIN.read_text(encoding="utf-8")
+
+
+def _load_methods(names, namespace=None):
+    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=[]), "<mem>", "exec"), ns)
+            fns[node.name] = ns[node.name]
+    return fns
+
+
+class SaveMemoryTest(unittest.TestCase):
+    def test_save_memory_runs_forget(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            fns = _load_methods(("_save_memory", "_memory_save_doc_for_session"), {
+                "json": json, "time": __import__("time"), "Path": Path,
+                "MEMORY_SCHEMA_VERSION": 2,
+                "MEMORY_DIR": Path(tmp),
+                "logger": types.SimpleNamespace(
+                    warning=lambda *a, **k: None, info=lambda *a, **k: None),
+            })
+            plugin = types.SimpleNamespace(
+                _memory_path=lambda event: Path(tmp) / "s1.json")
+            plugin._save_memory = types.MethodType(fns["_save_memory"], plugin)
+            plugin._memory_save_doc_for_session = types.MethodType(
+                fns["_memory_save_doc_for_session"], plugin)
+            doc = {"entries": [{"id": "stale", "retrieval_s": 0.001,
+                                "last_access_ts": 1.0, "text": "old"}]}
+            plugin._save_memory(None, doc)
+            saved = json.loads((Path(tmp) / "s1.json").read_text(encoding="utf-8"))
+            self.assertTrue(saved["entries"][0].get("hidden"))
+
+
+class DedupTest(unittest.TestCase):
+    def test_same_cluster_keeps_two(self):
+        fns = _load_methods(("_dedup_memory_top",), {"memory_meta": memory_meta})
+        plugin = types.SimpleNamespace()
+        fn = types.MethodType(fns["_dedup_memory_top"], plugin)
+        rows = [(0.9, {"text": "今天去海边玩"}),
+                (0.8, {"text": "今天去海边玩"}),
+                (0.7, {"text": "今天去海边玩"}),
+                (0.6, {"text": "完全不同的内容"})]
+        out = fn(rows)
+        self.assertLessEqual(len(out), 3)
+        self.assertEqual(len(out), 3)
+
+
+class MaintenanceTest(unittest.TestCase):
+    def test_entries_are_processed_and_returned(self):
+        now = 2_000_000_000.0
+        rows = [{"id": "a", "retrieval_s": 0.9, "last_access_ts": now},
+                {"id": "b", "retrieval_s": 0.01, "last_access_ts": now}]
+        out = bt.memory_maintenance(None, now, dt_hours=1.0, entries=rows)
+        self.assertFalse(out.get("skipped"))
+        self.assertIn("entries", out)
+        self.assertEqual(len(out["entries"]), 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_memory_forgetting.py

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+import random, unittest
+from biocore_model import memory_forgetting as mf
+
+NOW = 1_700_000_000
+
+class ForgettingTest(unittest.TestCase):
+    def test_decay_1h(self):
+        self.assertLess(mf.strength(1.0, 1), 1.0)
+    def test_decay_monotonic(self):
+        self.assertGreater(mf.strength(1.0, 1), mf.strength(1.0, 24))
+        self.assertGreater(mf.strength(1.0, 24), mf.strength(1.0, 24 * 7))
+    def test_power_law_value(self):
+        self.assertAlmostEqual(mf.strength(1.0, 24), round(2 ** -0.5, 6), places=5)
+    def test_recall_boost(self):
+        entry = mf.recall({'strength': 0.3}, NOW)
+        self.assertGreater(entry['strength'], 0.3); self.assertEqual(entry['recall_count'], 1)
+    def test_recall_cap(self):
+        entry = mf.recall({'strength': 0.95}, NOW)
+        self.assertLessEqual(entry['strength'], 1.0)
+    def test_core_after_five(self):
+        entry = {'strength': 0.5}
+        for _ in range(6): entry = mf.recall(entry, NOW)
+        self.assertTrue(entry.get('core_memory'))
+    def test_core_never_decays(self):
+        entry = mf.decayed({'strength': 0.6, 'core_memory': True, 'last_decay_ts': NOW - 86400 * 30}, NOW)
+        self.assertEqual(entry['strength'], 0.6)
+    def test_forgotten_threshold(self):
+        self.assertFalse(mf.injectable({'strength': 0.1}))
+        self.assertTrue(mf.injectable({'strength': 0.2}))
+    def test_memory_view(self):
+        view = mf.memory_view([{'id': 'a', 'strength': 0.9}, {'id': 'b', 'strength': 0.05}])
+        self.assertEqual(view['top'][0]['id'], 'a'); self.assertEqual(view['forgotten_count'], 1)
+    def test_rumination_requires_negative(self):
+        items = mf.add_rumination([], 'message', 'm1', 'text', NOW, valence=0.2)
+        self.assertEqual(items, [])
+    def test_rumination_added(self):
+        items = mf.add_rumination([], 'message', 'm1', 'text', NOW, valence=-0.6)
+        self.assertEqual(len(items), 1); self.assertEqual(items[0]['count'], 1)
+    def test_rumination_dedupe(self):
+        items = mf.add_rumination([], 'message', 'm1', 't', NOW, conflict=True)
+        items = mf.add_rumination(items, 'message', 'm1', 't', NOW + 60, conflict=True)
+        self.assertEqual(len(items), 1); self.assertEqual(items[0]['count'], 2)
+    def test_rumination_removed_at_count5(self):
+        items = [{'target_type': 'message', 'target_id': 'm', 'count': 5, 'first_ts': NOW - 100, 'last_ts': NOW - 100, 'intensity': 1.0}]
+        self.assertEqual(mf.tick_rumination(items, NOW, random.Random(1)), [])
+    def test_rumination_removed_after_72h(self):
+        items = [{'target_type': 'message', 'target_id': 'm', 'count': 1, 'first_ts': NOW - 80 * 3600, 'last_ts': NOW - 80 * 3600}]
+        self.assertEqual(mf.tick_rumination(items, NOW, random.Random(1)), [])
+    def test_rumination_same_now_idempotent(self):
+        items = [{'target_type': 'message', 'target_id': 'm', 'count': 1, 'first_ts': NOW, 'last_ts': NOW, 'last_tick_ts': NOW}]
+        kept = mf.tick_rumination(items, NOW, random.Random(1))
+        self.assertEqual(len(kept), 1); self.assertEqual(kept[0]['count'], 1)
+    def test_rumination_text(self):
+        self.assertIn('你还在想', mf.rumination_text([{'text_snippet': '那句话'}]))
+
+if __name__ == '__main__':
+    unittest.main()