dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_intero_style.py

@@ -0,0 +1,146 @@
+# -*- coding: utf-8 -*-
+"""P1-2 interoception -> expression style tests (intero_style.py + wiring)."""
+import ast
+import types
+import unittest
+from pathlib import Path
+
+from biocore_model import intero_style as ist
+
+ROOT = Path(__file__).resolve().parents[2]
+MAIN = ROOT / "main.py"
+SOURCE = MAIN.read_text(encoding="utf-8")
+
+# three clearly different felt states
+TENSE = {"tension": 0.9, "warmth": 0.15, "heaviness": 0.85, "clarity": 0.3}
+WARM = {"tension": 0.1, "warmth": 0.9, "heaviness": 0.1, "clarity": 0.8}
+FUZZY = {"tension": 0.45, "warmth": 0.5, "heaviness": 0.3, "clarity": 0.12}
+
+
+class LevelsTest(unittest.TestCase):
+    def test_levels_clamped(self):
+        self.assertEqual(ist.levels({"tension": 5, "warmth": -1}),
+                         {"tension": 1.0, "warmth": 0.0,
+                          "heaviness": 0.0, "clarity": 0.0})
+
+    def test_invalid_intero_is_neutral(self):
+        out = ist.style(None)
+        self.assertEqual(out["tone"], "")
+        self.assertEqual(out["target"], 10)
+        self.assertEqual(out["cap"], 30)
+        self.assertEqual(ist.initiative(None), 0.5)
+
+
+class StyleDifferenceTest(unittest.TestCase):
+    def test_three_profiles_are_distinguishable(self):
+        tense = ist.style(TENSE)
+        warm = ist.style(WARM)
+        fuzzy = ist.style(FUZZY)
+        # length: tense/fuzzy shorter, warm longer
+        self.assertLess(tense["cap"], warm["cap"])
+        self.assertLess(fuzzy["cap"], warm["cap"])
+        self.assertLess(tense["target"], warm["target"])
+        # tone: each profile gets its own directive
+        self.assertIn("情绪", tense["tone"])
+        self.assertIn("亲近", warm["tone"])
+        self.assertIn("确认", fuzzy["tone"])
+        self.assertEqual(len({tense["tone"], warm["tone"], fuzzy["tone"]}), 3)
+        # length factor monotone: tense < fuzzy < warm
+        self.assertLess(tense["factor"], fuzzy["factor"])
+        self.assertLess(fuzzy["factor"], warm["factor"])
+
+    def test_initiative_ordering(self):
+        tense = ist.initiative(TENSE)
+        fuzzy = ist.initiative(FUZZY)
+        warm = ist.initiative(WARM)
+        self.assertLess(tense, fuzzy)
+        self.assertLess(fuzzy, warm)
+        self.assertGreaterEqual(tense, 0.0)
+        self.assertLessEqual(warm, 1.0)
+
+    def test_tension_and_heaviness_shorten(self):
+        self.assertLess(ist.length_factor(TENSE), 1.0)
+        only_tense = ist.style({"tension": 1.0}, target=10, cap=30)
+        self.assertLess(only_tense["cap"], 30)
+        only_heavy = ist.style({"heaviness": 1.0}, target=10, cap=30)
+        self.assertLess(only_heavy["cap"], 30)
+
+    def test_warmth_lengthens(self):
+        warm = ist.style(WARM, target=10, cap=30)
+        self.assertGreater(warm["cap"], 30)
+        self.assertGreater(warm["target"], 10)
+
+    def test_low_clarity_asks_to_confirm(self):
+        self.assertIn("确认", ist.tone({"clarity": 0.1}))
+        self.assertEqual(ist.tone({"clarity": 0.9}), "")
+
+    def test_bounds_and_floor(self):
+        out = ist.style(TENSE, target=1, cap=1)
+        self.assertGreaterEqual(out["target"], ist.MIN_TARGET)
+        self.assertGreaterEqual(out["cap"], out["target"])
+        self.assertLessEqual(out["cap"], ist.MAX_CAP)
+        tiny = ist.style({"tension": 1.0, "heaviness": 1.0}, target=10,
+                         cap=30)
+        self.assertGreaterEqual(tiny["cap"], ist.MIN_CAP)
+
+    def test_deterministic(self):
+        self.assertEqual(ist.style(WARM), ist.style(dict(WARM)))
+
+
+def _load_intero_helper():
+    tree = ast.parse(SOURCE)
+    node = next(item for item in tree.body
+                if isinstance(item, ast.FunctionDef)
+                and item.name == "_intero_style")
+    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)
+    ns = {"logger": types.SimpleNamespace(
+        info=lambda *a, **k: None, warning=lambda *a, **k: None,
+        debug=lambda *a, **k: None)}
+    exec(compile(ast.Module(body=[clone], type_ignores=[]),
+                 "<_intero_style>", "exec"), ns)
+    return ns[node.name]
+
+
+HELPER = _load_intero_helper()
+
+
+class FakeCore:
+    def __init__(self, intero):
+        self.intero = intero
+
+
+class WiringTest(unittest.TestCase):
+    def test_main_wiring_markers(self):
+        self.assertIn("def _intero_style(core, target, cap)", SOURCE)
+        self.assertIn("_intero_style(", SOURCE)
+        self.assertIn("intero_style as _intero", SOURCE)
+        self.assertIn("expression_style", SOURCE)
+        self.assertGreaterEqual(SOURCE.count("_istyle = _intero_style("), 2)
+
+    def test_helper_applies_and_exposes_style(self):
+        core = FakeCore(TENSE)
+        out = HELPER(core, 10, 30)
+        self.assertEqual(out["tone"], ist.style(TENSE)["tone"])
+        self.assertLess(out["cap"], 30)
+        self.assertEqual(core.expression_style["tone"], out["tone"])
+
+    def test_helper_failure_is_identity(self):
+        class BoomCore:
+            @property
+            def intero(self):
+                raise RuntimeError("boom")
+
+        core = BoomCore()
+        out = HELPER(core, 12, 32)
+        self.assertEqual(out["target"], 12)
+        self.assertEqual(out["cap"], 32)
+        self.assertEqual(out["tone"], "")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_item3_numeric.py

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+"""item-3: LEX + bio_state text emotion word lists are gone; numeric path only."""
+import inspect
+import unittest
+from pathlib import Path
+
+from biocore_model import bio_const, bio_emotion, bio_state
+from biocore_model.bio_state import StateMixin
+
+PKG = Path(__file__).resolve().parents[1]
+
+
+class Dummy:
+    def __init__(self):
+        self.conflict_ema = 0.0
+        self.rumination_ema = 0.0
+        self.rumination_suppress = False
+        self.rumination_effect_enabled = False
+        self._neg_repeat = 0
+        self._last_neg_topic = ""
+
+
+class TableRemovalTest(unittest.TestCase):
+    def test_bio_const_has_no_lex(self):
+        self.assertFalse(hasattr(bio_const, "LEX"))
+
+    def test_bio_emotion_source_has_no_lex(self):
+        source = (PKG / "bio_emotion.py").read_text(encoding="utf-8")
+        self.assertNotIn("LEX", source)
+
+    def test_bio_emotion_has_no_command_word_lists(self):
+        source = (PKG / "bio_emotion.py").read_text(encoding="utf-8")
+        for word in ("必须", "服从", "不许", "麻烦"):
+            self.assertNotIn(word, source, word)
+
+    def test_bio_state_has_no_text_emotion_words(self):
+        source = (PKG / "bio_state.py").read_text(encoding="utf-8")
+        for word in ("不对", "你错了", "矛盾", "难受", "委屈", "崩溃"):
+            self.assertNotIn(word, source, word)
+
+
+class NumericConflictTest(unittest.TestCase):
+    def test_goal_blocked_raises_conflict(self):
+        dummy = Dummy()
+        out = StateMixin.update_conflict_ema(dummy, "随便什么字",
+                                             dims={"goal": -1.0})
+        self.assertGreater(out["delta"], 0.0)
+        self.assertGreater(out["conflict_ema"], 0.0)
+
+    def test_blame_raises_conflict(self):
+        dummy = Dummy()
+        out = StateMixin.update_conflict_ema(dummy, "", dims={"blame": 1.0})
+        self.assertGreater(out["delta"], 0.3)
+
+    def test_text_words_are_ignored(self):
+        dummy = Dummy()
+        out = StateMixin.update_conflict_ema(
+            dummy, "不对 你错了 矛盾 但是 说错了 纠正")
+        self.assertEqual(out["delta"], 0.0)
+
+    def test_correction_flag_still_counted(self):
+        dummy = Dummy()
+        plain = StateMixin.update_conflict_ema(dummy, "", dims={})
+        dummy2 = Dummy()
+        flagged = StateMixin.update_conflict_ema(dummy2, "", correction=True)
+        self.assertGreater(flagged["delta"], plain["delta"])
+
+
+class NumericRuminationTest(unittest.TestCase):
+    def test_negative_label_increases(self):
+        dummy = Dummy()
+        out = StateMixin.update_rumination_ema(dummy, "", emotion="sadness",
+                                              intensity=0.8)
+        self.assertGreater(out["rumination_ema"], 0.0)
+
+    def test_text_words_without_signal_do_not_increase(self):
+        dummy = Dummy()
+        out = StateMixin.update_rumination_ema(dummy, "难受 难过 委屈 崩溃",
+                                              emotion="neutral")
+        self.assertEqual(out["rumination_ema"], 0.0)
+        self.assertFalse(out["repeat"])
+
+    def test_dims_hit_marks_negative(self):
+        dummy = Dummy()
+        out = StateMixin.update_rumination_ema(dummy, "", emotion="neutral",
+                                              dims={"hit": 0.8})
+        self.assertGreater(out["rumination_ema"], 0.0)
+
+    def test_repeat_same_label_counts(self):
+        dummy = Dummy()
+        StateMixin.update_rumination_ema(dummy, "", emotion="anger")
+        second = StateMixin.update_rumination_ema(dummy, "", emotion="anger")
+        self.assertTrue(second["repeat"])
+        self.assertEqual(second["repeat_count"], 2)
+
+    def test_neutral_decays(self):
+        dummy = Dummy()
+        dummy.rumination_ema = 0.8
+        out = StateMixin.update_rumination_ema(dummy, "", emotion="neutral",
+                                              novelty=0.9)
+        self.assertLess(out["rumination_ema"], 0.8)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_item6_numeric.py

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+"""item-6: goal/identity scoring is numeric (probe dims), no word tables."""
+import unittest
+from pathlib import Path
+
+from biocore_model.bio_goal import GoalMixin
+from biocore_model.bio_identity import IdentityMixin
+
+PKG = Path(__file__).resolve().parents[1]
+
+
+class GoalDummy(GoalMixin):
+    def __init__(self):
+        self.goals = [
+            {"key": "a", "name": "Goal A", "priority": 0.9, "progress": 0.0},
+            {"key": "b", "name": "Goal B", "priority": 0.3, "progress": 0.0},
+        ]
+        self.appraisal = {}
+        self.goal_scores = {}
+        self.goal_focus = ""
+        self.goal_conflict = []
+        self.a = 0.5
+
+    @staticmethod
+    def _text_similarity(left, right):
+        return 0.0
+
+
+class IdentityDummy(IdentityMixin):
+    def __init__(self):
+        self.trust = 0.5
+        self.v = 0.0
+        self.stress = 0.1
+        self.echo_trace = 0.0
+        self.identity_threat_stress_enabled = False
+
+
+class SourceAuditTest(unittest.TestCase):
+    def test_bio_goal_has_no_positive_negative_word_table(self):
+        source = (PKG / "bio_goal.py").read_text(encoding="utf-8")
+        self.assertNotIn("_pos = sum", source)
+        self.assertNotIn("_neg = sum", source)
+        for word in ("谢谢", "废物", "闭嘴", "讨厌"):
+            self.assertNotIn(word, source, word)
+
+    def test_bio_identity_has_no_word_tables(self):
+        source = (PKG / "bio_identity.py").read_text(encoding="utf-8")
+        for word in ("你不是她", "不配", "cold_words", "warm_words",
+                     "废物", "傻子"):
+            self.assertNotIn(word, source, word)
+
+
+class IdentityNumericTest(unittest.TestCase):
+    def test_text_alone_is_not_a_threat(self):
+        dummy = IdentityDummy()
+        self.assertFalse(dummy.detect_identity_threat(
+            "你不是她，你就是个工具废物"))
+
+    def test_dims_blame_and_involve_are_a_threat(self):
+        dummy = IdentityDummy()
+        self.assertTrue(dummy.detect_identity_threat(
+            dims={"blame": 0.8, "involve": 0.6}))
+
+    def test_dims_hit_is_a_threat(self):
+        self.assertTrue(IdentityDummy().detect_identity_threat(
+            dims={"hit": 0.8}))
+
+    def test_apply_is_default_off(self):
+        dummy = IdentityDummy()
+        self.assertFalse(dummy.apply_identity_threat(dims={"hit": 0.9}))
+        self.assertAlmostEqual(dummy.stress, 0.1)
+
+    def test_apply_enabled_bumps_stress(self):
+        dummy = IdentityDummy()
+        dummy.identity_threat_stress_enabled = True
+        self.assertTrue(dummy.apply_identity_threat(dims={"hit": 0.9}))
+        self.assertGreater(dummy.stress, 0.1)
+
+    def test_feedback_user_numeric_cold_and_warm(self):
+        cold = IdentityDummy()
+        cold.feedback_user(cold=1.0)
+        self.assertLess(cold.trust, 0.5)
+        warm = IdentityDummy()
+        warm.feedback_user(warm=1.0)
+        self.assertGreater(warm.trust, 0.5)
+
+
+class GoalNumericTest(unittest.TestCase):
+    def test_goal_relevance_from_dims(self):
+        dummy = GoalDummy()
+        self.assertGreater(dummy._goal_relevance_from_dims(
+            {"involve": 1.0}), 0.4)
+        self.assertEqual(dummy._goal_relevance_from_dims({}), 0.0)
+
+    def test_update_goals_uses_dims(self):
+        dummy = GoalDummy()
+        dummy._update_goals("随便什么字", dims={"involve": 1.0, "blame": 0.5})
+        self.assertGreater(dummy.appraisal["goal_relevance"], 0.0)
+        self.assertTrue(all(v > 0.0 for v in dummy.goal_scores.values()))
+        self.assertLess(dummy.appraisal["norm_compatibility"], 0.5)
+
+    def test_update_goals_ignores_text_words_without_dims(self):
+        dummy = GoalDummy()
+        dummy._update_goals("谢谢 喜欢 谢谢")
+        self.assertEqual(dummy.appraisal["goal_relevance"], 0.0)
+
+    def test_goal_evidence_dims_beats_text(self):
+        dummy = GoalDummy()
+        goal = dummy.goals[0]
+        self.assertGreater(dummy._goal_evidence(goal, "", "",
+                                               dims={"hit": 1.0}), 0.0)
+        self.assertEqual(dummy._goal_evidence(goal, "谢谢 喜欢", ""), 0.0)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_layered_memory.py

