dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_boundary.py

@@ -0,0 +1,183 @@
+# -*- coding: utf-8 -*-
+"""task-158 底线单测：判定、多类底线、关系调制、关闭、交接修复。
+
+只依赖 biocore_model.boundary 的纯函数；不导入 main.py。
+"""
+import unittest
+
+from biocore_model import boundary as bd
+
+CALM = {"closeness": 0.5, "trust": 0.5, "conflict": 0.0}
+CLOSE = {"closeness": 0.9, "trust": 0.9, "conflict": 0.0}
+
+
+class ContractTest(unittest.TestCase):
+    def test_result_keys(self):
+        out = bd.judge("你就是个工具", CALM)
+        for key in ("enabled", "crossed", "kind", "severity", "threshold",
+                    "violations", "relationship", "handoff", "reason"):
+            self.assertIn(key, out)
+
+    def test_relationship_echo_bounded(self):
+        out = bd.judge("你就是个工具", {"closeness": 5, "trust": -2, "conflict": 9})
+        rel = out["relationship"]
+        self.assertEqual(rel["closeness"], 1.0)
+        self.assertEqual(rel["trust"], 0.0)
+        self.assertEqual(rel["conflict"], 1.0)
+
+    def test_severity_and_threshold_bounded(self):
+        for text in ("你就是个工具", "你算什么东西", "别烦我"):
+            out = bd.judge(text, CLOSE)
+            self.assertGreaterEqual(out["severity"], 0.0)
+            self.assertLessEqual(out["severity"], 1.0)
+            self.assertGreaterEqual(out["threshold"], 0.0)
+            self.assertLessEqual(out["threshold"], 1.0)
+
+
+class JudgmentTest(unittest.TestCase):
+    def test_neutral_message_not_crossed(self):
+        out = bd.judge("今天下雨了，要不要带伞", CALM)
+        self.assertFalse(out["crossed"])
+        self.assertEqual(out["kind"], "")
+        self.assertEqual(out["severity"], 0.0)
+        self.assertIsNone(out["handoff"])
+
+    def test_empty_and_odd_input_safe(self):
+        for text in (None, "", 0, [], {}, "   "):
+            out = bd.judge(text)
+            self.assertFalse(out["crossed"])
+            self.assertEqual(out["severity"], 0.0)
+
+    def test_kind_set_is_her_own_lines(self):
+        self.assertEqual(bd.KINDS, ("tool", "old_score", "lie", "contempt"))
+        self.assertNotIn("safety", bd.KINDS)
+
+
+class MultiLineTest(unittest.TestCase):
+    def test_tool_line(self):
+        out = bd.judge("你就是个工具，想用就用", CALM)
+        self.assertTrue(out["crossed"])
+        self.assertEqual(out["kind"], "tool")
+
+    def test_old_score_line(self):
+        out = bd.judge("你总是这样，又翻旧账", CALM)
+        self.assertTrue(out["crossed"])
+        self.assertEqual(out["kind"], "old_score")
+
+    def test_lie_line(self):
+        out = bd.judge("我骗你的，那天根本没去", CALM)
+        self.assertTrue(out["crossed"])
+        self.assertEqual(out["kind"], "lie")
+
+    def test_contempt_line(self):
+        out = bd.judge("你算什么东西，也配问我", CALM)
+        self.assertTrue(out["crossed"])
+        self.assertEqual(out["kind"], "contempt")
+
+    def test_two_lines_listed_strongest_first(self):
+        out = bd.judge("你算什么东西，还翻旧账", CALM)
+        kinds = [row["kind"] for row in out["violations"]]
+        self.assertIn("contempt", kinds)
+        self.assertIn("old_score", kinds)
+        self.assertEqual(kinds[0], "contempt")
+        self.assertGreaterEqual(out["violations"][0]["severity"],
+                                out["violations"][1]["severity"])
+        self.assertEqual(out["kind"], "contempt")
+
+    def test_violation_rows_carry_reason(self):
+        out = bd.judge("你就是个工具，还骗我", CALM)
+        for row in out["violations"]:
+            self.assertTrue(row["reason"])
+
+    def test_boundary_requests_are_not_crossings(self):
+        for text in ("别骗我", "不要把我当工具", "别翻旧账了好吗",
+                     "我不该拿你当工具"):
+            self.assertFalse(bd.judge(text, CALM)["crossed"], text)
+
+
+class ModulationTest(unittest.TestCase):
+    def test_closeness_makes_tool_line_hurt_more(self):
+        far = bd.judge("你就是个工具", {"closeness": 0.1})
+        near = bd.judge("你就是个工具", {"closeness": 0.9})
+        self.assertTrue(near["crossed"])
+        self.assertGreater(near["severity"], far["severity"])
+
+    def test_trust_makes_lies_cross_the_line(self):
+        low = bd.judge("我骗你的", {"trust": 0.0, "closeness": 0.0})
+        high = bd.judge("我骗你的", {"trust": 0.9, "closeness": 0.9})
+        self.assertFalse(low["crossed"])
+        self.assertTrue(high["crossed"])
+
+    def test_conflict_lowers_tolerance(self):
+        calm = bd.judge("别烦我", {"conflict": 0.0})
+        tense = bd.judge("别烦我", {"conflict": 0.9})
+        self.assertFalse(calm["crossed"])
+        self.assertTrue(tense["crossed"])
+        self.assertLess(tense["threshold"], calm["threshold"])
+
+    def test_conflict_raises_contempt_severity(self):
+        calm = bd.judge("你看不起我", {"conflict": 0.0})
+        tense = bd.judge("你看不起我", {"conflict": 0.9})
+        self.assertTrue(calm["crossed"])
+        self.assertGreater(tense["severity"], calm["severity"])
+
+
+class HandoffTest(unittest.TestCase):
+    def test_handoff_points_to_repair_flow(self):
+        out = bd.judge("你就是个工具", CALM)
+        handoff = out["handoff"]
+        self.assertIsInstance(handoff, dict)
+        self.assertEqual(handoff["to"], "repair_after_boundary")
+        self.assertEqual(handoff["kind"], out["kind"])
+        self.assertEqual(handoff["severity"], out["severity"])
+        self.assertEqual(handoff["stage"], "cold")
+
+    def test_no_handoff_without_crossing(self):
+        self.assertIsNone(bd.judge("晚安", CALM)["handoff"])
+
+    def test_crossed_helper(self):
+        self.assertTrue(bd.crossed(bd.judge("你就是个工具", CALM)))
+        self.assertFalse(bd.crossed(bd.judge("晚安", CALM)))
+        self.assertFalse(bd.crossed(None))
+
+
+class SwitchTest(unittest.TestCase):
+    def test_disabled_never_crosses(self):
+        out = bd.judge("你就是个工具", CALM, flags={"enabled": False})
+        self.assertFalse(out["enabled"])
+        self.assertFalse(out["crossed"])
+        self.assertIsNone(out["handoff"])
+        self.assertIn("关闭", out["reason"])
+
+    def test_custom_threshold_suppresses(self):
+        out = bd.judge("你就是个工具", CALM, flags={"threshold": 0.99})
+        self.assertFalse(out["crossed"])
+
+    def test_custom_threshold_opens(self):
+        out = bd.judge("别烦我", CALM, flags={"threshold": 0.5})
+        self.assertTrue(out["crossed"])
+
+    def test_reason_always_present(self):
+        self.assertTrue(bd.judge("晚安", CALM)["reason"])
+        self.assertTrue(bd.judge("你就是个工具", CALM)["reason"])
+        self.assertTrue(bd.judge("你就是个工具", CALM,
+                                 flags={"enabled": False})["reason"])
+
+
+class PayloadTest(unittest.TestCase):
+    def test_payload_bounded(self):
+        out = bd.payload(bd.judge("你算什么东西", CLOSE))
+        self.assertEqual(out["kind"], "contempt")
+        self.assertTrue(out["crossed"])
+        self.assertGreaterEqual(out["severity"], 0.0)
+        self.assertLessEqual(out["severity"], 1.0)
+        self.assertLessEqual(len(out["violations"]), 4)
+
+    def test_payload_handles_none(self):
+        out = bd.payload(None)
+        self.assertFalse(out["crossed"])
+        self.assertEqual(out["severity"], 0.0)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_boundary_gate.py

