dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_turn_memory_panel.py

@@ -0,0 +1,174 @@
+# -*- coding: utf-8 -*-
+"""P0-3 本轮记忆可见: turn_memory receipt -> dashboard card projection.
+
+The view logic lives in pages/dashboard/turn_memory_view.js (pure functions);
+these tests execute it with node and also pin the dashboard wiring + the
+backend receipt contract.
+"""
+import json
+import shutil
+import subprocess
+import tempfile
+import unittest
+from pathlib import Path
+
+from biocore_model import turn_memory as tm
+
+ROOT = Path(__file__).resolve().parents[2]
+DASH = ROOT / "pages" / "dashboard"
+VIEW = DASH / "turn_memory_view.js"
+APP = DASH / "app.js"
+SRC_HTML = DASH / "index.src.html"
+INDEX_HTML = DASH / "index.html"
+MAIN = ROOT / "main.py"
+ROUTES = ROOT / "biocore_model" / "plugin_routes.py"
+
+NODE = shutil.which("node")
+
+RECORD = {
+    "ts": 1800000000.0,
+    "reply": "好，知道了",
+    "count": 4,
+    "rows": [
+        {"rank": 1, "id": "e1", "text": "她周五去体检",
+         "source": "lexical", "tier": "hot", "score": 0.8123,
+         "reason": "关键词 0.40 / 近期 0.20"},
+        {"rank": 2, "id": "e2", "text": "老板张总",
+         "source": "graph", "tier": "warm", "score": 0.5,
+         "reason": "规则打分"},
+        {"rank": 3, "id": "e3", "text": "常驻事实：她在医院工作",
+         "source": "resident", "tier": "hot", "score": 0.4},
+        {"rank": 4, "id": "e4", "text": "上次聊到奶茶",
+         "source": "retrieval", "tier": "cold", "score": 0.2,
+         "reason": "留存 0.10"},
+    ],
+}
+
+
+def _node_view(payload):
+    """Run turn_memory_view.js against *payload* and return its projections."""
+    script = (
+        "require(" + json.dumps(str(VIEW)) + ");"
+        "const v=globalThis.BioTurnMemoryView;"
+        "const p=JSON.parse(require('fs').readFileSync(process.argv[1],'utf8'));"
+        "process.stdout.write(JSON.stringify({"
+        "summary:v.summary(p),all:v.rows(p),two:v.rows(p,2),"
+        "zero:v.rows(p,0),none:v.summary(null)}));"
+    )
+    with tempfile.TemporaryDirectory() as tmp:
+        path = Path(tmp) / "payload.json"
+        path.write_text(json.dumps(payload, ensure_ascii=False), encoding="utf-8")
+        done = subprocess.run([NODE, "-e", script, str(path)],
+                              capture_output=True, text=True,
+                              encoding="utf-8", errors="replace", timeout=60)
+    if done.returncode != 0:
+        raise AssertionError("node view failed: " + done.stderr[-800:])
+    return json.loads(done.stdout)
+
+
+@unittest.skipUnless(NODE, "node is required for the dashboard view tests")
+class ViewProjectionTest(unittest.TestCase):
+    def test_four_rows_keep_source_and_reason(self):
+        out = _node_view(RECORD)
+        rows = out["summary"]["rows"]
+        self.assertEqual(len(rows), 4)
+        self.assertEqual([row["source"] for row in rows],
+                         ["lexical", "graph", "resident", "retrieval"])
+        self.assertEqual(rows[0]["reason"], "关键词 0.40 / 近期 0.20")
+        self.assertEqual(rows[2]["reason"], "规则打分")  # default filled in
+        self.assertEqual(rows[0]["rank"], 1)
+        self.assertEqual(rows[0]["id"], "e1")
+        self.assertAlmostEqual(rows[0]["score"], 0.8123)
+        self.assertEqual(out["summary"]["count"], 4)
+        self.assertEqual(out["summary"]["total"], 4)
+
+    def test_never_more_than_four_rows(self):
+        payload = dict(RECORD)
+        payload["rows"] = RECORD["rows"] + [
+            {"rank": 5, "id": "e5", "text": "第五条", "source": "lexical"},
+            {"rank": 6, "id": "e6", "text": "第六条", "source": "lexical"},
+        ]
+        out = _node_view(payload)
+        self.assertEqual(len(out["all"]), 4)
+        self.assertEqual(len(out["summary"]["rows"]), 4)
+        self.assertEqual([row["id"] for row in out["all"]],
+                         ["e1", "e2", "e3", "e4"])
+
+    def test_empty_or_broken_record_is_safe(self):
+        out = _node_view({"rows": "nope"})
+        self.assertEqual(out["all"], [])
+        self.assertEqual(out["summary"]["count"], 0)
+        self.assertEqual(out["none"]["rows"], [])
+        self.assertEqual(out["none"]["count"], 0)
+        # rows without id and text are dropped
+        out = _node_view({"rows": [{"source": "x"}, {}]})
+        self.assertEqual(out["all"], [])
+
+    def test_limit_argument(self):
+        out = _node_view(RECORD)
+        self.assertEqual(len(out["two"]), 2)
+        self.assertEqual(out["zero"], [])
+        self.assertEqual(out["two"][0]["id"], "e1")
+
+
+class ReceiptContractTest(unittest.TestCase):
+    def test_build_record_keeps_four_sources(self):
+        trace = [
+            {"entry_id": "a1", "text": "她周五体检", "source": "lexical",
+             "tier": "hot", "score": 0.8,
+             "components": {"lexical": 0.4, "recency": 0.2}},
+            {"entry_id": "a2", "text": "老板张总", "source": "graph",
+             "tier": "warm", "score": 0.5},
+            {"entry_id": "a3", "text": "常驻事实", "source": "resident",
+             "tier": "hot", "score": 0.4},
+            {"entry_id": "a4", "text": "上次聊到奶茶", "source": "retrieval",
+             "tier": "cold", "score": 0.2},
+        ]
+        rows = tm.build(trace, limit=4)
+        record = tm.build_record(rows, reply="ok", ts=1.0)
+        self.assertEqual(record["count"], 4)
+        for row in record["rows"]:
+            self.assertTrue(row["source"])
+        project = _node_panel(record) if NODE else None
+        if project is not None:
+            self.assertEqual(project["count"], 4)
+            self.assertEqual(len({row["source"] for row in project["rows"]}), 4)
+
+
+def _node_panel(record):
+    out = _node_view(record)
+    return out["summary"]
+
+
+class DashboardWiringTest(unittest.TestCase):
+    def test_status_payload_exposes_turn_memory(self):
+        for path in (MAIN, ROUTES):
+            text = path.read_text(encoding="utf-8")
+            self.assertIn('"turn_memory"', text)
+            self.assertIn("_last_turn_memory", text)
+
+    def test_source_markup_and_renderer_present(self):
+        src = SRC_HTML.read_text(encoding="utf-8")
+        self.assertIn('id="turnMemoryList"', src)
+        self.assertIn('id="turnMemoryNote"', src)
+        self.assertIn("turn_memory_view.js", src)
+        app = APP.read_text(encoding="utf-8")
+        self.assertIn("function renderTurnMemory()", app)
+        self.assertIn("BioTurnMemoryView", app)
+        self.assertIn("data&&data.turn_memory", app)
+        self.assertIn("renderTurnMemory()", app)
+
+    def test_inlined_index_contains_view_module(self):
+        html = INDEX_HTML.read_text(encoding="utf-8")
+        self.assertIn('id="turnMemoryList"', html)
+        self.assertIn("BioTurnMemoryView", html)
+        self.assertIn("root.BioTurnMemoryView", html)
+
+    def test_inliner_builds_the_view_module(self):
+        inliner = (ROOT / "scripts" / "inline-assets.mjs").read_text(
+            encoding="utf-8")
+        self.assertIn("turn_memory_view.js", inliner)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_ui_settings.py

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+import json, tempfile, unittest
+from pathlib import Path
+from biocore_model import ui_settings
+
+
+class FakePlugin:
+    def __init__(self, data_dir):
+        self.data_dir = data_dir
+        self.reply_soft_limit_enabled = None
+        self.reply_soft_target_chars = None
+        self.reply_soft_max_chars = None
+        self.reply_split_enabled = None
+        self.reply_split_mode = None
+        self.reply_split_max_chars = None
+        self.proactive_autonomy = None
+        self.proactive_send = None
+
+
+class UiSettingsTest(unittest.TestCase):
+    def test_defaults_when_missing(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            data = ui_settings.load(FakePlugin(tmp))
+            self.assertTrue(data["reply_soft"]["enabled"]); self.assertEqual(data["reply_split"]["mode"], "astrbot")
+
+    def test_save_then_load_roundtrip(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            plugin = FakePlugin(tmp)
+            result = ui_settings.save(plugin, {"reply_split": {"enabled": True, "mode": "astrbot"}, "reply_soft": {"target_chars": 10, "max_chars": 30}})
+            self.assertTrue(result["ok"])
+            data = ui_settings.load(plugin)
+            self.assertTrue(data["reply_split"]["enabled"]); self.assertEqual(data["reply_split"]["mode"], "astrbot")
+            self.assertEqual(data["reply_soft"]["max_chars"], 30)
+
+    def test_apply_to_plugin_overrides_runtime(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            plugin = FakePlugin(tmp)
+            ui_settings.save(plugin, {"reply_split": {"enabled": True, "mode": "astrbot"}, "autonomy": {"enabled": True, "send": True}})
+            ui_settings.apply_to_plugin(plugin)
+            self.assertTrue(plugin.reply_split_enabled); self.assertEqual(plugin.reply_split_mode, "astrbot")
+            self.assertTrue(plugin.proactive_autonomy); self.assertTrue(plugin.proactive_send)
+
+    def test_survives_simulated_restart(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            first = FakePlugin(tmp)
+            ui_settings.save(first, {"reply_split": {"enabled": True, "mode": "astrbot"}, "reply_soft": {"target_chars": 10, "max_chars": 30}})
+            second = FakePlugin(tmp)  # fresh instance = restart
+            ui_settings.apply_to_plugin(second)
+            self.assertTrue(second.reply_split_enabled); self.assertEqual(second.reply_split_mode, "astrbot")
+            self.assertEqual(second.reply_soft_target_chars, 10); self.assertEqual(second.reply_soft_max_chars, 30)
+
+    def test_corrupt_file_falls_back(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            plugin = FakePlugin(tmp)
+            ui_settings.settings_path(plugin).write_text("{not json", encoding="utf-8")
+            data = ui_settings.load(plugin)
+            self.assertTrue(data["reply_soft"]["enabled"])
+
+    def test_backups_rotated_to_three(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            plugin = FakePlugin(tmp)
+            for index in range(6):
+                ui_settings.save(plugin, {"reply_split": {"max_chars": 200 + index}})
+            backups = list(Path(tmp).glob("ui_settings.json.bak_*"))
+            self.assertLessEqual(len(backups), 3)
+
+    def test_accumulator_v_survives_restart(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            first = FakePlugin(tmp)
+            ui_settings.save(first, {"autonomy": {"accumulator": {"V": 0.42, "ticks_since_fire": 7}}})
+            data = ui_settings.load(FakePlugin(tmp))
+            self.assertAlmostEqual(data["autonomy"]["accumulator"]["V"], 0.42)
+            self.assertEqual(data["autonomy"]["accumulator"]["ticks_since_fire"], 7)
+
+    def test_schema_written(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            plugin = FakePlugin(tmp)
+            ui_settings.save(plugin, {"autonomy": {"enabled": True}})
+            raw = json.loads(ui_settings.settings_path(plugin).read_text(encoding="utf-8"))
+            self.assertEqual(raw["schema"], 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_ui_settings_authority.py

@@ -0,0 +1,179 @@
+class _Recorder:
+    """Logger stub so tests never import the stdlib logging module."""
+
+    def __init__(self):
+        self.lines = []
+        self.level = 0
+
+    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))
+
+    def setLevel(self, *_a, **_k):
+        return None
+
+    def addHandler(self, *_a, **_k):
+        return None
+
+    def removeHandler(self, *_a, **_k):
+        return None
+
+    debug = info = warning = error = exception = critical = _log
+
+
+# -*- coding: utf-8 -*-
+"""ui_settings single-authority tests: path, migration, idempotency, roundtrip."""
+import json
+import os
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+from biocore_model import ui_settings as ui
+
+ENV_DIR = "BIOCORE_UI_SETTINGS_DIR"
+ENV_LEGACY = "BIOCORE_UI_SETTINGS_LEGACY"
+
+
+class FakePlugin:
+    def __init__(self, data_dir):
+        self.data_dir = str(data_dir)
+
+
+class AuthorityPathTest(unittest.TestCase):
+    def setUp(self):
+        ui._MIGRATED.clear()
+
+    def tearDown(self):
+        ui._MIGRATED.clear()
+
+    def test_two_plugin_objects_share_one_path(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            first = ui.settings_path(FakePlugin(tmp))
+            second = ui.settings_path(FakePlugin(tmp))
+            self.assertEqual(first, second)
+            self.assertEqual(first, Path(tmp) / ui.FILE_NAME)
+
+    def test_plugins_layout_maps_to_plugin_data(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            legacy = Path(tmp) / "plugins" / "astrbot_plugin_biocore_standalone" / "data"
+            legacy.mkdir(parents=True)
+            path = ui.settings_path(FakePlugin(legacy))
+            self.assertEqual(path, Path(tmp) / "plugin_data" / "astrbot_plugin_biocore" / ui.FILE_NAME)
+
+    def test_env_override_wins_for_every_plugin(self):
+        with tempfile.TemporaryDirectory() as tmp, tempfile.TemporaryDirectory() as other:
+            with mock.patch.dict(os.environ, {ENV_DIR: tmp}):
+                a = ui.settings_path(FakePlugin(other))
+                b = ui.settings_path(FakePlugin("/somewhere/else"))
+            self.assertEqual(a, b)
+            self.assertEqual(a, Path(tmp) / ui.FILE_NAME)
+
+    def test_canonical_plugin_data_dir_is_kept(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            canonical = Path(tmp) / "plugin_data" / "astrbot_plugin_biocore_standalone"
+            canonical.mkdir(parents=True)
+            path = ui.settings_path(FakePlugin(canonical))
+            self.assertEqual(path, Path(tmp) / "plugin_data" / "astrbot_plugin_biocore" / ui.FILE_NAME)
+
+
+class MigrationTest(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.authority_dir = Path(self.tmp.name) / "plugin_data"
+        self.legacy = Path(self.tmp.name) / "legacy_ui_settings.json"
+        self.env = mock.patch.dict(os.environ, {
+            ENV_DIR: str(self.authority_dir),
+            ENV_LEGACY: str(self.legacy),
+        })
+        self.env.start()
+        ui._MIGRATED.clear()
+
+    def tearDown(self):
+        ui._MIGRATED.clear()
+        self.env.stop()
+        self.tmp.cleanup()
+
+    def _authority_file(self):
+        return self.authority_dir / ui.FILE_NAME
+
+    def test_a_to_b_migration_merges_keys(self):
+        self.legacy.write_text(json.dumps({"reply_soft": {"max_chars": 77},
+                                           "custom": {"x": 1}}), encoding="utf-8")
+        data = ui.load(FakePlugin(self.tmp.name))
+        self.assertEqual(data["reply_soft"]["max_chars"], 77)
+        raw = json.loads(self._authority_file().read_text(encoding="utf-8"))
+        self.assertEqual(raw["custom"]["x"], 1)
+        self.assertEqual(raw["schema"], 1)
+
+    def test_migration_logged_once(self):
+        self.legacy.write_text(json.dumps({"reply_soft": {"max_chars": 40}}), encoding="utf-8")
+        rec = _Recorder()
+        saved = ui.logger
+        ui.logger = rec
+        try:
+            ui.load(FakePlugin(self.tmp.name))
+            ui.load(FakePlugin(self.tmp.name))
+        finally:
+            ui.logger = saved
+        self.assertEqual(rec.lines.count(ui.MIGRATION_LOG), 1)
+
+    def test_migration_idempotent(self):
+        self.legacy.write_text(json.dumps({"reply_soft": {"max_chars": 55}}), encoding="utf-8")
+        first = ui.load(FakePlugin(self.tmp.name))
+        second = ui.load(FakePlugin(self.tmp.name))
+        self.assertEqual(first["reply_soft"]["max_chars"], 55)
+        self.assertEqual(second["reply_soft"]["max_chars"], 55)
+
+    def test_newer_authority_is_not_overwritten(self):
+        self._authority_file().parent.mkdir(parents=True, exist_ok=True)
+        self._authority_file().write_text(json.dumps({"reply_soft": {"max_chars": 30}}), encoding="utf-8")
+        self.legacy.write_text(json.dumps({"reply_soft": {"max_chars": 77}}), encoding="utf-8")
+        os.utime(self._authority_file(), (2_000, 2_000))
+        os.utime(self.legacy, (1_000, 1_000))
+        data = ui.load(FakePlugin(self.tmp.name))
+        self.assertEqual(data["reply_soft"]["max_chars"], 30)
+
+    def test_newer_legacy_is_merged(self):
+        self._authority_file().parent.mkdir(parents=True, exist_ok=True)
+        self._authority_file().write_text(json.dumps({"reply_soft": {"max_chars": 30},
+                                                       "keep": {"k": 1}}), encoding="utf-8")
+        self.legacy.write_text(json.dumps({"reply_soft": {"max_chars": 77}}), encoding="utf-8")
+        os.utime(self._authority_file(), (1_000, 1_000))
+        os.utime(self.legacy, (2_000, 2_000))
+        data = ui.load(FakePlugin(self.tmp.name))
+        self.assertEqual(data["reply_soft"]["max_chars"], 77)
+        raw = json.loads(self._authority_file().read_text(encoding="utf-8"))
+        self.assertEqual(raw["keep"]["k"], 1)
+
+    def test_legacy_is_never_read_again(self):
+        self.legacy.write_text(json.dumps({"reply_soft": {"max_chars": 44}}), encoding="utf-8")
+        ui.load(FakePlugin(self.tmp.name))
+        self.legacy.write_text(json.dumps({"reply_soft": {"max_chars": 99}}), encoding="utf-8")
+        data = ui.load(FakePlugin(self.tmp.name))
+        self.assertEqual(data["reply_soft"]["max_chars"], 44)
+
+    def test_missing_legacy_does_not_crash(self):
+        data = ui.load(FakePlugin(self.tmp.name))
+        self.assertTrue(data["reply_soft"]["enabled"])
+        self.assertFalse(self._authority_file().exists())
+
+    def test_corrupt_legacy_does_not_crash(self):
+        self.legacy.write_text("{not json", encoding="utf-8")
+        data = ui.load(FakePlugin(self.tmp.name))
+        self.assertTrue(data["reply_soft"]["enabled"])
+
+    def test_save_load_roundtrip_two_plugins(self):
+        first = FakePlugin(self.tmp.name)
+        self.assertTrue(ui.save(first, {"reply_soft": {"max_chars": 25}})["ok"])
+        second = FakePlugin("/elsewhere")
+        self.assertEqual(ui.load(second)["reply_soft"]["max_chars"], 25)
+        self.assertTrue(self._authority_file().is_file())
+        self.assertFalse((Path("/elsewhere") / ui.FILE_NAME).exists())
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_user_appraisal_async.py

@@ -0,0 +1,155 @@
+# -*- coding: utf-8 -*-
+"""Async user appraisal: non-blocking schedule, idempotency, fallback."""
+import ast
+import asyncio
+import json
+import time
+import types
+import unittest
+from pathlib import Path
+
+import interpretation
+
+MAIN = Path(__file__).resolve().parents[2] / "main.py"
+SOURCE = MAIN.read_text(encoding="utf-8")
+
+
+def _load_methods():
+    tree = ast.parse(SOURCE)
+    cls = next(n for n in tree.body
+               if isinstance(n, ast.ClassDef) and n.name == "BioCorePlugin")
+    wanted = ("_user_appraisal_key", "_user_appraisal_immediate",
+              "_schedule_user_appraisal", "_lexical_user_feedback",
+              "_user_appraisal_async")
+    log = []
+    ns = {"asyncio": asyncio, "time": time, "interpretation": interpretation,
+          "logger": types.SimpleNamespace(
+              info=lambda *a, **k: log.append(a),
+              warning=lambda *a, **k: None)}
+    fns = {}
+    for node in cls.body:
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and node.name in wanted:
+            _cls = (ast.AsyncFunctionDef if isinstance(node, ast.AsyncFunctionDef)
+                    else ast.FunctionDef)
+            clone = _cls(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=[]), "<uappr>", "exec"), ns)
+            fns[node.name] = ns[node.name]
+    return fns, log
+
+
+FNS, LOG = _load_methods()
+DIMS_RAW = ('{"dims":{"goal":0.7,"blame":0.1,"control":0.6,"certainty":0.6,'
+            '"novelty":0.2,"involve":0.8,"hit":0.0},"why":"夸","c":0.9}')
+
+
+class FakeCore:
+    def __init__(self):
+        self._snapshot = {"v": 0.0, "a": 0.4, "stress": 0.1, "social": 0.5,
+                          "trust": 0.5, "self_esteem": 0.5}
+        self.needs = {"belonging": 0.6, "self_esteem": 0.6,
+                      "control": 0.6, "meaningful_existence": 0.6}
+        self.loaded = []
+
+    def snapshot(self):
+        return dict(self._snapshot)
+
+    def load_state(self, state):
+        self.loaded.append(dict(state))
+        self._snapshot.update(state)
+
+
+class FakePlugin:
+    def __init__(self, raw=DIMS_RAW):
+        self.raw = raw
+        self.llm_calls = 0
+        self.lexical_fallback_enabled = True
+        self._last_insult_ts = 0.0
+        self._appraisal_seen = {}
+        self._user_appraisal_task = None
+        self._user_appraisal_async = types.MethodType(
+            FNS["_user_appraisal_async"], self)
+        for name in ("_user_appraisal_key", "_user_appraisal_immediate",
+                     "_schedule_user_appraisal", "_lexical_user_feedback"):
+            setattr(self, name, types.MethodType(FNS[name], self))
+
+    async def _llm_v2_call(self, kind, prompt, parser, event=None, timeout_ms=None):
+        self.llm_calls += 1
+        if self.raw is None:
+            return None
+        return self.raw
+
+
+class ScheduleTest(unittest.IsolatedAsyncioTestCase):
+    async def test_schedule_does_not_block(self):
+        plugin = FakePlugin()
+
+        async def slow(*args, **kwargs):
+            await asyncio.sleep(0.3)
+        plugin._user_appraisal_async = slow
+        started = time.time()
+        task = plugin._schedule_user_appraisal(object(), FakeCore(), "夸她")
+        elapsed = time.time() - started
+        self.assertLess(elapsed, 0.05)
+        self.assertIsNotNone(task)
+        await asyncio.wait_for(task, timeout=1)
+
+    async def test_insult_cooling_off_by_default(self):
+        plugin = FakePlugin()
+        plugin.lexical_fallback_enabled = False
+        plugin._user_appraisal_immediate(object(), "你真废物，闭嘴")
+        # item-5: no word-table insult cooling; the probe owns semantics.
+        self.assertEqual(plugin._last_insult_ts, 0.0)
+
+    async def test_async_result_writes_once(self):
+        plugin = FakePlugin()
+        core = FakeCore()
+        event = types.SimpleNamespace(unified_msg_origin="u1", message_id="m1")
+        key = plugin._user_appraisal_key(event)
+        self.assertTrue(await plugin._user_appraisal_async(event, core, "夸她", key))
+        self.assertTrue(core.loaded)
+        self.assertIn(key, plugin._appraisal_seen)
+
+    async def test_idempotent_key(self):
+        plugin = FakePlugin()
+        core = FakeCore()
+        event = types.SimpleNamespace(unified_msg_origin="u1", message_id="m2")
+        key = plugin._user_appraisal_key(event)
+        self.assertTrue(await plugin._user_appraisal_async(event, core, "夸她", key))
+        writes = len(core.loaded)
+        self.assertFalse(await plugin._user_appraisal_async(event, core, "夸她", key))
+        self.assertEqual(len(core.loaded), writes)
+        self.assertEqual(plugin.llm_calls, 1)
+
+    async def test_dims_failure_falls_back_to_words(self):
+        plugin = FakePlugin(raw=None)
+        core = FakeCore()
+        event = types.SimpleNamespace(unified_msg_origin="u1", message_id="m3")
+        key = plugin._user_appraisal_key(event)
+        self.assertFalse(await plugin._user_appraisal_async(event, core, "你真废物", key))
+        self.assertIsNotNone(core.loaded)
+
+    async def test_switch_off_disables_fallback(self):
+        plugin = FakePlugin(raw=None)
+        plugin.lexical_fallback_enabled = False
+        core = FakeCore()
+        event = types.SimpleNamespace(unified_msg_origin="u1", message_id="m4")
+        key = plugin._user_appraisal_key(event)
+        self.assertFalse(await plugin._user_appraisal_async(event, core, "你真废物", key))
+        self.assertFalse(core.loaded)
+
+
+class WiringStaticTest(unittest.TestCase):
+    def test_async_log_and_schedule(self):
+        self.assertIn("async=True", SOURCE)
+        self.assertIn("self._user_appraisal_immediate(event, text)", SOURCE)
+        self.assertNotIn("self._schedule_user_appraisal(event, core, text)", SOURCE)
+        self.assertIn("_user_appraisal_async", SOURCE)
+
+
+if __name__ == "__main__":
+    unittest.main()