dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_template_expr.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+"""Safe template engine: substitution, conditionals, loops, no code execution."""
+import unittest
+
+from biocore_model import template_expr as t
+from biocore_model import expr_template as et
+
+
+class RenderTest(unittest.TestCase):
+    def test_plain_text_untouched(self):
+        self.assertEqual(t.render("你好", {}), "你好")
+
+    def test_substitution(self):
+        self.assertEqual(t.render("你好{{name}}", {"name": "老板"}), "你好老板")
+
+    def test_missing_variable_is_empty(self):
+        self.assertEqual(t.render("[{{missing}}]", {}), "[]")
+
+    def test_if_else(self):
+        self.assertEqual(t.render("{% if trust > 0.5 %}亲近{% else %}疏远{% endif %}",
+                                  {"trust": 0.7}), "亲近")
+        self.assertEqual(t.render("{% if trust > 0.5 %}亲近{% else %}疏远{% endif %}",
+                                  {"trust": 0.1}), "疏远")
+
+    def test_elif_chain(self):
+        v = {"trust": 0.3}
+        self.assertEqual(t.render("{% if trust > 0.5 %}a{% elif trust > 0.2 %}b{% else %}c{% endif %}", v), "b")
+
+    def test_for_loop(self):
+        self.assertEqual(t.render("{% for x in tags %}[{{x}}]{% endfor %}", {"tags": ["a", "b"]}), "[a][b]")
+
+    def test_nested_if(self):
+        tpl = "{% if a %}A{% if b %}B{% endif %}{% endif %}"
+        self.assertEqual(t.render(tpl, {"a": 1, "b": 1}), "AB")
+        self.assertEqual(t.render(tpl, {"a": 1, "b": 0}), "A")
+
+    def test_arithmetic_and_helpers(self):
+        self.assertEqual(t.render("{{ len(tags) }}", {"tags": [1, 2, 3]}), "3")
+        self.assertEqual(t.render("{{ min(a, b) }}", {"a": 2, "b": 5}), "2")
+
+    def test_no_code_execution(self):
+        out = t.render('{{ __import__("os").system("echo pwn") }}', {})
+        self.assertEqual(out, "")
+        self.assertEqual(t.render("{{ ().__class__ }}", {}), "")
+
+    def test_bad_syntax_is_safe(self):
+        self.assertEqual(t.render("{% if %}x{% endif %}", {}), "")
+
+
+class WiringTest(unittest.TestCase):
+    def test_build_reply_renders_template_vars(self):
+        built = et.build_reply({}, relationship={},
+                               state_ctx={"state_block": "{% if trust > 0.5 %}亲近{% else %}疏远{% endif %}"},
+                               tone="", guard="", opts={"template_vars": {"trust": 0.8}})
+        self.assertIn("亲近", built["user"])
+        self.assertNotIn("{%", built["user"])
+
+    def test_bulit_reply_without_vars_keeps_text(self):
+        built = et.build_reply({}, relationship={}, state_ctx={"state_block": "情绪：平静"},
+                               tone="", guard="", opts={})
+        self.assertIn("情绪：平静", built["user"])
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_text_inference.py

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+"""item-5: lexical inference is disabled; the probe owns semantics."""
+import unittest
+
+import interpretation as it
+
+
+class DisabledInferenceTest(unittest.TestCase):
+    def test_flag_is_off_by_default(self):
+        self.assertIs(it.TEXT_INFERENCE_ENABLED, False)
+        self.assertIs(it.USER_CLASSIFY_ENABLED, False)
+
+    def test_negative_text_is_neutral(self):
+        out = it.infer_from_text("我今天特别难受，别烦我")
+        self.assertEqual(out["emotion"], "neutral")
+        self.assertEqual(out["confidence"], 0.0)
+
+    def test_positive_text_is_neutral(self):
+        self.assertEqual(it.infer_from_text("今天特别开心！")["emotion"],
+                         "neutral")
+
+    def test_no_lexical_tables_remain(self):
+        for name in ("_INFER_WORDS", "_INFER_EMOJI", "_SARCASM_MARKERS",
+                     "_USER_WORDS", "_NEGATION_PREFIX_WORDS", "_negated"):
+            self.assertFalse(hasattr(it, name), name)
+
+    def test_parse_response_does_not_infer(self):
+        for text in ("我今天特别难受，别烦我", "今天特别开心！", "你可真行啊",
+                     "最近压力好大，晚上总睡不着。"):
+            visible, update = it.parse_response(text)
+            self.assertIsNone(update, text)
+            self.assertEqual(visible, text)
+
+    def test_empty_input_is_safe(self):
+        self.assertEqual(it.infer_from_text("")["emotion"], "neutral")
+        self.assertIsNone(it.parse_response("")[1])
+
+    def test_ranges_are_bounded(self):
+        for text in ("开心", "难受", "压力大", "在吗", ""):
+            out = it.infer_from_text(text)
+            self.assertGreaterEqual(out["intensity"], 0.0)
+            self.assertLessEqual(out["intensity"], 1.0)
+            self.assertGreaterEqual(out["confidence"], 0.0)
+            self.assertLessEqual(out["confidence"], 1.0)
+
+    def test_classify_is_neutral_noop(self):
+        out = it.classify_user_msg("你真废物，闭嘴")
+        self.assertEqual(out["kind"], "neutral")
+        self.assertLess(out["confidence"], 0.4)
+
+
+class ParseContractTest(unittest.TestCase):
+    def test_tag_path_still_works(self):
+        visible, update = it.parse_response(
+            '<bc>{"e":"joy","i":0.4}</bc> 我今天特别难受')
+        self.assertNotIn("<bc>", visible)
+        self.assertEqual(update["emotion"], "joy")
+        self.assertNotEqual(update.get("source"), "inferred")
+
+    def test_invalid_tag_does_not_fall_back(self):
+        _visible, update = it.parse_response("嗯。<bc>not json</bc>")
+        self.assertIsNone(update)
+
+    def test_update_shape_unchanged_for_tag_path(self):
+        _visible, update = it.parse_response('<bc>{"e":"anger","i":0.6}</bc>')
+        self.assertIn("valence_delta", update)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_theta_params.py