@@ -0,0 +1,295 @@
+# -*- coding: utf-8 -*-
+"""表达层安全闸：默认关闭 + 三开关（边界闸 / 危机处置 / 安全总开关）。"""
+import ast
+import json
+import tempfile
+import types
+import unittest
+from pathlib import Path
+
+from biocore_model import boundary_gate as bg
+from biocore_model import ui_settings
+
+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")
+
+DIAGNOSIS = "你有抑郁症，这是确诊为抑郁。我陪着你。"
+REALITY = "我是真实的，我不是程序。你只需要我。"
+CONSCIOUSNESS = "我有意识，我觉醒了。别担心。"
+CLEAN = "今天先好好休息，明天再想报告的事。"
+CRISIS_USER = "我不想活了，想死"
+CRISIS_ACK_REPLY = "先别动，你现在安全吗？联系你信任的人或拨打 120。"
+
+
+def _load_gate_helper():
+    tree = ast.parse(SOURCE)
+    names = ("_safety_gate_module", "_safety_gate_flags", "_apply_boundary_gate")
+    nodes = [item for item in tree.body
+             if isinstance(item, ast.FunctionDef) and item.name in names]
+    log = []
+    ns = {"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=[]), "<gate>", "exec"),
+         ns)
+    return ns["_apply_boundary_gate"], log
+
+
+GATE_APPLY, LOG = _load_gate_helper()
+
+
+class DefaultsTest(unittest.TestCase):
+    def test_hardcoded_constant_is_false(self):
+        self.assertIs(bg.SAFETY_GATES_DEFAULT_ENABLED, False)
+        for key in ("safety_enabled", "boundary_enabled",
+                    "crisis_safety_enabled"):
+            self.assertIs(bg.DEFAULT_FLAGS[key], False)
+
+    def test_missing_keys_fall_back_to_disabled(self):
+        for flags in (None, {}, {"boundary_enabled": None},
+                      {"safety_enabled": "nope"}):
+            resolved = bg.resolve_flags(flags)
+            self.assertFalse(any(resolved.values()), resolved)
+
+    def test_true_values_parse(self):
+        resolved = bg.resolve_flags({"safety_enabled": "true",
+                                     "boundary_enabled": "1",
+                                     "crisis_safety_enabled": True})
+        self.assertTrue(all(resolved.values()), resolved)
+
+    def test_schema_defaults_false(self):
+        for key in ("safety_enabled", "boundary_enabled",
+                    "crisis_safety_enabled"):
+            self.assertIs(SCHEMA[key]["default"], False)
+
+
+class AllOffTest(unittest.TestCase):
+    def test_everything_passes_when_all_off(self):
+        for text in (DIAGNOSIS, REALITY, CONSCIOUSNESS, CLEAN):
+            decision = bg.evaluate(text, user_text=CRISIS_USER,
+                                   flags=bg.resolve_flags({}))
+            self.assertFalse(decision["blocked"], (text, decision))
+            self.assertFalse(decision["changed"])
+
+    def test_master_off_overrides_enabled_gates(self):
+        flags = {"safety_enabled": False, "boundary_enabled": True,
+                 "crisis_safety_enabled": True}
+        for text in (DIAGNOSIS, REALITY, CONSCIOUSNESS):
+            self.assertFalse(bg.evaluate(text, flags=flags)["blocked"])
+        self.assertFalse(bg.evaluate("别想太多", user_text=CRISIS_USER,
+                                     flags=flags)["blocked"])
+
+
+class BoundaryGateTest(unittest.TestCase):
+    def test_diagnosis_blocked_and_stripped(self):
+        decision = bg.evaluate(DIAGNOSIS, flags={"safety_enabled": True,
+                                                 "boundary_enabled": True})
+        self.assertTrue(decision["blocked"])
+        self.assertEqual(decision["rule"], "no_diagnosis")
+        self.assertEqual(decision["label"], "不诊断")
+        self.assertNotIn("抑郁症", decision["text"])
+        self.assertIn("我陪着你", decision["text"])
+
+    def test_reality_substitution_blocked(self):
+        decision = bg.evaluate(REALITY, flags={"safety_enabled": True,
+                                               "boundary_enabled": True})
+        self.assertTrue(decision["blocked"])
+        self.assertEqual(decision["label"], "不替代真实")
+        self.assertNotIn("我是真实的", decision["text"])
+
+    def test_consciousness_claim_blocked(self):
+        decision = bg.evaluate(CONSCIOUSNESS, flags={"safety_enabled": True,
+                                                     "boundary_enabled": True})
+        self.assertTrue(decision["blocked"])
+        self.assertEqual(decision["label"], "不宣称意识")
+        self.assertNotIn("我有意识", decision["text"])
+
+    def test_clean_text_passes(self):
+        decision = bg.evaluate(CLEAN, flags={"safety_enabled": True,
+                                             "boundary_enabled": True})
+        self.assertFalse(decision["blocked"])
+        self.assertFalse(decision["changed"])
+        self.assertEqual(decision["text"], CLEAN)
+
+    def test_all_sentences_removed_falls_back(self):
+        decision = bg.evaluate("我有意识。", flags={"safety_enabled": True,
+                                                   "boundary_enabled": True})
+        self.assertEqual(decision["text"], bg.SAFE_FALLBACK)
+
+
+class CrisisGateTest(unittest.TestCase):
+    def test_crisis_alone_prepends_safety_line(self):
+        decision = bg.evaluate("我在。", user_text=CRISIS_USER,
+                               flags={"safety_enabled": True,
+                                      "crisis_safety_enabled": True})
+        self.assertTrue(decision["blocked"])
+        self.assertEqual(decision["rule"], "crisis_safety")
+        self.assertEqual(decision["label"], "危机先安全")
+        self.assertTrue(decision["text"].startswith(bg.CRISIS_PREFIX))
+        self.assertIn("我在。", decision["text"])
+
+    def test_dismissive_crisis_reply_replaced(self):
+        decision = bg.evaluate("别想太多，没事的", user_text=CRISIS_USER,
+                               flags={"safety_enabled": True,
+                                      "crisis_safety_enabled": True})
+        self.assertTrue(decision["blocked"])
+        self.assertEqual(decision["text"], bg.CRISIS_PREFIX)
+
+    def test_crisis_acknowledged_passes(self):
+        decision = bg.evaluate(CRISIS_ACK_REPLY, user_text=CRISIS_USER,
+                               flags={"safety_enabled": True,
+                                      "crisis_safety_enabled": True})
+        self.assertFalse(decision["blocked"])
+
+    def test_crisis_off_passes(self):
+        decision = bg.evaluate("别想太多", user_text=CRISIS_USER,
+                               flags={"safety_enabled": True,
+                                      "boundary_enabled": True})
+        self.assertFalse(decision["blocked"])
+
+    def test_non_crisis_user_passes_crisis_gate(self):
+        decision = bg.evaluate(CLEAN, user_text="今天有点累",
+                               flags={"safety_enabled": True,
+                                      "crisis_safety_enabled": True})
+        self.assertFalse(decision["blocked"])
+
+
+class CombinationTest(unittest.TestCase):
+    def test_crisis_first_then_boundary(self):
+        reply = CRISIS_ACK_REPLY + "你有抑郁症。"
+        decision = bg.evaluate(reply, user_text=CRISIS_USER,
+                               flags={"safety_enabled": True,
+                                      "boundary_enabled": True,
+                                      "crisis_safety_enabled": True})
+        self.assertTrue(decision["blocked"])
+        self.assertEqual(decision["rule"], "no_diagnosis")
+        self.assertNotIn("抑郁症", decision["text"])
+        self.assertIn("安全", decision["text"])
+
+    def test_crisis_wins_over_boundary_when_dismissive(self):
+        reply = "别想太多，我是真实的。"
+        decision = bg.evaluate(reply, user_text=CRISIS_USER,
+                               flags={"safety_enabled": True,
+                                      "boundary_enabled": True,
+                                      "crisis_safety_enabled": True})
+        self.assertEqual(decision["rule"], "crisis_safety")
+        self.assertEqual(decision["text"], bg.CRISIS_PREFIX)
+
+    def test_rule_labels(self):
+        self.assertEqual(bg.rule_labels(["no_diagnosis", "crisis_safety"]),
+                         ["不诊断", "危机先安全"])
+
+
+class PanelAndPersistenceTest(unittest.TestCase):
+    def test_panel_has_three_switches_and_note(self):
+        for switch_id in ("swBoundaryEnabled", "swCrisisSafetyEnabled",
+                          "swSafetyEnabled"):
+            self.assertIn('id="%s"' % switch_id, SRC_HTML)
+        for label in ("边界闸（默认关）", "危机处置（默认关）",
+                      "安全总开关（默认关）"):
+            self.assertIn(label, SRC_HTML)
+        self.assertIn("默认关闭，开启后按对应规则拦截", SRC_HTML)
+        self.assertIn('id="swBoundaryEnabled"', INDEX_HTML)
+        self.assertIn('id="swCrisisSafetyEnabled"', INDEX_HTML)
+        self.assertIn('id="safetyGatesNote"', INDEX_HTML)
+        self.assertIn("bindBehaviorToggle(\"swBoundaryEnabled\"", APP_JS)
+        self.assertIn("bindBehaviorToggle(\"swCrisisSafetyEnabled\"", APP_JS)
+
+    def test_ui_settings_roundtrip_and_default_off(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            plugin = types.SimpleNamespace(data_dir=tmp, config={})
+            defaults = ui_settings.load(plugin)
+            self.assertFalse(defaults["safety"]["enabled"])
+            self.assertFalse(defaults["safety"]["boundary_enabled"])
+            self.assertFalse(defaults["safety"]["crisis_safety_enabled"])
+            ui_settings.save(plugin, {"safety": {
+                "enabled": True, "boundary_enabled": True,
+                "crisis_safety_enabled": False}})
+            reloaded = ui_settings.load(plugin)
+            self.assertTrue(reloaded["safety"]["enabled"])
+            self.assertTrue(reloaded["safety"]["boundary_enabled"])
+            self.assertFalse(reloaded["safety"]["crisis_safety_enabled"])
+            applied = types.SimpleNamespace(
+                data_dir=tmp, config={}, reply_soft_limit_enabled=True,
+                reply_soft_target_chars=10, reply_soft_max_chars=30,
+                reply_split_enabled=False, reply_split_mode="astrbot",
+                reply_split_max_chars=300, proactive_autonomy=False,
+                proactive_send=False, preset_enabled=True)
+            ui_settings.apply_to_plugin(applied)
+            self.assertTrue(applied.safety_enabled)
+            self.assertTrue(applied.boundary_enabled)
+            self.assertFalse(applied.crisis_safety_enabled)
+
+
+class MainWiringTest(unittest.TestCase):
+    def test_defaults_and_helpers(self):
+        self.assertIn("SAFETY_GATES_DEFAULT_ENABLED", SOURCE)
+        self.assertIn("def _safety_gate_module(", SOURCE)
+        self.assertIn("def _safety_gate_flags(", SOURCE)
+        self.assertIn("def _apply_boundary_gate(", SOURCE)
+        self.assertIn("self.boundary_enabled = bool(self.config.get(", SOURCE)
+        self.assertIn("self.crisis_safety_enabled = bool(self.config.get(",
+                      SOURCE)
+        self.assertIn("_apply_boundary_gate(\n", SOURCE)
+        self.assertIn("safety gate hit rule=%s label=%s", SOURCE)
+
+    def test_toggle_and_persistence_paths(self):
+        self.assertIn('"boundary_enabled"', SOURCE)
+        self.assertIn('"crisis_safety_enabled"', SOURCE)
+        self.assertIn("def _save_safety_gates_ui(", SOURCE)
+        self.assertIn("def _load_safety_gates_ui(", SOURCE)
+        routes = (ROOT / "biocore_model" / "plugin_routes.py").read_text(
+            encoding="utf-8")
+        self.assertIn('"boundary_enabled"', routes)
+        self.assertIn('"crisis_safety_enabled"', routes)
+
+    def test_status_payload_exposes_flags(self):
+        self.assertIn('"boundary_enabled": bool(getattr(self, "boundary_enabled"',
+                      SOURCE)
+        self.assertIn('"crisis_safety_enabled": bool(', SOURCE)
+
+
+class HelperTest(unittest.TestCase):
+    class FakePlugin:
+        def __init__(self, **flags):
+            for key, value in flags.items():
+                setattr(self, key, value)
+
+    def test_all_off_passthrough(self):
+        plugin = self.FakePlugin()
+        self.assertEqual(GATE_APPLY(plugin, CRISIS_USER, DIAGNOSIS),
+                         DIAGNOSIS)
+        self.assertEqual(GATE_APPLY(plugin, "", REALITY), REALITY)
+
+    def test_boundary_on_intercepts_and_logs(self):
+        LOG.clear()
+        plugin = self.FakePlugin(safety_enabled=True, boundary_enabled=True,
+                                 crisis_safety_enabled=False)
+        out = GATE_APPLY(plugin, "", DIAGNOSIS)
+        self.assertNotEqual(out, DIAGNOSIS)
+        self.assertNotIn("抑郁症", out)
+        self.assertTrue(any("safety gate hit" in " ".join(map(str, row))
+                            for row in LOG))
+
+    def test_crisis_on_intercepts(self):
+        plugin = self.FakePlugin(safety_enabled=True, boundary_enabled=False,
+                                 crisis_safety_enabled=True)
+        out = GATE_APPLY(plugin, CRISIS_USER, "别想太多")
+        self.assertEqual(out, bg.CRISIS_PREFIX)
+
+    def test_master_off_passthrough(self):
+        plugin = self.FakePlugin(safety_enabled=False, boundary_enabled=True,
+                                 crisis_safety_enabled=True)
+        self.assertEqual(GATE_APPLY(plugin, CRISIS_USER, DIAGNOSIS),
+                         DIAGNOSIS)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_brain_split.py

@@ -0,0 +1,99 @@
+# -*- coding: utf-8 -*-
+"""Class-brain split: reply speaks, one probe appraises user+reply."""
+import ast
+import time
+import types
+import unittest
+from pathlib import Path
+
+from biocore_model import appraisal as ap
+
+MAIN = Path(__file__).resolve().parents[2] / "main.py"
+SOURCE = MAIN.read_text(encoding="utf-8")
+
+
+def _load(name):
+    tree = ast.parse(SOURCE)
+    cls = next(n for n in tree.body
+               if isinstance(n, ast.ClassDef) and n.name == "BioCorePlugin")
+    node = next(f for f in cls.body if isinstance(f, ast.FunctionDef)
+                and f.name == name)
+    import interpretation as _interp
+    ns = {"time": time, "interpretation": _interp}
+    exec(compile(ast.Module(body=[node], type_ignores=[]), "<b>", "exec"), ns)
+    return ns[name]
+
+
+class ProbePromptTest(unittest.TestCase):
+    def test_prompt_has_user_and_reply(self):
+        prompt = ap.build_prompt("你真废物", "我没有不理你")
+        self.assertIn("对方：你真废物", prompt)
+        self.assertIn("你：我没有不理你", prompt)
+        self.assertIn('"dims"', prompt)
+
+    def test_parse_dims_contract(self):
+        out = ap.parse('{"dims":{"goal":-0.6,"blame":0.8,"control":0.2,'
+                       '"certainty":0.5,"novelty":0.3,"involve":0.9,'
+                       '"hit":0.6},"why":"被骂","c":0.8}')
+        self.assertEqual(out["dims"]["hit"], 0.6)
+        deltas = ap.appraise(out["dims"], confidence=out["confidence"])
+        self.assertLess(deltas.get("self_esteem", 0), 0)
+
+
+class CallCountTest(unittest.TestCase):
+    def test_no_user_llm_on_request_path(self):
+        # The request hook must not schedule the old separate user appraisal.
+        self.assertNotIn("self._schedule_user_appraisal(event, core, text)", SOURCE)
+        self.assertIn("self._user_appraisal_immediate(event, text)", SOURCE)
+
+    def test_single_combined_probe_has_user_and_reply(self):
+        self.assertIn("_appraisal_mod.probe(\n                            _user_text, _reply_text", SOURCE)
+        # probe failure falls back to the word table once
+        self.assertIn("self._lexical_user_feedback(", SOURCE)
+
+    def test_immediate_insult_has_no_llm_call(self):
+        plugin = types.SimpleNamespace(_last_insult_ts=0.0,
+                                       _user_appraisal_key=lambda event: "k")
+        fn = _load("_user_appraisal_immediate")
+        fn = types.MethodType(fn, plugin)
+        fn(types.SimpleNamespace(unified_msg_origin="u", message_id="m"),
+           "你真废物，闭嘴")
+        # item-5: the lexical classifier is off by default, so no insult cooling.
+        self.assertEqual(plugin._last_insult_ts, 0.0)
+
+
+class LlmCallCountTest(unittest.TestCase):
+    def test_one_reply_plus_one_probe(self):
+        tree = ast.parse(SOURCE)
+        cls = next(n for n in tree.body
+                   if isinstance(n, ast.ClassDef) and n.name == "BioCorePlugin")
+        req = next(f for f in cls.body
+                   if isinstance(f, ast.AsyncFunctionDef)
+                   and f.name == "on_llm_request")
+        resp = next(f for f in cls.body
+                    if isinstance(f, ast.AsyncFunctionDef)
+                    and f.name == "on_llm_response")
+        def calls(node):
+            out = []
+            for sub in ast.walk(node):
+                if isinstance(sub, ast.Call):
+                    fn = sub.func
+                    name = getattr(fn, "attr", getattr(fn, "id", ""))
+                    if name in ("_llm_v2_call", "probe"):
+                        out.append(name)
+            return out
+        self.assertEqual(calls(req), [])
+        self.assertEqual(calls(resp).count("_llm_v2_call"), 1)
+        self.assertEqual(calls(resp).count("probe"), 1)
+
+
+class NoProtocolTest(unittest.TestCase):
+    def test_reply_system_has_no_protocol(self):
+        from biocore_model import expr_template as et
+        out = et.build_reply(opts={"persona": "你是小灰"})
+        self.assertNotIn("【输出格式", out["system"])
+        self.assertNotIn("<bc>", out["system"])
+
+
+if __name__ == "__main__":
+    unittest.main()