dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_needs_esteem.py

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import needs_esteem as ne
+
+class NeedsTest(unittest.TestCase):
+    def test_defaults(self):
+        self.assertEqual(ne.defaults()['belonging'], 0.6)
+    def test_silence_belonging(self):
+        self.assertAlmostEqual(ne.silence_effects(10)['belonging'], -0.2)
+    def test_belonging_cap(self):
+        self.assertAlmostEqual(ne.silence_effects(100)['belonging'], -0.4)
+    def test_meaning_after_48h(self):
+        self.assertEqual(ne.silence_effects(24)['meaningful_existence'], 0.0)
+        self.assertLess(ne.silence_effects(60)['meaningful_existence'], 0.0)
+    def test_control_when_stalled(self):
+        self.assertLess(ne.silence_effects(10, phases_stalled=True)['control'], 0.0)
+    def test_responded_repairs_all(self):
+        needs = ne.on_responded(ne.defaults())
+        for key in ne.NEED_KEYS:
+            self.assertGreater(needs[key], 0.6)
+    def test_ignored_lowers_esteem(self):
+        self.assertLess(ne.on_ignored(ne.defaults())['self_esteem'], 0.6)
+    def test_rejected_bigger_drop(self):
+        self.assertLess(ne.on_ignored(ne.defaults(), rejected=True)['self_esteem'], ne.on_ignored(ne.defaults())['self_esteem'])
+    def test_praised_raises_esteem(self):
+        self.assertGreater(ne.on_praised(ne.defaults())['self_esteem'], 0.6)
+    def test_dominant(self):
+        needs = ne.defaults(); needs['meaningful_existence'] = 0.2
+        self.assertEqual(ne.dominant(needs), 'meaningful_existence')
+    def test_dominant_empty_when_full(self):
+        needs = {key: 0.9 for key in ne.NEED_KEYS}
+        self.assertEqual(ne.dominant(needs), '')
+    def test_four_behaviours_differ(self):
+        tones = set()
+        for key in ne.NEED_KEYS:
+            needs = ne.defaults(); needs[key] = 0.2
+            b = ne.behaviour(needs); tones.add(b['tone'])
+        self.assertEqual(len(tones), 4)
+    def test_self_esteem_regress(self):
+        self.assertGreater(ne.self_esteem_update(0.2), 0.2)
+        self.assertLess(ne.self_esteem_update(0.9), 0.9)
+    def test_esteem_respond_boost(self):
+        self.assertGreater(ne.self_esteem_update(0.5, responded=True), 0.5)
+    def test_confidence_lower_with_low_esteem(self):
+        self.assertLess(ne.confidence_from_esteem(0.2), ne.confidence_from_esteem(0.55))
+    def test_clamp(self):
+        self.assertLessEqual(ne.self_esteem_update(1.0, praised=True), 1.0)
+        self.assertGreaterEqual(ne.self_esteem_update(0.0, ignored=True), 0.0)
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_needs_events.py