@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+"""Persona theta overwrite tests: save path and startup write."""
+import ast
+import tempfile
+import types
+import unittest
+from pathlib import Path
+
+from biocore_model import ui_settings
+
+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 = ("_apply_autonomy_params", "_write_autonomy_theta_once")
+    ns = {}
+    fns = {}
+    for node in cls.body:
+        if isinstance(node, ast.FunctionDef) and node.name in wanted:
+            clone = ast.FunctionDef(name=node.name, args=node.args, body=node.body,
+                                    decorator_list=[], returns=node.returns,
+                                    type_comment=None, lineno=node.lineno,
+                                    col_offset=node.col_offset,
+                                    end_lineno=node.end_lineno,
+                                    end_col_offset=node.end_col_offset)
+            exec(compile(ast.Module(body=[clone], type_ignores=[]), "<theta>", "exec"),
+                 ns)
+            fns[node.name] = ns[node.name]
+    return fns
+
+
+FNS = _load_methods()
+
+
+class FakePlugin:
+    def __init__(self, data_dir):
+        self.data_dir = str(data_dir)
+        self.autonomy_params = {"theta": 0.5239, "cooldown_s": 1625,
+                                "daily_cap": 3}
+        self._autonomy_theta_written = False
+        self._apply_autonomy_params = types.MethodType(
+            FNS["_apply_autonomy_params"], self)
+        self._write_autonomy_theta_once = types.MethodType(
+            FNS["_write_autonomy_theta_once"], self)
+
+    def _autonomy_params(self):
+        return dict(self.autonomy_params)
+
+
+class ParamsMergeTest(unittest.TestCase):
+    def test_theta_overwrites_stale_value(self):
+        plugin = FakePlugin(tempfile.gettempdir())
+        out = plugin._apply_autonomy_params({"theta": 0.55}, {"theta": 0.5239})
+        self.assertAlmostEqual(out["theta"], 0.5239, places=4)
+
+    def test_cooldown_and_cap_always_forced(self):
+        plugin = FakePlugin(tempfile.gettempdir())
+        out = plugin._apply_autonomy_params(
+            {"theta": 0.55, "cooldown_seconds": 1800, "daily_cap": 5, "V": 0.1},
+            {"theta": 0.52, "cooldown_s": 1625, "daily_cap": 3})
+        self.assertEqual(out["cooldown_seconds"], 1625)
+        self.assertEqual(out["daily_cap"], 3)
+        self.assertEqual(out["V"], 0.1)
+        lean = plugin._apply_autonomy_params({"theta": 0.55}, {"theta": 0.52})
+        self.assertEqual(lean["cooldown_seconds"], 1800)
+        self.assertEqual(lean["daily_cap"], 5)
+
+    def test_params_unavailable_keeps_old_theta(self):
+        plugin = FakePlugin(tempfile.gettempdir())
+        out = plugin._apply_autonomy_params({"theta": 0.55}, {})
+        self.assertAlmostEqual(out["theta"], 0.55, places=4)
+
+
+class StartupWriteTest(unittest.TestCase):
+    def test_startup_write_once(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            plugin = FakePlugin(tmp)
+            ui_settings.save(plugin, {"autonomy": {"accumulator": {
+                "theta": 0.55, "V": 0.15, "cooldown_seconds": 1800,
+                "daily_cap": 5}}})
+            plugin._write_autonomy_theta_once()
+            saved = ((ui_settings.load(plugin).get("autonomy") or {})
+                     .get("accumulator") or {})
+            self.assertAlmostEqual(saved["theta"], 0.5239, places=4)
+            self.assertEqual(saved["cooldown_seconds"], 1625)
+            self.assertEqual(saved["daily_cap"], 3)
+            self.assertEqual(saved["V"], 0.15)
+            # Second call is a no-op (startup write once).
+            plugin.autonomy_params = {"theta": 0.9, "cooldown_s": 9999,
+                                      "daily_cap": 8}
+            plugin._write_autonomy_theta_once()
+            again = ((ui_settings.load(plugin).get("autonomy") or {})
+                     .get("accumulator") or {})
+            self.assertAlmostEqual(again["theta"], 0.5239, places=4)
+
+    def test_save_path_overwrites_after_one_tick(self):
+        plugin = FakePlugin(tempfile.gettempdir())
+        payload = {"theta": 0.55, "V": 0.1}
+        out = plugin._apply_autonomy_params(payload, plugin._autonomy_params())
+        self.assertAlmostEqual(out["theta"], 0.5239, places=4)
+
+
+class WiringStaticTest(unittest.TestCase):
+    def test_log_has_theta_and_save_uses_params(self):
+        self.assertIn("autonomy tick engine=module V=%.3f theta=%.3f", SOURCE)
+        self.assertIn("self._apply_autonomy_params(payload, params)", SOURCE)
+        self.assertIn("_write_autonomy_theta_once()", SOURCE)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_topic_control.py

@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+"""task-181 话题主导权单测：让出/接住/另起/收尾、主导度、关闭、畸形输入。
+
+只依赖 biocore_model.topic_control 的纯函数；不导入 main.py。
+"""
+import unittest
+
+from biocore_model import topic_control as tc
+
+CATCH_TURNS = [{"by": "you", "kind": "initiate"},
+               {"by": "me", "kind": "keep"}]
+YIELD_TURNS = [{"by": "me", "kind": "initiate"},
+               {"by": "me", "kind": "switch"},
+               {"by": "me", "kind": "keep"}]
+STALE_TURNS = [{"by": "you", "kind": "keep"},
+               {"by": "me", "kind": "keep"},
+               {"by": "you", "kind": "keep"},
+               {"by": "me", "kind": "keep"}]
+CLOSE_TURNS = [{"by": "you", "kind": "initiate"},
+               {"by": "you", "kind": "close"}]
+
+
+class ContractTest(unittest.TestCase):
+    def test_result_keys(self):
+        out = tc.topic_control(CATCH_TURNS)
+        for key in ("enabled", "holder", "dominance", "tendency", "reason",
+                    "counts", "window", "last_by", "scores"):
+            self.assertIn(key, out)
+
+    def test_constants(self):
+        self.assertEqual(tc.HOLDERS, ("me", "you", "shared"))
+        self.assertEqual(tc.TENDENCIES, ("让出", "接住", "另起", "收尾"))
+        self.assertEqual(tc.KINDS, ("initiate", "switch", "close", "keep"))
+        self.assertEqual(set(tc.REASONS), set(tc.TENDENCIES))
+
+    def test_values_bounded(self):
+        for turns in (CATCH_TURNS, YIELD_TURNS, STALE_TURNS, CLOSE_TURNS, []):
+            out = tc.topic_control(turns)
+            self.assertGreaterEqual(out["dominance"], 0.0)
+            self.assertLessEqual(out["dominance"], 1.0)
+            self.assertIn(out["holder"], tc.HOLDERS)
+            self.assertIn(out["tendency"], tc.TENDENCIES)
+            for value in out["scores"].values():
+                self.assertGreaterEqual(value, 0.0)
+                self.assertLessEqual(value, 1.0)
+
+
+class TendencyTest(unittest.TestCase):
+    def test_catch_your_topic(self):
+        out = tc.topic_control(CATCH_TURNS, state={"energy": 0.6},
+                               relationship={"closeness": 0.6})
+        self.assertEqual(out["tendency"], "接住")
+        self.assertEqual(out["holder"], "you")
+
+    def test_yield_when_she_has_been_steering(self):
+        out = tc.topic_control(YIELD_TURNS, state={"energy": 0.3},
+                               relationship={"closeness": 0.7})
+        self.assertEqual(out["tendency"], "让出")
+        self.assertEqual(out["holder"], "me")
+
+    def test_start_when_topic_is_stale(self):
+        out = tc.topic_control(STALE_TURNS, state={"energy": 0.8},
+                               relationship={"closeness": 0.3})
+        self.assertEqual(out["tendency"], "另起")
+        self.assertTrue(tc.metrics(STALE_TURNS)["stale"])
+
+    def test_close_when_topic_is_wrapping_up(self):
+        out = tc.topic_control(CLOSE_TURNS, state={"energy": 0.3},
+                               relationship={"conflict": 0.2}, hour=23)
+        self.assertEqual(out["tendency"], "收尾")
+        self.assertTrue(tc.metrics(CLOSE_TURNS)["closing"])
+
+    def test_closing_flag_forces_close(self):
+        out = tc.topic_control([{"by": "you", "kind": "keep"}],
+                               state={"energy": 0.2},
+                               flags={"closing": True})
+        self.assertEqual(out["tendency"], "收尾")
+
+    def test_empty_history_defaults_to_catch(self):
+        out = tc.topic_control([])
+        self.assertEqual(out["tendency"], "接住")
+        self.assertEqual(out["holder"], "shared")
+        self.assertEqual(out["dominance"], 0.5)
+
+
+class HolderTest(unittest.TestCase):
+    def test_holder_me(self):
+        out = tc.topic_control([{"by": "me", "kind": "initiate"}])
+        self.assertEqual(out["holder"], "me")
+        self.assertEqual(out["dominance"], 1.0)
+
+    def test_holder_you(self):
+        out = tc.topic_control([{"by": "you", "kind": "switch"}])
+        self.assertEqual(out["holder"], "you")
+        self.assertEqual(out["dominance"], 0.0)
+
+    def test_holder_shared(self):
+        out = tc.topic_control([{"by": "me", "kind": "initiate"},
+                                {"by": "you", "kind": "initiate"}])
+        self.assertEqual(out["holder"], "shared")
+
+    def test_recency_weights(self):
+        turns = [{"by": "you", "kind": "initiate"},
+                 {"by": "me", "kind": "switch"}]
+        row = tc.metrics(turns)
+        self.assertGreater(row["dominance"], 0.5)
+        self.assertLess(row["dominance"], 1.0)
+        self.assertGreater(row["my_control"], 0.0)
+        self.assertGreater(row["your_control"], 0.0)
+
+    def test_window_limits_history(self):
+        turns = [{"by": "me", "kind": "initiate"},
+                 {"by": "me", "kind": "initiate"},
+                 {"by": "me", "kind": "initiate"},
+                 {"by": "you", "kind": "initiate"}]
+        wide = tc.metrics(turns, window=4)
+        narrow = tc.metrics(turns, window=2)
+        self.assertEqual(narrow["count"], 2)
+        self.assertEqual(narrow["holder"], "shared")
+        self.assertEqual(wide["holder"], "me")
+
+    def test_counts_consistent(self):
+        out = tc.topic_control(YIELD_TURNS)
+        counts = out["counts"]
+        self.assertGreaterEqual(counts["my_control"], 0.0)
+        self.assertGreaterEqual(counts["your_control"], 0.0)
+        self.assertGreaterEqual(counts["engaged"], 0.0)
+        self.assertLessEqual(counts["engaged"], 1.0)
+
+
+class EnergyTest(unittest.TestCase):
+    def test_energy_raises_start_score(self):
+        low = tc.topic_control(STALE_TURNS, state={"energy": 0.0})
+        high = tc.topic_control(STALE_TURNS, state={"energy": 1.0})
+        self.assertGreater(high["scores"]["另起"], low["scores"]["另起"])
+
+    def test_low_energy_raises_close_score(self):
+        low = tc.topic_control(CLOSE_TURNS, state={"energy": 0.1})
+        high = tc.topic_control(CLOSE_TURNS, state={"energy": 0.9})
+        self.assertGreater(low["scores"]["收尾"], high["scores"]["收尾"])
+
+    def test_low_energy_with_closing_stops_keeping_topic(self):
+        out = tc.topic_control(YIELD_TURNS, state={"energy": 0.1},
+                               flags={"closing": True})
+        self.assertIn(out["tendency"], ("让出", "收尾"))
+
+
+class SwitchTest(unittest.TestCase):
+    def test_disabled_is_neutral(self):
+        out = tc.topic_control(CATCH_TURNS, flags={"enabled": False})
+        self.assertFalse(out["enabled"])
+        self.assertEqual(out["holder"], "shared")
+        self.assertEqual(out["dominance"], 0.5)
+        self.assertEqual(out["tendency"], "接住")
+        self.assertIn("关闭", out["reason"])
+
+    def test_directives_mapping(self):
+        out = tc.directives(tc.topic_control(YIELD_TURNS))
+        self.assertEqual(out["tendency"], "让出")
+        self.assertEqual(out["holder"], "me")
+        self.assertLessEqual(out["initiative"], 0.2)
+        self.assertTrue(out["tone"])
+        neutral = tc.directives(tc.topic_control(flags={"enabled": False}))
+        self.assertEqual(neutral["tendency"], "接住")
+        self.assertEqual(neutral["tone"], "")
+
+
+class RobustnessTest(unittest.TestCase):
+    def test_odd_inputs(self):
+        for turns in (None, "x", 3, [], [{"by": "what", "kind": "??"}],
+                      ["bad"], "me:initiate", {"turns": CATCH_TURNS}):
+            out = tc.topic_control(turns)
+            self.assertIn(out["tendency"], tc.TENDENCIES)
+            self.assertIn(out["holder"], tc.HOLDERS)
+            self.assertTrue(out["reason"])
+
+    def test_string_turns_are_parsed(self):
+        row = tc.metrics(["me:initiate", "me:switch"])
+        self.assertEqual(row["holder"], "me")
+        self.assertEqual(row["dominance"], 1.0)
+
+    def test_aliases(self):
+        row = tc.metrics([{"by": "her", "kind": "new"},
+                          {"by": "user", "kind": "change"}])
+        self.assertGreater(row["my_control"], 0.0)
+        self.assertGreater(row["your_control"], 0.0)
+
+    def test_deterministic(self):
+        first = tc.topic_control(YIELD_TURNS, state={"energy": 0.3})
+        second = tc.topic_control(YIELD_TURNS, state={"energy": 0.3})
+        self.assertEqual(first, second)
+
+    def test_bad_hour_and_state(self):
+        out = tc.topic_control(CATCH_TURNS, state="x", relationship="y",
+                               hour="zzz")
+        self.assertIn(out["tendency"], tc.TENDENCIES)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_turn_memory.py

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+import unittest
+
+from biocore_model import turn_memory as tm
+
+
+def _trace_row(rank, eid, text, score=0.6, source="direct", **extra):
+    row = {"entry_id": eid, "rank": rank, "score": score, "source": source,
+           "text": text, "cosine": 0.55, "importance": 0.5,
+           "components": {"lexical": 0.5, "recency": 0.3}}
+    row.update(extra)
+    return row
+
+
+class TurnMemoryTest(unittest.TestCase):
+    def test_build_gives_four_rows_with_source_and_score(self):
+        trace = [_trace_row(i, "id%d" % i, "记忆 %d" % i, score=0.5 + i * 0.05)
+                 for i in range(1, 6)]
+        rows = tm.build(trace)
+        self.assertEqual(len(rows), 4)
+        for row in rows:
+            self.assertEqual(row["source"], "direct")
+            self.assertGreater(row["score"], 0)
+            self.assertTrue(row["reason"])
+        self.assertEqual([row["rank"] for row in rows], [1, 2, 3, 4])
+
+    def test_build_limit_is_clamped(self):
+        trace = [_trace_row(i, "id%d" % i, "记忆 %d" % i) for i in range(1, 9)]
+        self.assertEqual(len(tm.build(trace, limit=2)), 2)
+        self.assertEqual(tm.build(trace, limit=0), [])
+        self.assertEqual(len(tm.build(trace, limit=99)), tm.HARD_ROWS)
+        self.assertEqual(len(tm.build(trace)), tm.MAX_ROWS)
+
+    def test_reason_uses_top_two_components(self):
+        reason = tm.reason_text({"lexical": 0.58, "recency": 0.22,
+                                 "retention": 0.10})
+        self.assertIn("关键词 0.58", reason)
+        self.assertIn("近期 0.22", reason)
+        self.assertNotIn("留存", reason)
+
+    def test_reason_falls_back_to_similarity_and_importance(self):
+        reason = tm.reason_text(None, cosine=0.61, importance=0.5)
+        self.assertIn("相似度 0.61", reason)
+        self.assertIn("重要度 0.50", reason)
+
+    def test_reason_defaults_to_rule_score(self):
+        self.assertEqual(tm.reason_text(), "规则打分")
+
+    def test_build_skips_unusable_rows(self):
+        rows = tm.build([None, {}, {"entry_id": ""}, "x",
+                         {"entry_id": "e1", "text": "保留", "score": 0.7}])
+        self.assertEqual(len(rows), 1)
+        self.assertEqual(rows[0]["text"], "保留")
+        self.assertEqual(rows[0]["source"], "unknown")
+        self.assertEqual(rows[0]["rank"], 1)
+
+    def test_build_record_fields(self):
+        rows = tm.build([_trace_row(1, "e1", "记忆")])
+        record = tm.build_record(rows, reply="回" * 300, ts=1700000000)
+        self.assertEqual(record["count"], 1)
+        self.assertEqual(record["ts"], 1700000000.0)
+        self.assertLessEqual(len(record["reply"]), 121)
+        self.assertIn("…", record["reply"])
+
+    def test_render_receipt_lists_rows(self):
+        trace = [_trace_row(i, "e%d" % i, "记忆内容 %d" % i)
+                 for i in range(1, 5)]
+        record = tm.build_record(tm.build(trace), ts=1700000000)
+        text = tm.render_receipt(record)
+        lines = text.splitlines()
+        self.assertEqual(lines[0], "本轮记忆：用了 4 条")
+        self.assertEqual(len(lines), 5)
+        for line in lines[1:]:
+            self.assertIn("[direct]", line)
+            self.assertIn("score", line)
+            self.assertIn("原因：关键词", line)
+
+    def test_render_receipt_empty(self):
+        self.assertIn("暂无", tm.render_receipt(None))
+        self.assertIn("暂无", tm.render_receipt({"rows": []}))
+
+    def test_merge_history_is_bounded_newest_first(self):
+        old = [{"ts": 1, "rows": []}, {"ts": 2, "rows": []}]
+        new = {"ts": 3, "rows": []}
+        merged = tm.merge_history(old, new)
+        self.assertEqual([item["ts"] for item in merged], [3, 1, 2])
+        long = [{"ts": i} for i in range(6)]
+        self.assertEqual(len(tm.merge_history(long, {"ts": 9})),
+                         tm.HISTORY_LIMIT)
+        self.assertIsInstance(tm.merge_history(None, {"ts": 9}), list)
+        self.assertEqual(len(tm.merge_history(None, {"ts": 9})), 1)
+        self.assertEqual(tm.merge_history(old, None), old)
+
+    def test_text_trim_and_receipt_budget(self):
+        rows = tm.build([{"entry_id": "e1", "text": "长" * 300,
+                          "score": 0.5, "components": {}}])
+        self.assertLessEqual(len(rows[0]["text"]), tm.MAX_TEXT + 1)
+        self.assertTrue(rows[0]["text"].endswith("…"))
+        record = tm.build_record(rows)
+        self.assertLessEqual(len(tm.render_receipt(record)),
+                             tm.RECEIPT_MAX_CHARS)
+
+
+if __name__ == "__main__":
+    unittest.main()