@@ -0,0 +1,174 @@
+# -*- coding: utf-8 -*-
+import unittest
+
+from biocore_model import layered_memory as lm
+
+NOW = 1_700_000_000
+DAY = 86400
+
+
+def _entry(eid, text, ts=0, importance=0.5, role="user", **extra):
+    data = {"id": eid, "text": text, "role": role, "ts": ts,
+            "importance": importance}
+    data.update(extra)
+    return data
+
+
+def _resident(eid, text, ts=0, importance=0.5, **extra):
+    return _entry(eid, text, ts, importance, tags=["resident"], **extra)
+
+
+def _section(text, header):
+    out, inside = [], False
+    for line in text.splitlines():
+        if line.strip() in ("常驻事实：", "相关事件："):
+            inside = line.strip() == header
+            continue
+        if inside:
+            out.append(line)
+    return out
+
+
+class LayeredMemoryTest(unittest.TestCase):
+    def test_classification_uses_only_tags_kind_and_pin(self):
+        # no keyword heuristics: a factual sentence without a tag stays retrieval
+        plain = _entry("x1", "我姓王，我妈住院了")
+        self.assertEqual(lm.classify(plain), "retrieval")
+        tagged = _entry("x2", "我姓王", tags=["resident"])
+        self.assertEqual(lm.classify(tagged), "resident")
+        kinded = _entry("x3", "我姓王", kind="profile")
+        self.assertEqual(lm.classify(kinded), "resident")
+        pinned = _entry("x4", "我姓王", pin=True)
+        self.assertEqual(lm.classify(pinned), "resident")
+        self.assertEqual(lm.classify(_entry("x5", "我姓王", deleted=True)), "")
+
+    def test_resident_facts_plus_capped_retrieval(self):
+        entries = [
+            _resident("f1", "小夏，昵称夏夏", NOW - 5 * DAY, 0.8),
+            _resident("f2", "不喜欢下雨", NOW - 4 * DAY, 0.7),
+            _entry("e1", "周末打算去海边", NOW - 3 * DAY),
+            _entry("e2", "周五陪小夏体检", NOW - 2 * DAY),
+            _entry("e3", "项目报告下周五截止", NOW - DAY),
+        ]
+        out = lm.render(entries, recalled_ids=["e1", "e2", "e3"], now=NOW)
+        self.assertIn("[分层记忆]", out)
+        self.assertIn("夏夏", out)
+        self.assertIn("海边", out)
+        self.assertEqual(len(_section(out, "相关事件：")), 2)
+
+    def test_retrieval_limit_is_configurable_and_clamped(self):
+        entries = [_resident("f1", "昵称小七", NOW, 0.9)]
+        entries += [_entry("e%d" % i, "事件 %d" % i, NOW - i * DAY)
+                    for i in range(1, 7)]
+        one = lm.render(entries, retrieval_limit=1, now=NOW)
+        self.assertEqual(len(_section(one, "相关事件：")), 1)
+        zero = lm.render(entries, retrieval_limit=0, now=NOW)
+        self.assertNotIn("相关事件：", zero)
+        self.assertIn("小七", zero)
+        huge = lm.render(entries, retrieval_limit=99, now=NOW)
+        self.assertEqual(len(_section(huge, "相关事件：")),
+                         lm.HARD_RETRIEVAL_LIMIT)
+
+    def test_resident_facts_survive_three_days(self):
+        entries = [
+            _resident("f1", "叫他夏夏", NOW - 10 * DAY, 0.9),
+            _resident("f2", "最怕打雷", NOW - 9 * DAY, 0.6),
+            _entry("e1", "上周去了海边", NOW - 3 * DAY),
+        ]
+        for day in range(3):
+            out = lm.render(entries, recalled_ids=["e1"],
+                            now=NOW + day * DAY)
+            self.assertIn("夏夏", out)
+            self.assertIn("打雷", out)
+            self.assertIn("常驻事实：", out)
+
+    def test_recalled_order_is_respected(self):
+        entries = [_entry("e1", "第一个事件", NOW - DAY),
+                   _entry("e2", "第二个事件", NOW - 2 * DAY),
+                   _entry("e3", "第三个事件", NOW - 3 * DAY)]
+        out = lm.render(entries, recalled_ids=["e3", "e1", "e2"], now=NOW)
+        rows = _section(out, "相关事件：")
+        self.assertIn("第三个事件", rows[0])
+        self.assertIn("第一个事件", rows[1])
+
+    def test_resident_entries_never_repeat_in_retrieval(self):
+        entries = [_resident("f1", "叫他阿夏", NOW, 0.9),
+                   _entry("e1", "昨天一起吃了火锅", NOW - DAY)]
+        out = lm.render(entries, recalled_ids=["f1", "e1"], now=NOW)
+        rows = _section(out, "相关事件：")
+        self.assertEqual(len(rows), 1)
+        self.assertNotIn("阿夏", rows[0])
+
+    def test_duplicate_facts_collapse(self):
+        entries = [_resident("f1", "昵称是夏夏", NOW, 0.8),
+                   _resident("f2", "昵称是夏夏！", NOW - DAY, 0.7)]
+        out = lm.render(entries, now=NOW)
+        self.assertEqual(out.count("夏夏"), 1)
+
+    def test_deleted_and_summarized_entries_are_skipped(self):
+        entries = [_resident("f1", "叫小夏", NOW, 0.9, deleted=True),
+                   _resident("f2", "喜欢下雨", NOW, 0.9, summarized=True),
+                   _resident("f3", "长期摘要", NOW, 0.9, role="summary")]
+        self.assertEqual(lm.render(entries, now=NOW), "")
+
+    def test_pinned_event_becomes_resident(self):
+        entries = [_entry("e1", "明天下午三点开会", NOW - DAY, 0.4, pin=True)]
+        out = lm.render(entries, now=NOW)
+        self.assertIn("常驻事实：", out)
+        self.assertIn("三点开会", out)
+        self.assertNotIn("相关事件：", out)
+
+    def test_empty_and_malformed_inputs(self):
+        self.assertEqual(lm.render(None), "")
+        self.assertEqual(lm.render([]), "")
+        self.assertEqual(lm.render([None, "x", {}, {"text": "  "}]), "")
+
+    def test_render_is_bounded_and_trims(self):
+        long_fact = "很长的偏好描述" * 60
+        entries = [_resident("f1", long_fact, NOW, 0.9),
+                   _entry("e1", "事件" * 80, NOW - DAY)]
+        out = lm.render(entries, now=NOW)
+        self.assertLessEqual(len(out), lm.MAX_CHARS)
+        self.assertIn("…", out)
+        rows = _section(out, "相关事件：")
+        self.assertEqual(len(rows), 1)
+        self.assertLessEqual(len(rows[0]), lm.EVENT_TRIM + 8)
+
+    def test_fact_entry_validation(self):
+        self.assertIsNone(lm.fact_entry("", 0.9))
+        self.assertIsNone(lm.fact_entry("他姓王", 0.3))
+        candidate = lm.fact_entry("他姓王", 0.8)
+        self.assertEqual(candidate["text"], "他姓王")
+        self.assertEqual(candidate["tags"], ["resident"])
+        self.assertEqual(candidate["memory_source"], "probe_fact")
+        long_fact = "他" * 40
+        self.assertEqual(len(lm.fact_entry(long_fact, 0.9)["text"]),
+                         lm.FACT_MAX_CHARS)
+
+    def test_duplicate_resident_detection(self):
+        entries = [_resident("f1", "他姓王，住在杭州")]
+        self.assertTrue(lm.duplicate_resident("他姓王，住在杭州", entries))
+        self.assertTrue(lm.duplicate_resident("他姓王住在杭州啊", entries))
+        self.assertFalse(lm.duplicate_resident("他喜欢打游戏", entries))
+        # a non-resident entry with the same text is not a resident duplicate
+        self.assertFalse(lm.duplicate_resident(
+            "他姓王，住在杭州", [_entry("e1", "他姓王，住在杭州")]))
+
+    def test_should_write_fact_once_per_message(self):
+        entries = [_resident("f1", "他姓王")]
+        written = {}
+        self.assertTrue(lm.should_write_fact("他喜欢打游戏", 0.8, entries,
+                                             written, "msg-1"))
+        written["msg-1"] = 1.0
+        self.assertFalse(lm.should_write_fact("他喜欢打游戏", 0.8, entries,
+                                              written, "msg-1"))
+        self.assertFalse(lm.should_write_fact("他姓王", 0.8, entries, {},
+                                              "msg-2"))
+        self.assertFalse(lm.should_write_fact("他喜欢打游戏", 0.4, entries, {},
+                                              "msg-3"))
+        self.assertTrue(lm.should_write_fact("他喜欢打游戏", 0.8, entries, {},
+                                             "msg-3"))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_leak_guard.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+import unittest
+import interpretation
+
+
+class ProtocolEchoStripTest(unittest.TestCase):
+    def setUp(self):
+        interpretation.LEAK_GUARD.update({'protocol_echo_stripped': 0, 'prompt_rule_echo': 0, 'protocol_echo_seen': 0})
+
+    def test_echo_sentence_at_end_is_removed(self):
+        visible, _ = interpretation.parse_response('今天天气不错。标签必须隐藏，不要解释。')
+        self.assertNotIn('必须隐藏', visible)
+        self.assertIn('今天天气不错', visible)
+        self.assertEqual(interpretation.LEAK_GUARD['protocol_echo_stripped'], 1)
+
+    def test_echo_sentence_in_middle_keeps_neighbours(self):
+        visible, _ = interpretation.parse_response('我明白你的意思。标签只出现一次，必须隐藏。我们继续聊。')
+        self.assertNotIn('标签只出现一次', visible)
+        self.assertIn('我明白', visible)
+        self.assertIn('我们继续聊', visible)
+
+    def test_multiple_echo_sentences_all_removed(self):
+        visible, _ = interpretation.parse_response('标签格式说明。不要解释。正常内容。')
+        self.assertNotIn('<bc>', visible)
+        self.assertNotIn('不要解释', visible)
+        self.assertIn('正常内容', visible)
+
+    def test_normal_hidden_word_not_stripped(self):
+        visible, _ = interpretation.parse_response('这件事我一直隐藏着没说。')
+        self.assertEqual(visible.strip(), '这件事我一直隐藏着没说。')
+
+    def test_rule_echo_kept_but_counted(self):
+        visible, _ = interpretation.parse_response('先接住情绪，再谈事情；今天想聊什么？')
+        self.assertIn('先接住情绪', visible)
+        self.assertEqual(interpretation.LEAK_GUARD['prompt_rule_echo'], 1)
+
+    def test_normal_reply_no_metrics(self):
+        visible, _ = interpretation.parse_response('晚安，做个好梦。')
+        self.assertEqual(visible.strip(), '晚安，做个好梦。')
+        self.assertEqual(interpretation.LEAK_GUARD['prompt_rule_echo'], 0)
+
+    def test_tag_plus_json_plus_fence_no_leak(self):
+        visible, _ = interpretation.parse_response('你好。\n```json\n{"e":"sad","i":0.5}\n```\n<bc>{"e":"sad","i":0.5}</bc>\n必须隐藏。')
+        self.assertNotIn('<bc>', visible)
+        self.assertNotIn('"e"', visible)
+        self.assertNotIn('```', visible)
+        self.assertIn('你好', visible)
+
+    def test_unclosed_tag_removed(self):
+        visible, _ = interpretation.parse_response('在的。<bc>{"e":"joy","i":0.4}')
+        self.assertNotIn('<bc>', visible)
+        self.assertIn('在的', visible)
+
+    def test_bad_json_label_not_crash(self):
+        visible, _ = interpretation.parse_response('嗯。<bc>not json</bc>')
+        self.assertNotIn('<bc>', visible)
+
+    def test_echo_only_reply_becomes_empty(self):
+        visible, _ = interpretation.parse_response('标签必须隐藏，不要解释。')
+        self.assertEqual(visible.strip(), '')
+
+    def test_leak_guard_snapshot_shape(self):
+        interpretation.parse_response('标签必须隐藏。开心吗？')
+        snap = interpretation.leak_guard_snapshot()
+        for key in ('protocol_echo', 'prompt_rule_echo', 'tag_missing', 'tag_invalid'):
+            self.assertIn(key, snap)
+        self.assertGreaterEqual(snap['protocol_echo'], 1)
+
+    def test_prompt_rule_multiple_occurrences_counted_once(self):
+        interpretation.parse_response('先接住情绪。先缓和。')
+        self.assertEqual(interpretation.LEAK_GUARD['prompt_rule_echo'], 1)
+
+
+if __name__ == '__main__':
+    unittest.main()