@@ -0,0 +1,205 @@
+# -*- coding: utf-8 -*-
+"""P1-3 need-event hook tests (needs_events.py + main wiring)."""
+import ast
+import json
+import types
+import unittest
+from pathlib import Path
+
+from biocore_model import needs_events as ne
+
+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"))
+
+
+def _load_helper():
+    tree = ast.parse(SOURCE)
+    node = next(item for item in tree.body
+                if isinstance(item, ast.FunctionDef)
+                and item.name == "_apply_needs_events")
+    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)
+    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=[clone], type_ignores=[]),
+                 "<_apply_needs_events>", "exec"), ns)
+    return ns[node.name], log
+
+
+HELPER, LOG = _load_helper()
+
+
+class FakeCore:
+    def __init__(self, needs=None):
+        self.needs = dict(needs or ne.DEFAULT_NEEDS)
+
+
+class FakePlugin:
+    def __init__(self, enabled=True):
+        self.needs_events_enabled = enabled
+
+
+class NeedsStateTest(unittest.TestCase):
+    def test_defaults_and_clamps(self):
+        state = ne.needs_state({"belonging": 5, "control": -2})
+        self.assertEqual(state["belonging"], 1.0)
+        self.assertEqual(state["control"], 0.0)
+        self.assertEqual(state["self_esteem"], ne.BASELINE)
+        self.assertEqual(ne.needs_state(None), ne.DEFAULT_NEEDS)
+
+
+class EventEffectTest(unittest.TestCase):
+    def _apply(self, kind, strength=1.0, needs=None):
+        needed = dict(needs or ne.DEFAULT_NEEDS)
+        return ne.apply(needed, [{"kind": kind, "strength": strength}])
+
+    def test_praised_raises_self_esteem(self):
+        after, report = self._apply("praised")
+        self.assertGreater(after["self_esteem"], ne.BASELINE)
+        self.assertGreater(after["belonging"], ne.BASELINE)
+        self.assertGreater(report["deltas"]["self_esteem"], 0)
+
+    def test_rejected_lowers_belonging_and_esteem(self):
+        after, report = self._apply("rejected")
+        self.assertLess(after["belonging"], ne.BASELINE)
+        self.assertLess(after["self_esteem"], ne.BASELINE)
+        self.assertLess(report["deltas"]["belonging"], 0)
+
+    def test_ignored_lowers_belonging_and_meaning(self):
+        after, _report = self._apply("ignored")
+        self.assertLess(after["belonging"], ne.BASELINE)
+        self.assertLess(after["meaningful_existence"], ne.BASELINE)
+
+    def test_single_event_is_capped(self):
+        after, report = self._apply("rejected", strength=1.0)
+        self.assertEqual(report["deltas"]["belonging"], -ne.CAPS["belonging"])
+        after2, report2 = ne.apply(ne.DEFAULT_NEEDS,
+                                   [{"kind": "rejected", "strength": 1.0}] * 5)
+        self.assertEqual(report2["deltas"]["belonging"], -ne.CAPS["belonging"])
+        self.assertGreaterEqual(after2["belonging"], 0.0)
+
+    def test_needs_stay_in_range(self):
+        low = {key: 0.01 for key in ne.NEED_KEYS}
+        after, _report = ne.apply(low, [{"kind": "abandoned",
+                                         "strength": 1.0}] * 4)
+        self.assertTrue(all(0.0 <= value <= 1.0 for value in after.values()))
+        self.assertEqual(after["belonging"], 0.0)
+
+    def test_zero_strength_is_noop(self):
+        after, report = ne.apply(ne.DEFAULT_NEEDS,
+                                 [{"kind": "praised", "strength": 0.0}])
+        self.assertEqual(after, ne.DEFAULT_NEEDS)
+        self.assertEqual(report["events"], [])
+        str_after, _ = ne.apply(ne.DEFAULT_NEEDS,
+                                [{"kind": "praised", "strength": 0}])
+        self.assertEqual(str_after, ne.DEFAULT_NEEDS)
+
+    def test_apply_does_not_mutate_input(self):
+        source = dict(ne.DEFAULT_NEEDS)
+        before = dict(source)
+        ne.apply(source, [{"kind": "praised", "strength": 1.0}])
+        self.assertEqual(source, before)
+
+    def test_scale_factor(self):
+        _after, full = ne.apply(ne.DEFAULT_NEEDS, [{"kind": "praised"}])
+        _after2, half = ne.apply(ne.DEFAULT_NEEDS, [{"kind": "praised"}],
+                                 scale=0.5)
+        self.assertAlmostEqual(half["deltas"]["self_esteem"],
+                               full["deltas"]["self_esteem"] / 2.0)
+
+    def test_invalid_events_are_safe(self):
+        after, report = ne.apply(None, "nope")
+        self.assertEqual(after, ne.DEFAULT_NEEDS)
+        self.assertEqual(report["events"], [])
+        after2, _ = ne.apply(ne.DEFAULT_NEEDS, [{"kind": "unknown"}])
+        self.assertEqual(after2, ne.DEFAULT_NEEDS)
+
+
+class DimsEventsTest(unittest.TestCase):
+    def test_positive_dims(self):
+        kinds = {event["kind"]
+                 for event in ne.events_from_dims({"goal": 0.8, "involve": 0.7})}
+        self.assertIn("achieved", kinds)
+        self.assertIn("connected", kinds)
+
+    def test_negative_dims(self):
+        kinds = {event["kind"]
+                 for event in ne.events_from_dims({"hit": 0.9, "blame": 0.6})}
+        self.assertIn("rejected", kinds)
+
+    def test_neutral_dims_no_events(self):
+        self.assertEqual(ne.events_from_dims({"goal": 0.0, "hit": 0.0,
+                                              "involve": 0.1}), [])
+        self.assertEqual(ne.events_from_dims(None), [])
+
+
+class BehaviorChainTest(unittest.TestCase):
+    def test_deficit_biases_contact_and_clarify(self):
+        low = dict(ne.DEFAULT_NEEDS, belonging=0.2, control=0.25)
+        bias = ne.behavior_bias(low)
+        self.assertGreaterEqual(bias["seek_contact"], 0.6)
+        self.assertGreater(bias["ask_clarify"], 0.0)
+
+    def test_surplus_biases_sharing(self):
+        high = dict(ne.DEFAULT_NEEDS, meaningful_existence=0.95,
+                    self_esteem=0.9)
+        bias = ne.behavior_bias(high)
+        self.assertGreater(bias["share_meaning"], 0.0)
+        self.assertGreater(bias["self_assert"], 0.0)
+
+    def test_event_to_needs_to_behavior_chain(self):
+        before = ne.behavior_bias(ne.DEFAULT_NEEDS)
+        dims = {"hit": 0.9, "blame": 0.7, "involve": 0.0}
+        events = ne.events_from_dims(dims)
+        after_needs, report = ne.apply(ne.DEFAULT_NEEDS, events)
+        after = ne.behavior_bias(after_needs)
+        self.assertGreater(after["seek_contact"], before["seek_contact"])
+        self.assertLess(after_needs["belonging"],
+                        ne.DEFAULT_NEEDS["belonging"])
+        self.assertTrue(report["deltas"]["belonging"] < 0)
+
+
+class WiringTest(unittest.TestCase):
+    def test_main_markers(self):
+        self.assertIn("def _apply_needs_events(plugin, core, dims)", SOURCE)
+        self.assertIn("_apply_needs_events(self, core, _inline.get(\"dims\"))",
+                      SOURCE)
+        self.assertIn("needs_events as _needs_mod", SOURCE)
+        self.assertIn("needs_behavior", SOURCE)
+        self.assertIn("[biocore] needs events=", SOURCE)
+
+    def test_schema_default_on(self):
+        self.assertIn("needs_events_enabled", SCHEMA)
+        self.assertTrue(SCHEMA["needs_events_enabled"]["default"])
+
+    def test_helper_writes_needs_and_bias(self):
+        plugin = FakePlugin()
+        core = FakeCore()
+        LOG.clear()
+        report = HELPER(plugin, core, {"hit": 0.9, "blame": 0.7})
+        self.assertLess(core.needs["belonging"], ne.BASELINE)
+        self.assertIn("seek_contact", core.needs_behavior)
+        self.assertTrue(report["events"])
+        self.assertTrue(any("needs events" in str(row) for row in LOG))
+
+    def test_helper_disabled_and_neutral_are_noops(self):
+        core = FakeCore()
+        before = dict(core.needs)
+        HELPER(FakePlugin(enabled=False), core, {"hit": 0.9})
+        self.assertEqual(core.needs, before)
+        HELPER(FakePlugin(), core, {"hit": 0.0})
+        self.assertEqual(core.needs, before)
+        self.assertFalse(hasattr(core, "needs_behavior"))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_needs_sleep.py

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import needs_sleep as ns, needs_esteem as ne
+
+NOW = 1_700_000_000
+
+class NeedsSleepTest(unittest.TestCase):
+    def test_four_needs_include_control_meaning(self):
+        data = ns.defaults(NOW)
+        for key in ('belonging', 'self_esteem', 'control', 'meaningful_existence'):
+            self.assertIn(key, data)
+    def test_control_drops_when_stalled(self):
+        data = ns.need_step(ns.defaults(NOW), {'silence_hours': 10, 'stalled': True}, dt=10, now=NOW + 1)
+        self.assertLess(data['control'], 0.6)
+    def test_meaning_drops_after_48h(self):
+        long_silence = ns.need_step(ns.defaults(NOW), {'silence_hours': 60}, dt=10, now=NOW + 1)
+        short = ns.need_step(ns.defaults(NOW), {'silence_hours': 24}, dt=10, now=NOW + 1)
+        self.assertLess(long_silence['meaningful_existence'], short['meaningful_existence'])
+    def test_responded_repairs_all(self):
+        data = ns.need_step(ns.defaults(NOW), {'responded': True}, dt=0, now=NOW + 1)
+        for key in ns.NEED_KEYS: self.assertGreater(data[key], 0.6)
+    def test_idempotent_same_now(self):
+        first = ns.need_step(ns.defaults(NOW), {'silence_hours': 10}, dt=10, now=NOW)
+        second = ns.need_step(first, {'silence_hours': 10}, dt=10, now=NOW)
+        self.assertEqual(first['belonging'], second['belonging'])
+    def test_sleep_debt_accumulates(self):
+        data = ns.sleep_debt_step(0.0, slept_hours=0, dt=8, now=NOW)
+        self.assertGreater(data['debt'], 0)
+    def test_sleep_repays(self):
+        data = ns.sleep_debt_step(4.0, slept_hours=6, dt=6, now=NOW)
+        self.assertLess(data['debt'], 4.0)
+    def test_sleep_debt_idempotent(self):
+        first = ns.sleep_debt_step(2.0, 0, 8, NOW)
+        second = ns.sleep_debt_step(first['debt'], 0, 8, NOW, state={'last_debt_ts': NOW})
+        self.assertAlmostEqual(second['debt'], first['debt'])
+    def test_energy_and_irritability(self):
+        self.assertGreater(ns.energy_penalty(12), 0); self.assertGreater(ns.irritability(12), 0)
+    def test_view_fields(self):
+        view = ns.view(ns.defaults(NOW), 5)
+        for key in ('needs', 'dominant', 'sleep_debt', 'energy_penalty', 'irritability'): self.assertIn(key, view)
+    def test_needs_esteem_delegates_apply_silence(self):
+        old = ne.apply_silence(ne.defaults(), 10)
+        new = ns.need_step(ns.defaults(NOW), {'silence_hours': 10}, dt=0, now=NOW + 1)
+        self.assertAlmostEqual(old['belonging'], new['belonging'], places=3)
+    def test_needs_esteem_delegates_responded(self):
+        old = ne.on_responded(ne.defaults())
+        self.assertGreater(old['control'], 0.6)
+    def test_needs_esteem_delegates_ignored(self):
+        old = ne.on_ignored(ne.defaults(), rejected=True)
+        new = ns.need_step(ns.defaults(NOW), {'ignored': True}, dt=0, now=NOW + 1)
+        self.assertAlmostEqual(old['self_esteem'], new['self_esteem'], places=3)
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_noise_bank.py

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+"""HUMAN-2 noise bank tests: reproducibility, channels, bursts."""
+import unittest
+
+from biocore_model import noise_bank as nb
+
+
+class DeterminismTest(unittest.TestCase):
+    def test_same_seed_tick_reproducible(self):
+        self.assertEqual(nb.value(11, 7, "chat"), nb.value(11, 7, "chat"))
+
+    def test_different_seed_differs(self):
+        self.assertNotEqual(nb.value(11, 7), nb.value(12, 7))
+
+    def test_sample_window_shape(self):
+        rows = nb.sample_window(3, 10, count=5, name="chat")
+        self.assertEqual(len(rows), 5)
+        self.assertEqual(rows, nb.sample_window(3, 10, count=5, name="chat"))
+
+
+class ChannelTest(unittest.TestCase):
+    def test_channel_noise_differs(self):
+        self.assertNotEqual(nb.channel(5, 9, "chat"), nb.channel(5, 9, "voice"))
+
+    def test_common_is_shared_and_bounded(self):
+        value = nb.common(5, 9)
+        self.assertLessEqual(abs(value), nb.CLAMP)
+        self.assertEqual(value, nb.common(5, 9))
+
+    def test_value_clamped(self):
+        for tick in range(200):
+            self.assertLessEqual(abs(nb.value(7, tick, "chat")["value"]), nb.CLAMP)
+
+
+class BurstTest(unittest.TestCase):
+    def test_burst_reproducible(self):
+        self.assertEqual(nb.burst(9, 4), nb.burst(9, 4))
+
+    def test_burst_disabled_or_forced(self):
+        self.assertFalse(nb.burst(9, 4, p=0.0)["hit"])
+        self.assertTrue(nb.burst(9, 4, p=1.0)["hit"])
+
+    def test_burst_rare(self):
+        hits = sum(1 for tick in range(500) if nb.burst(3, tick)["hit"])
+        self.assertLessEqual(hits, 60)
+
+    def test_burst_value_bounds(self):
+        row = nb.burst(3, 0, p=1.0)
+        self.assertLessEqual(abs(row["value"]), nb.CLAMP)
+        self.assertGreaterEqual(row["magnitude"], 0.0)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_numeric_schema.py

