dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_local_embedding_health.py

@@ -0,0 +1,258 @@
+# -*- coding: utf-8 -*-
+"""task-193 本地 embedding 健康投影单测（/health + 面板，只读，不加载模型）。
+
+main.py 无法在离线单测里 import（依赖 AstrBot），因此这里用 AST 从 main.py
+抽取四个纯投影函数与 _local_embedding_health 方法并执行；面板断言读取
+app.js / index.src.html / 构建后的 index.html 源码。
+"""
+import ast
+import json
+import sys
+import tempfile
+import types
+import unittest
+from pathlib import Path
+from unittest import mock
+
+ROOT = Path(__file__).resolve().parents[2]
+MAIN_SRC = (ROOT / "main.py").read_text(encoding="utf-8")
+APP_SRC = (ROOT / "pages" / "dashboard" / "app.js").read_text(encoding="utf-8")
+TPL_SRC = (ROOT / "pages" / "dashboard" / "index.src.html").read_text(encoding="utf-8")
+BUILT_SRC = (ROOT / "pages" / "dashboard" / "index.html").read_text(encoding="utf-8")
+
+HELPER_NAMES = ("_local_embedding_switch", "_local_embedding_value",
+                "_probe_local_embedding", "_local_embedding_payload")
+
+
+def _projection_namespace():
+    tree = ast.parse(MAIN_SRC)
+    functions = {node.name: node for node in tree.body
+                 if isinstance(node, ast.FunctionDef)
+                 and node.name in HELPER_NAMES}
+    missing = [name for name in HELPER_NAMES if name not in functions]
+    if missing:
+        raise AssertionError("main.py is missing helpers: %s" % missing)
+    plugin = next((node for node in tree.body
+                   if isinstance(node, ast.ClassDef)
+                   and node.name == "BioCorePlugin"), None)
+    if plugin is None:
+        raise AssertionError("BioCorePlugin not found")
+    method = next((node for node in plugin.body
+                   if isinstance(node, ast.FunctionDef)
+                   and node.name == "_local_embedding_health"), None)
+    if method is None:
+        raise AssertionError("_local_embedding_health not found")
+    module = ast.Module(
+        body=[functions[name] for name in HELPER_NAMES] + [method],
+        type_ignores=[])
+    namespace = {}
+    exec(compile(module, str(ROOT / "main.py"), "exec"), namespace)
+    return namespace
+
+
+class _FakeEngine:
+    def __init__(self, status, detail=None):
+        self.status = status
+        self.detail = detail or {}
+
+    def health(self):
+        return {"local_embedding": self.status, "embedding": dict(self.detail)}
+
+
+class _FakeSelf:
+    def __init__(self, config, engines=None, switch=None):
+        self.config = config
+        self._memory_module_engines = engines or {}
+        self._switch = switch
+
+    def _local_embedding_enabled(self):
+        if callable(self._switch):
+            return bool(self._switch(self.config))
+        return False
+
+
+class ProjectionTest(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.ns = _projection_namespace()
+
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.root = Path(self._tmp.name)
+
+    def tearDown(self):
+        self._tmp.cleanup()
+
+    def _payload(self, config):
+        return self.ns["_local_embedding_payload"](config)
+
+    def test_switch_off_returns_no_field(self):
+        self.assertIsNone(self._payload(
+            {"embedding_local_fallback_enabled": False}))
+        self.assertIsNone(self._payload(
+            {"embedding_local_fallback_enabled": "off"}))
+
+    def test_default_off_returns_no_field(self):
+        self.assertIsNone(self._payload({}))
+        self.assertIsNone(self._payload(
+            {"embedding_local_fallback_enabled": False}))
+
+    def test_missing_when_enabled_without_model_path(self):
+        payload = self._payload(
+            {"embedding_local_fallback_enabled": True})
+        self.assertEqual(payload["local_embedding"], "missing")
+        self.assertEqual(payload["local_embedding_model_path"], "")
+        self.assertEqual(payload["local_embedding_threads"], 2)
+        self.assertEqual(payload["local_embedding_timeout_s"], 8.0)
+        self.assertEqual(payload["local_embedding_detail"]["status"], "missing")
+        self.assertEqual(payload["local_embedding_detail"]["reason"], "未配置模型路径")
+        for key in ("model_path", "threads", "timeout_s", "reason"):
+            self.assertIn(key, payload["local_embedding_detail"])
+
+    def test_failed_when_model_file_missing(self):
+        path = str(self.root / "nope.onnx")
+        payload = self._payload({"embedding_local_fallback_enabled": True,
+                "embedding_local_model_path": path})
+        self.assertEqual(payload["local_embedding"], "failed")
+        self.assertEqual(payload["local_embedding_model_path"], path)
+        self.assertIn("not found", payload["local_embedding_detail"]["reason"])
+
+    def test_failed_when_tokenizer_missing(self):
+        model = self.root / "model.onnx"
+        model.write_bytes(b"fake")
+        with mock.patch("importlib.util.find_spec", return_value=object()):
+            payload = self._payload({"embedding_local_fallback_enabled": True,
+                "embedding_local_model_path": str(model)})
+        self.assertEqual(payload["local_embedding"], "failed")
+        self.assertIn("tokenizer", payload["local_embedding_detail"]["reason"])
+
+    def test_ok_when_component_files_ready(self):
+        model = self.root / "model.onnx"
+        model.write_bytes(b"fake")
+        (self.root / "tokenizer.json").write_text(
+            json.dumps({"model": {"vocab": {}}}), encoding="utf-8")
+        with mock.patch("importlib.util.find_spec", return_value=object()):
+            payload = self._payload({
+                "embedding_local_fallback_enabled": True,
+                "embedding_local_model_path": str(model),
+                "embedding_local_threads": 3,
+                "embedding_timeout_s": 6,
+            })
+        self.assertEqual(payload["local_embedding"], "ok")
+        self.assertEqual(payload["local_embedding_threads"], 3)
+        self.assertEqual(payload["local_embedding_timeout_s"], 6.0)
+        self.assertEqual(payload["local_embedding_detail"]["status"], "ok")
+
+    def test_failed_when_onnxruntime_missing(self):
+        model = self.root / "model.onnx"
+        model.write_bytes(b"fake")
+        (self.root / "tokenizer.json").write_text("{}", encoding="utf-8")
+        with mock.patch("importlib.util.find_spec", return_value=None):
+            payload = self._payload({"embedding_local_fallback_enabled": True,
+                "embedding_local_model_path": str(model)})
+        self.assertEqual(payload["local_embedding"], "failed")
+        self.assertIn("onnxruntime",
+                      payload["local_embedding_detail"]["reason"])
+
+    def test_engine_health_is_preferred(self):
+        engine = _FakeEngine("ok", {"local_model_path": "C:/m.onnx",
+                                    "local_threads": 2, "timeout_s": 8.0,
+                                    "local_embedding": "ok"})
+        method = self.ns["_local_embedding_health"]
+        out = method(_FakeSelf({"embedding_local_fallback_enabled": True},
+                               {"s1": engine},
+                               switch=self.ns["_local_embedding_switch"]))
+        self.assertEqual(out["local_embedding"], "ok")
+        self.assertEqual(out["local_embedding_model_path"], "C:/m.onnx")
+        failed = _FakeEngine("failed", {"local_model_path": "C:/bad.onnx"})
+        out = method(_FakeSelf({"embedding_local_fallback_enabled": True},
+                               {"s1": failed},
+                               switch=self.ns["_local_embedding_switch"]))
+        self.assertEqual(out["local_embedding"], "failed")
+
+    def test_switch_off_never_probes(self):
+        with mock.patch.dict(self.ns, {
+                "_probe_local_embedding": mock.Mock(
+                    side_effect=AssertionError("must not probe"))}):
+            self.assertIsNone(self._payload(
+                {"embedding_local_fallback_enabled": False}))
+
+    def test_switch_off_beats_engine_health(self):
+        engine = _FakeEngine("ok", {"local_model_path": "C:/m.onnx"})
+        method = self.ns["_local_embedding_health"]
+        out = method(_FakeSelf({"embedding_local_fallback_enabled": False},
+                               {"s1": engine}))
+        self.assertIsNone(out)
+
+    def test_projection_never_loads_the_model(self):
+        tree = ast.parse(MAIN_SRC)
+        plugin = next(node for node in tree.body
+                      if isinstance(node, ast.ClassDef)
+                      and node.name == "BioCorePlugin")
+        method_node = next(node for node in plugin.body
+                           if isinstance(node, ast.FunctionDef)
+                           and node.name == "_local_embedding_health")
+        probe_node = next(node for node in tree.body
+                          if isinstance(node, ast.FunctionDef)
+                          and node.name == "_probe_local_embedding")
+        for source in (ast.get_source_segment(MAIN_SRC, probe_node),
+                       ast.get_source_segment(MAIN_SRC, method_node),
+                       ast.get_source_segment(
+                           MAIN_SRC,
+                           next(node for node in tree.body
+                                if isinstance(node, ast.FunctionDef)
+                                and node.name == "_local_embedding_payload"))):
+            self.assertTrue(source)
+            self.assertNotIn("InferenceSession", source)
+            self.assertNotIn("warmup(", source)
+            self.assertNotIn(".encode(", source)
+            self.assertNotIn("import onnxruntime", source)
+
+
+class WiringSourceTest(unittest.TestCase):
+    def test_health_route_and_page_status_wiring(self):
+        routes_src = (ROOT / "biocore_model" / "plugin_routes.py").read_text(
+            encoding="utf-8")
+        self.assertIn("_local_emb = self._local_embedding_health()", routes_src)
+        self.assertIn("_data.update(_local_emb)", routes_src)
+        self.assertIn("self._local_embedding_enabled()", routes_src)
+        self.assertIn("embedding_local_fallback_enabled", routes_src)
+        self.assertIn("/astrbot_plugin_biocore/health", MAIN_SRC)
+        self.assertIn("self.page_health", MAIN_SRC)
+        self.assertIn("async def page_health", MAIN_SRC)
+        self.assertIn("_local_emb = self._local_embedding_health()", MAIN_SRC)
+        self.assertIn("_data.update(_local_emb)", MAIN_SRC)
+        self.assertIn("local_embedding_detail", MAIN_SRC)
+
+    def test_schema_default_is_off(self):
+        schema = json.loads((ROOT / "_conf_schema.json").read_text(
+            encoding="utf-8-sig"))
+        entry = schema["embedding_local_fallback_enabled"]
+        self.assertIs(entry["default"], False)
+        self.assertIn("23MB", entry["hint"])
+        self.assertIn("默认关", entry["description"])
+
+    def test_panel_markup_has_switch_and_status(self):
+        for source in (TPL_SRC, BUILT_SRC):
+            self.assertIn('id="localEmbeddingRow"', source)
+            self.assertIn('id="swLocalEmbedding"', source)
+            self.assertIn('id="localEmbeddingState"', source)
+            self.assertIn('id="localEmbeddingDetail"', source)
+            self.assertIn("本地向量", source)
+            self.assertIn("本地向量兜底", source)
+
+    def test_panel_renderer_handles_ok_missing_failed_off(self):
+        self.assertIn("function renderLocalEmbedding()", APP_SRC)
+        self.assertIn("renderLocalEmbedding();", APP_SRC)
+        self.assertIn("local_embedding_detail", APP_SRC)
+        self.assertIn("embedding_local_fallback_enabled", APP_SRC)
+        self.assertIn("swLocalEmbedding", APP_SRC)
+        self.assertIn("本地向量：关（纯远程）", APP_SRC)
+        self.assertIn("本地向量：失败", APP_SRC)
+        self.assertIn("未配置模型路径", APP_SRC)
+        self.assertIn("meta.model_path", APP_SRC)
+        self.assertIn("renderLocalEmbedding", APP_SRC)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_memory_affect_encoding.py

@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*-
+import os, tempfile, unittest
+from pathlib import Path
+from biocore_memory.engine import MemoryEngine
+from biocore_memory.core import config as engine_config
+
+class AffectEncodingTest(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.dir = Path(self.tmp.name)
+        self._saved = {k: os.environ.get(k) for k in
+                       ("BIOCORE_AFFECT_ENCODING", "BIOCORE_AFFECT_ENCODE_A", "BIOCORE_AFFECT_ENCODE_B")}
+        for k in self._saved:
+            os.environ.pop(k, None)
+
+    def tearDown(self):
+        self.tmp.cleanup()
+        for k, v in self._saved.items():
+            if v is None: os.environ.pop(k, None)
+            else: os.environ[k] = v
+
+    def remember(self, affect, **event):
+        e = MemoryEngine(data_dir=str(self.dir), affect=affect)
+        payload = {"text": event.pop("text", "affect encoding probe"), "role": "user"}
+        payload.update(event)
+        return e.remember(payload)
+
+    def test_flag_defaults_off(self):
+        self.assertIs(engine_config.FLAGS.get("affect_encoding"), False)
+
+    def test_off_does_not_change(self):
+        result = self.remember({"v": 0.8, "a": 0.8})
+        self.assertAlmostEqual(result["importance"], 0.2, places=4)
+
+    def test_high_arousal_boosts(self):
+        os.environ["BIOCORE_AFFECT_ENCODING"] = "1"
+        result = self.remember({"v": 0.8, "a": 0.8})
+        self.assertAlmostEqual(result["importance"], 0.40, places=3)
+
+    def test_calm_no_change(self):
+        os.environ["BIOCORE_AFFECT_ENCODING"] = "1"
+        result = self.remember({"v": 0.0, "a": 0.0})
+        self.assertAlmostEqual(result["importance"], 0.2, places=3)
+
+    def test_negative_valence_uses_abs(self):
+        os.environ["BIOCORE_AFFECT_ENCODING"] = "1"
+        result = self.remember({"v": -0.8, "a": 0.8})
+        self.assertAlmostEqual(result["importance"], 0.40, places=3)
+
+    def test_explicit_importance_wins(self):
+        os.environ["BIOCORE_AFFECT_ENCODING"] = "1"
+        result = self.remember({"v": 0.9, "a": 0.9}, importance=0.9)
+        self.assertAlmostEqual(result["importance"], 0.9, places=4)
+
+    def test_clamped_to_one(self):
+        os.environ["BIOCORE_AFFECT_ENCODING"] = "1"
+        os.environ["BIOCORE_AFFECT_ENCODE_A"] = "0.9"
+        os.environ["BIOCORE_AFFECT_ENCODE_B"] = "0.9"
+        result = self.remember({"v": 1.0, "a": 1.0})
+        self.assertLessEqual(result["importance"], 1.0)
+        self.assertGreater(result["importance"], 0.9)
+
+    def test_no_affect_state_falls_back(self):
+        os.environ["BIOCORE_AFFECT_ENCODING"] = "1"
+        result = self.remember(None)
+        self.assertAlmostEqual(result["importance"], 0.2, places=4)
+
+    def test_custom_weights(self):
+        os.environ["BIOCORE_AFFECT_ENCODING"] = "1"
+        os.environ["BIOCORE_AFFECT_ENCODE_A"] = "0.3"
+        os.environ["BIOCORE_AFFECT_ENCODE_B"] = "0.2"
+        result = self.remember({"v": -0.8, "a": 0.8})
+        self.assertAlmostEqual(result["importance"], 0.60, places=3)
+
+    def test_flag_enabled_via_engine_flags(self):
+        e = MemoryEngine(data_dir=str(self.dir), affect={"v": 0.8, "a": 0.8})
+        e.flags["affect_encoding"] = True
+        result = e.remember({"text": "flag probe", "role": "user"})
+        self.assertAlmostEqual(result["importance"], 0.40, places=3)

package/python/biocore_model/tests/test_memory_backend.py

@@ -0,0 +1,332 @@
+# -*- coding: utf-8 -*-
+"""task-146: user-selectable memory backend (json | sqlite | auto)."""
+import ast
+import json
+import tempfile
+import types
+import unittest
+from pathlib import Path
+
+from biocore_model import memory_store as ms
+
+ROOT = Path(__file__).resolve().parents[2]
+MAIN = ROOT / "main.py"
+SOURCE = MAIN.read_text(encoding="utf-8")
+SCHEMA = json.loads((ROOT / "_conf_schema.json").read_text(encoding="utf-8"))
+DASH = ROOT / "pages" / "dashboard"
+SRC_HTML = (DASH / "index.src.html").read_text(encoding="utf-8")
+APP_JS = (DASH / "app.js").read_text(encoding="utf-8")
+INDEX_HTML = (DASH / "index.html").read_text(encoding="utf-8")
+
+_HELPER_NAMES = ("_memory_store_module", "_memory_backend_attr",
+                 "_json_entries_count", "_init_memory_backend",
+                 "_memory_store_handle", "_memory_backend_switch")
+
+
+def _load_helpers():
+    tree = ast.parse(SOURCE)
+    nodes = [item for item in tree.body
+             if isinstance(item, ast.FunctionDef) and item.name in _HELPER_NAMES]
+    log = []
+    ns = {"json": json, "Path": Path,
+          "logger": types.SimpleNamespace(
+              info=lambda *a, **k: log.append(a),
+              warning=lambda *a, **k: None,
+              debug=lambda *a, **k: None)}
+    exec(compile(ast.Module(body=nodes, type_ignores=[]), "<mem_backend>",
+                 "exec"), ns)
+    return ns, log
+
+
+def _load_save_method():
+    """AST-load BioCorePlugin._memory_save_doc_for_session (+ its helpers)."""
+    tree = ast.parse(SOURCE)
+    cls = next(node for node in tree.body
+               if isinstance(node, ast.ClassDef) and node.name == "BioCorePlugin")
+    method = next(item for item in cls.body
+                  if isinstance(item, ast.FunctionDef)
+                  and item.name == "_memory_save_doc_for_session")
+    clone = ast.FunctionDef(name=method.name, args=method.args, body=method.body,
+                            decorator_list=[], returns=method.returns,
+                            type_comment=None, lineno=method.lineno,
+                            col_offset=method.col_offset,
+                            end_lineno=method.end_lineno,
+                            end_col_offset=method.end_col_offset)
+    import time as _time
+    ns = {"json": json, "Path": Path, "time": _time, "MEMORY_DIR": None,
+          "logger": types.SimpleNamespace(
+              info=lambda *a, **k: None, warning=lambda *a, **k: None,
+              debug=lambda *a, **k: None)}
+    for name in ("_memory_store_module", "_memory_store_handle",
+                 "_json_entries_count"):
+        node = next(item for item in tree.body
+                    if isinstance(item, ast.FunctionDef) and item.name == name)
+        exec(compile(ast.Module(body=[node], type_ignores=[]), "<helper>",
+                     "exec"), ns)
+    exec(compile(ast.Module(body=[clone], type_ignores=[]), "<save>",
+                 "exec"), ns)
+    return ns["_memory_save_doc_for_session"], ns
+
+
+HELPERS, LOG = _load_helpers()
+
+
+class FakePlugin:
+    def __init__(self, setting="auto"):
+        self.memory_storage_backend = setting
+        self._memory_backend = "json"
+        self._memory_store_cache = None
+
+
+def _doc(name="friend", count=2):
+    return {"entries": [{"text": "%s-%d" % (name, i), "ts": float(i)}
+                        for i in range(count)]}
+
+
+def _write_json(memory_dir, name, doc):
+    path = Path(memory_dir) / (name + ".json")
+    path.write_text(json.dumps(doc, ensure_ascii=False), encoding="utf-8")
+
+
+class NormalizeTest(unittest.TestCase):
+    def test_values_and_default(self):
+        self.assertEqual(ms.normalize_backend("json"), "json")
+        self.assertEqual(ms.normalize_backend("SQLite "), "sqlite")
+        self.assertEqual(ms.normalize_backend("auto"), "auto")
+        self.assertEqual(ms.normalize_backend("nope"), "auto")
+        self.assertEqual(ms.normalize_backend(None), "auto")
+
+    def test_resolve_backend_auto(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            self.assertEqual(ms.resolve_backend("auto", tmp), "json")
+            _write_json(tmp, "friend", _doc())
+            ms.ensure_store(tmp)
+            self.assertEqual(ms.resolve_backend("auto", tmp), "sqlite")
+            self.assertEqual(ms.resolve_backend("json", tmp), "json")
+            self.assertEqual(ms.resolve_backend("sqlite", tmp), "sqlite")
+
+    def test_healthy_check_rejects_corruption(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            (Path(tmp) / ms.SQLITE_FILE).write_bytes(b"garbage")
+            self.assertFalse(ms.db_present_healthy(tmp))
+            self.assertEqual(ms.resolve_backend("auto", tmp), "json")
+
+
+class SwitchTest(unittest.TestCase):
+    def test_json_to_sqlite_counts_and_backup(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            _write_json(tmp, "friend", _doc("friend", 3))
+            report = ms.switch_backend("sqlite", tmp)
+            self.assertTrue(report["ok"], report)
+            self.assertEqual(report["from"], "json")
+            self.assertEqual(report["to"], "sqlite")
+            self.assertEqual(report["state"], "imported")
+            self.assertEqual(report["counts_after"]["entries"], 3)
+            self.assertTrue(report["backup"]["dir"])
+            self.assertTrue(Path(report["backup"]["dir"]).is_dir())
+            self.assertEqual(ms.db_counts(tmp)["entries"], 3)
+
+    def test_switch_idempotent_both_directions(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            _write_json(tmp, "friend", _doc("friend", 2))
+            _write_json(tmp, "group", _doc("group", 1))
+            first = ms.switch_backend("sqlite", tmp)
+            second = ms.switch_backend("sqlite", tmp)
+            self.assertEqual(first["counts_after"]["entries"], 3)
+            self.assertEqual(second["counts_after"]["entries"], 3)
+            self.assertEqual(second["state"], "noop")
+            back1 = ms.switch_backend("json", tmp)
+            self.assertTrue(back1["ok"], back1)
+            self.assertEqual(back1["to"], "json")
+            self.assertEqual(back1["counts_after"]["entries"], 3)
+            back2 = ms.switch_backend("json", tmp)
+            self.assertEqual(back2["counts_after"]["entries"], 3)
+            self.assertEqual(ms.json_counts(tmp)["entries"], 3)
+
+    def test_roundtrip_content_preserved(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            _write_json(tmp, "friend", _doc("friend", 2))
+            ms.switch_backend("sqlite", tmp)
+            store = ms.open_store(tmp)
+            try:
+                before = [e["text"] for e in store.load_doc("friend")["entries"]]
+            finally:
+                store.close()
+            ms.switch_backend("json", tmp)
+            doc = json.loads((Path(tmp) / "friend.json").read_text(encoding="utf-8"))
+            after = [e["text"] for e in doc["entries"]]
+            self.assertEqual(before, after)
+
+    def test_switch_failure_keeps_previous_backend(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            _write_json(tmp, "friend", _doc("friend", 2))
+            plugin = FakePlugin("json")
+            original = ms.switch_backend
+
+            def boom(*args, **kwargs):
+                raise RuntimeError("disk full")
+
+            ms.switch_backend = boom
+            try:
+                report = HELPERS["_memory_backend_switch"](
+                    plugin, "sqlite", tmp)
+            finally:
+                ms.switch_backend = original
+            self.assertFalse(report["ok"])
+            self.assertEqual(report["backend"], "json")
+            self.assertTrue(report.get("fallback"))
+            self.assertEqual(plugin._memory_backend, "json")
+
+
+class InitHelperTest(unittest.TestCase):
+    def test_json_setting_reads_json(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            _write_json(tmp, "friend", _doc("friend", 3))
+            plugin = FakePlugin("json")
+            report = HELPERS["_init_memory_backend"](plugin, tmp)
+            self.assertEqual(report["backend"], "json")
+            self.assertEqual(report["entries"], 3)
+            self.assertEqual(plugin._memory_backend, "json")
+            self.assertIsNone(plugin._memory_store_cache)
+
+    def test_sqlite_setting_imports_and_logs(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            _write_json(tmp, "friend", _doc("friend", 2))
+            plugin = FakePlugin("sqlite")
+            report = HELPERS["_init_memory_backend"](plugin, tmp)
+            self.assertEqual(report["backend"], "sqlite")
+            self.assertEqual(report["entries"], 2)
+            self.assertIsNotNone(plugin._memory_store_cache)
+            lines = [" ".join(str(part) for part in row) for row in LOG]
+            try:
+                self.assertTrue(any(
+                    "memory backend=%s entries=%d" in line
+                    and str(line).endswith("sqlite 2") for line in lines),
+                    lines[-3:])
+            finally:
+                plugin._memory_store_cache.close()
+                plugin._memory_store_cache = None
+
+    def test_auto_setting_follows_db_presence(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            _write_json(tmp, "friend", _doc("friend", 1))
+            plugin = FakePlugin("auto")
+            first = HELPERS["_init_memory_backend"](plugin, tmp)
+            self.assertEqual(first["backend"], "json")
+            self.assertEqual(first["entries"], 1)
+            ms.switch_backend("sqlite", tmp)
+            plugin2 = FakePlugin("auto")
+            second = HELPERS["_init_memory_backend"](plugin2, tmp)
+            self.assertEqual(second["backend"], "sqlite")
+            self.assertEqual(second["entries"], 1)
+            plugin2._memory_store_cache.close()
+
+    def test_init_failure_falls_back_to_json(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            _write_json(tmp, "friend", _doc("friend", 2))
+            plugin = FakePlugin("sqlite")
+            original = ms.ensure_backend
+
+            def boom(*args, **kwargs):
+                raise RuntimeError("no sqlite")
+
+            ms.ensure_backend = boom
+            try:
+                report = HELPERS["_init_memory_backend"](plugin, tmp)
+            finally:
+                ms.ensure_backend = original
+            self.assertEqual(report["backend"], "json")
+            self.assertTrue(report["fallback"])
+            self.assertEqual(plugin._memory_backend, "json")
+            self.assertEqual(report["entries"], 2)
+
+
+class FallbackConsistencyTest(unittest.TestCase):
+    def test_sqlite_open_failure_recounts_json_entries(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            _write_json(tmp, "friend", _doc("friend", 3))
+            plugin = FakePlugin("sqlite")
+            original = ms.open_store
+
+            def boom(*args, **kwargs):
+                raise RuntimeError("db handle unavailable")
+
+            ms.open_store = boom
+            try:
+                report = HELPERS["_init_memory_backend"](plugin, tmp)
+            finally:
+                ms.open_store = original
+            self.assertEqual(report["backend"], "json")
+            self.assertTrue(report["fallback"])
+            self.assertEqual(report["entries"], 3)   # counted from JSON
+            self.assertEqual(plugin._memory_backend, "json")
+
+    def test_sqlite_write_failure_degrades_to_json(self):
+        save, ns = _load_save_method()
+
+        class BoomStore:
+            def save_doc(self, session, doc):
+                raise RuntimeError("disk full")
+
+        with tempfile.TemporaryDirectory() as tmp:
+            ns["MEMORY_DIR"] = Path(tmp)
+            plugin = types.SimpleNamespace(
+                _memory_backend="sqlite", _memory_store_cache=BoomStore())
+            path = Path(tmp) / "friend.json"
+            doc = {"entries": [{"text": "新写入", "ts": 1.0}]}
+            save(plugin, path, doc)
+            self.assertTrue(path.is_file())
+            saved = json.loads(path.read_text(encoding="utf-8"))
+            self.assertEqual(saved["entries"][0]["text"], "新写入")
+            self.assertEqual(plugin._memory_backend, "json")
+            self.assertIsNone(plugin._memory_store_cache)
+
+
+class WiringTest(unittest.TestCase):
+    def test_config_attr_and_startup_call(self):
+        self.assertIn('self.config.get("memory_storage_backend", "auto")',
+                      SOURCE)
+        self.assertIn("_init_memory_backend(", SOURCE)
+        self.assertIn("self._memory_backend = \"json\"", SOURCE)
+
+    def test_handler_route_and_log_format(self):
+        self.assertIn("async def page_memory_backend", SOURCE)
+        self.assertIn("/astrbot_plugin_biocore/page/memory_backend", SOURCE)
+        self.assertIn("[biocore] memory backend=%s entries=%d", SOURCE)
+        self.assertIn("_memory_backend_switch(self, target, MEMORY_DIR", SOURCE)
+
+    def test_storage_helpers_wired_into_memory_paths(self):
+        for marker in ("_memory_store_handle(self, MEMORY_DIR)",
+                       "store.save_doc(session, doc)",
+                       "store.load_doc(safe)",
+                       "store.load_doc(Path(path).stem)",
+                       "store.stats()",
+                       "store.all_docs()"):
+            self.assertIn(marker, SOURCE)
+
+    def test_status_payload_exposes_backend(self):
+        self.assertIn('"memory_storage_backend":', SOURCE)
+        self.assertIn('"memory_backend":', SOURCE)
+        routes = (ROOT / "biocore_model" / "plugin_routes.py").read_text(
+            encoding="utf-8")
+        self.assertIn('"memory_storage_backend":', routes)
+
+    def test_schema_entry(self):
+        cfg = SCHEMA.get("memory_storage_backend") or {}
+        self.assertEqual(cfg.get("type"), "string")
+        self.assertEqual(cfg.get("default"), "auto")
+        self.assertEqual(cfg.get("options"), ["json", "sqlite", "auto"])
+
+    def test_panel_dropdown(self):
+        self.assertIn('id="memoryStorageBackend"', SRC_HTML)
+        for label in ("JSON 文件", "SQLite 数据库", "自动"):
+            self.assertIn(label, SRC_HTML)
+        self.assertIn("page/memory_backend", APP_JS)
+        self.assertIn("renderMemoryBackend", APP_JS)
+        # the inlined dashboard ships the same control
+        self.assertIn('id="memoryStorageBackend"', INDEX_HTML)
+        self.assertIn("MEM_BACKEND_LABELS", INDEX_HTML)
+
+
+if __name__ == "__main__":
+    unittest.main()