@@ -0,0 +1,98 @@
+# -*- coding: utf-8 -*-
+"""Numeric schema + legend injection tests."""
+import types
+import unittest
+from pathlib import Path
+
+from biocore_model import expr_template as et
+from biocore_model import runtime as rt
+from biocore_model import schema
+
+DOC = Path(__file__).resolve().parents[2] / "docs" / "NUMERIC-SCHEMA.md"
+
+
+class SchemaTest(unittest.TestCase):
+    def test_groups_and_fields_present(self):
+        names = {field["name"] for field in schema.FIELDS}
+        for expected in ("v", "a", "d", "social", "trust", "stress",
+                         "self_esteem", "social_pain", "tension", "warmth",
+                         "heaviness", "clarity", "belonging", "control",
+                         "meaningful_existence", "goal", "blame", "certainty",
+                         "novelty", "involve", "hit", "theta", "tau_hours",
+                         "cooldown_s", "daily_cap", "storage_s", "retrieval_s",
+                         "access_count", "arousal_at_encoding"):
+            self.assertIn(expected, names)
+
+    def test_ranges(self):
+        ranges = {field["name"]: (field["min"], field["max"])
+                  for field in schema.FIELDS}
+        self.assertEqual(ranges["v"], (-1.0, 1.0))
+        self.assertEqual(ranges["goal"], (-1.0, 1.0))
+        self.assertEqual(ranges["stress"], (0.0, 1.0))
+        self.assertEqual(ranges["theta"], (0.35, 0.75))
+        self.assertEqual(ranges["cooldown_s"], (1200, 10800))
+
+    def test_docs_match_code(self):
+        self.assertEqual(DOC.read_text(encoding="utf-8"), schema.render_markdown())
+        text = DOC.read_text(encoding="utf-8")
+        for field in schema.FIELDS:
+            self.assertIn(field["name"], text)
+            self.assertIn(field["desc"], text)
+
+
+class LegendTest(unittest.TestCase):
+    def test_significant_values_appear(self):
+        text = schema.numeric_legend({"v": 0.55, "a": 0.9, "stress": 0.7})
+        self.assertIn(schema.LEGEND_HEADER, text)
+        self.assertIn("v 效价", text)
+        self.assertIn("a 唤醒", text)
+        self.assertIn("stress 压力", text)
+        self.assertLessEqual(len(text), schema.LEGEND_LIMIT)
+
+    def test_flat_state_is_empty(self):
+        text = schema.numeric_legend({"v": 0.0, "a": 0.4, "stress": 0.1,
+                                      "social": 0.55, "trust": 0.5})
+        self.assertEqual(text, "")
+
+    def test_threshold_and_custom_baseline(self):
+        self.assertEqual(schema.numeric_legend({"v": 0.14}), "")
+        self.assertNotEqual(schema.numeric_legend({"v": 0.2}), "")
+        self.assertEqual(schema.numeric_legend({"v": 0.9},
+                                               baselines={"v": 0.9}), "")
+
+    def test_max_five_items_and_limit(self):
+        values = {"v": 1.0, "a": 1.0, "stress": 1.0, "social": 1.0,
+                  "trust": 1.0, "self_esteem": 1.0, "social_pain": 1.0}
+        text = schema.numeric_legend(values)
+        self.assertLessEqual(text.count("现在"), schema.LEGEND_MAX_ITEMS)
+        self.assertLessEqual(len(text), schema.LEGEND_LIMIT)
+
+
+class InjectionTest(unittest.TestCase):
+    def test_legend_in_system_after_persona_before_protocol(self):
+        legend = schema.numeric_legend({"v": 0.8, "stress": 0.8})
+        out = et.build_reply(state_ctx={"numeric_legend": legend},
+                             opts={"persona": "你是小灰", "speak_style": "口语"})
+        system = out["system"]
+        self.assertIn(schema.LEGEND_HEADER, system)
+        self.assertLess(system.index("小灰"), system.index(schema.LEGEND_HEADER))
+        self.assertNotIn("【输出格式", system)
+        self.assertNotIn(schema.LEGEND_HEADER, out["user"])
+
+    def test_no_legend_when_flat(self):
+        out = et.build_reply(opts={"persona": "你是小灰"})
+        self.assertNotIn(schema.LEGEND_HEADER, out["system"])
+
+    def test_runtime_enrich_sets_legend(self):
+        core = types.SimpleNamespace(snapshot=lambda: {
+            "v": 0.8, "a": 0.9, "stress": 0.8, "social": 0.2,
+            "trust": 0.2, "self_esteem": 0.2})
+        plugin = types.SimpleNamespace(_relationship_of=lambda user: {},
+                                       persona_text="", prompt_rules=None)
+        ctx = {"core": core, "plugin": plugin, "user": {}, "meta": {}}
+        out = rt.enrich_ctx(ctx)
+        self.assertIn(schema.LEGEND_HEADER, out.get("numeric_legend", ""))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_output_protocol.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+"""Output-protocol tests: single constant, system placement, strong format."""
+import unittest
+from pathlib import Path
+
+from biocore_model import expr_template as et
+
+
+class ConstantTest(unittest.TestCase):
+    def test_header_example_and_constraints(self):
+        text = et.PROMPT_OUTPUT_PROTOCOL
+        self.assertIn("【输出格式 · 必须遵守】", text)
+        self.assertIn('<bc>{"e":"joy","i":0.6}</bc>', text)
+        self.assertIn("e 只能取", text)
+        self.assertIn("joy / trust / anxiety / sadness / anger / loneliness / neutral", text)
+        self.assertIn("i 是 0 到 1 的小数", text)
+        self.assertIn("不要包在代码块里", text)
+
+    def test_old_weak_sentence_is_gone(self):
+        self.assertNotIn("只输出正文 + 一个 <bc> 标签", et.PROMPT_OUTPUT_PROTOCOL)
+
+
+class TemplatePlacementTest(unittest.TestCase):
+    def test_reply_system_has_no_protocol(self):
+        out = et.build_reply(opts={"persona": "你是小灰", "speak_style": "口语"})
+        self.assertNotIn("【输出格式", out["system"])
+        self.assertNotIn("<bc>", out["system"])
+        self.assertNotIn("【输出格式", out["user"])
+
+    def test_proactive_system_has_no_protocol(self):
+        out = et.build_proactive(opts={"persona": "你是小灰"})
+        self.assertNotIn("【输出格式", out["system"])
+        self.assertNotIn("<bc>", out["system"])
+        self.assertNotIn("【输出格式", out["user"])
+
+    def test_protocol_absent_everywhere(self):
+        out = et.build_reply(opts={})
+        self.assertEqual(out["system"].count("【输出格式 · 必须遵守】"), 0)
+
+    def test_order_no_protocol_in_user(self):
+        out = et.build_reply(opts={})
+        self.assertNotIn("输出协议", out["order"])
+
+    def test_custom_protocol_is_ignored(self):
+        out = et.build_reply(opts={"output_protocol": "CUSTOM-PROTOCOL"})
+        self.assertNotIn("CUSTOM-PROTOCOL", out["system"])
+        self.assertNotIn("CUSTOM-PROTOCOL", out["user"])
+
+
+class WiringTest(unittest.TestCase):
+    def test_main_uses_constant_not_old_literal(self):
+        source = (Path(__file__).resolve().parents[2] / "main.py").read_text(encoding="utf-8")
+        self.assertNotIn('_etpl.PROMPT_OUTPUT_PROTOCOL', source)
+        self.assertNotIn('"output_protocol"', source)
+
+    def test_runtime_has_no_protocol_default(self):
+        from biocore_model import runtime
+        ctx = runtime.make_request_ctx(plugin=None, event=None, core=None, text="x")
+        ctx = runtime.enrich_ctx(ctx)
+        opts = (ctx.get("meta") or {}).get("template_opts") or {}
+        self.assertFalse(opts.get("output_protocol"))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_page_debug.py

@@ -0,0 +1,147 @@
+# -*- coding: utf-8 -*-
+"""page/debug tests: field completeness, real attribute reads, error -> null."""
+import ast
+import asyncio
+import json
+import tempfile
+import types
+import unittest
+from pathlib import Path
+
+from biocore_model import intero_core as ic
+
+MAIN = Path(__file__).resolve().parents[2] / "main.py"
+SOURCE = MAIN.read_text(encoding="utf-8")
+
+
+def _load_page_debug():
+    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.AsyncFunctionDef) and f.name == "page_debug")
+    blocks = types.SimpleNamespace(
+        BLOCKS=[types.SimpleNamespace(id="bio_emotion"),
+                types.SimpleNamespace(id="bio_goal"),
+                types.SimpleNamespace(id="runtime")],
+        _enabled_map=lambda plugin: {"bio_emotion": True, "bio_goal": False, "runtime": True})
+    ns = {"_bc_blocks": blocks,
+          "PROFILE_PATH": Path("/data/persona_profile.json"),
+          "DATA_DIR": Path("/data")}
+    clone = ast.AsyncFunctionDef(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=[]), "<page_debug>", "exec"), ns)
+    return ns[node.name], ns
+
+
+PAGE_DEBUG, NS = _load_page_debug()
+
+
+class FakeCore:
+    def __init__(self):
+        self.intero = {"tension": 0.8, "warmth": 0.2, "heaviness": 0.5, "clarity": 0.4}
+        self.needs = {"belonging": 0.4, "control": 0.6}
+        self.pending_intent = {"action": "repair", "reason": "tension"}
+        self.last_bio_tick_ts = 1700000000.0
+
+
+class FakePlugin:
+    def __init__(self, tmp):
+        self.data_dir = str(tmp)
+        self.cores = {"s1": FakeCore()}
+        self._life_tick_n = 42
+        self._policy_pending = {"ctx": "expect|secure|day"}
+
+    def _load_policy_q(self):
+        return {"expect|secure|day": {"q": 0.1}, "protest|secure|day": {"q": 0.2}}
+
+
+class PageDebugTest(unittest.IsolatedAsyncioTestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.plugin = FakePlugin(self.tmp.name)
+        from biocore_model import ui_settings
+        ui_settings.save(self.plugin, {"autonomy": {"accumulator": {
+            "V": 0.3, "theta": 0.55, "ticks_since_fire": 2}}})
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    async def _payload(self):
+        return await PAGE_DEBUG(self.plugin)
+
+    async def test_all_fields_present_and_json_safe(self):
+        out = await self._payload()
+        self.assertEqual(out["status"], "ok")
+        data = out["data"]
+        for key in ("loop", "bio", "autonomy", "paths", "blocks", "pipeline", "policy"):
+            self.assertIn(key, data)
+        json.dumps(out)  # must be serialisable
+
+    async def test_loop_reads_live_counter(self):
+        data = (await self._payload())["data"]
+        self.assertEqual(data["loop"]["count"], 42)
+        self.assertEqual(data["loop"]["interval_s"], 10)
+        self.assertEqual(data["loop"]["last_tick_ts"], 1700000000.0)
+
+    async def test_bio_reads_core(self):
+        data = (await self._payload())["data"]
+        expected = ic.discomfort(self.plugin.cores["s1"].intero)["total"]
+        self.assertAlmostEqual(data["bio"]["discomfort"], expected)
+        self.assertEqual(data["bio"]["pending_intent"]["action"], "repair")
+        self.assertEqual(data["bio"]["needs"]["belonging"], 0.4)
+        self.assertEqual(data["bio"]["intero"]["tension"], 0.8)
+
+    async def test_autonomy_accumulator(self):
+        data = (await self._payload())["data"]
+        self.assertEqual(data["autonomy"]["V"], 0.3)
+        self.assertEqual(data["autonomy"]["theta"], 0.55)
+        self.assertEqual(data["autonomy"]["ticks_since_fire"], 2)
+
+    async def test_paths_use_authority_settings_file(self):
+        data = (await self._payload())["data"]
+        self.assertTrue(data["paths"]["settings"].endswith("ui_settings.json"))
+        self.assertIn("persona_profile.json", data["paths"]["profile"])
+        self.assertTrue(data["paths"]["data_dir"])
+
+    async def test_blocks_and_pipeline_and_policy(self):
+        data = (await self._payload())["data"]
+        self.assertEqual(data["blocks"]["enabled"], ["bio_emotion", "runtime"])
+        self.assertEqual(data["blocks"]["skipped"], ["bio_goal"])
+        self.assertIn(data["pipeline"]["mode"], ("shadow", "active"))
+        self.assertIsInstance(data["pipeline"]["last_trace"], dict)
+        self.assertEqual(data["policy"]["q_size"], 2)
+        self.assertEqual(data["policy"]["last_ctx"], "expect|secure|day")
+
+    async def test_failures_degrade_to_null_not_crash(self):
+        plugin = FakePlugin(self.tmp.name)
+        plugin._life_tick_n = None
+
+        def boom(*args, **kwargs):
+            raise RuntimeError("boom")
+
+        plugin._load_policy_q = boom
+        plugin._policy_pending = None
+        old = NS["_bc_blocks"]
+        NS["_bc_blocks"] = types.SimpleNamespace(
+            BLOCKS=[types.SimpleNamespace(id="bio_emotion")],
+            _enabled_map=boom)
+        try:
+            out = await PAGE_DEBUG(plugin)
+        finally:
+            NS["_bc_blocks"] = old
+        self.assertEqual(out["status"], "ok")
+        self.assertEqual(out["data"]["policy"], {"q_size": None, "last_ctx": None})
+        self.assertEqual(out["data"]["blocks"], {"enabled": [], "skipped": []})
+        json.dumps(out)
+
+    async def test_route_registered(self):
+        self.assertIn("/astrbot_plugin_biocore/page/debug", SOURCE)
+        self.assertIn("self.page_debug", SOURCE)
+
+
+if __name__ == "__main__":
+    unittest.main()