dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_reconstruction.py

@@ -0,0 +1,111 @@
+# -*- coding: utf-8 -*-
+"""Memory reconstruction: bounded drift, direction, conservation."""
+import unittest
+
+from biocore_model import reconstruction as rc
+
+ENTRY = {"text": "那天一起看了海", "importance": 0.5, "valence": 0.2}
+
+
+class MagnitudeTest(unittest.TestCase):
+    def test_zero_recalls_no_drift(self):
+        self.assertEqual(rc.magnitude(0), 0.0)
+
+    def test_grows_with_recalls(self):
+        self.assertGreater(rc.magnitude(5), rc.magnitude(1))
+
+    def test_capped(self):
+        self.assertLessEqual(rc.magnitude(10 ** 6), rc.DRIFT_CAP)
+
+
+class DirectionTest(unittest.TestCase):
+    def test_warm_mood_positive(self):
+        self.assertEqual(rc.direction(0.6), 1)
+
+    def test_low_mood_negative(self):
+        self.assertEqual(rc.direction(-0.5), -1)
+
+    def test_neutral(self):
+        self.assertEqual(rc.direction(0.0), 0)
+
+
+class DriftTest(unittest.TestCase):
+    def test_no_recall_no_change(self):
+        out = rc.drift(ENTRY, mood=0.8, recalls=0)
+        self.assertEqual(out["delta"], 0.0)
+
+    def test_warm_mood_moves_positive(self):
+        out = rc.drift(ENTRY, mood=0.8, recalls=3)
+        self.assertGreater(out["delta"], 0.0)
+
+    def test_low_mood_moves_negative(self):
+        out = rc.drift(ENTRY, mood=-0.8, recalls=3)
+        self.assertLess(out["delta"], 0.0)
+
+    def test_neutral_mood_no_change(self):
+        out = rc.drift(ENTRY, mood=0.0, recalls=3)
+        self.assertEqual(out["delta"], 0.0)
+
+    def test_important_memory_never_drifts(self):
+        row = dict(ENTRY, importance=0.95)
+        out = rc.drift(row, mood=0.9, recalls=20)
+        self.assertEqual(out["delta"], 0.0)
+        self.assertEqual(out["reason"], "重要记忆不漂")
+
+    def test_empty_text_no_change(self):
+        out = rc.drift({"importance": 0.3}, mood=0.9, recalls=3)
+        self.assertEqual(out["delta"], 0.0)
+
+    def test_cap_respected(self):
+        out = rc.drift(ENTRY, mood=1.0, recalls=1000, prior_drift=0.10)
+        self.assertLessEqual(abs(out["total"]), rc.DRIFT_CAP)
+        self.assertTrue(out["capped"])
+
+    def test_conservation_positive_side(self):
+        out = rc.drift(ENTRY, mood=1.0, recalls=50, prior_drift=0.10)
+        self.assertAlmostEqual(out["total"], rc.DRIFT_CAP, places=3)
+
+    def test_conservation_negative_side(self):
+        out = rc.drift(ENTRY, mood=-1.0, recalls=50, prior_drift=-0.10)
+        self.assertAlmostEqual(out["total"], -rc.DRIFT_CAP, places=3)
+
+    def test_disabled(self):
+        out = rc.drift(ENTRY, mood=0.9, recalls=5, flags={"enabled": False})
+        self.assertEqual(out["delta"], 0.0)
+        self.assertFalse(out["enabled"])
+
+    def test_malformed_entry(self):
+        out = rc.drift("nope", mood="x", recalls="y")
+        self.assertEqual(out["delta"], 0.0)
+
+    def test_bounded_without_prior(self):
+        out = rc.drift(ENTRY, mood=-1.0, recalls=5)
+        self.assertGreaterEqual(out["total"], -rc.DRIFT_CAP)
+
+
+class HintTest(unittest.TestCase):
+    def test_no_hint_when_tiny(self):
+        self.assertEqual(rc.text_hint({"enabled": True, "total": 0.0}), "")
+
+    def test_warm_hint(self):
+        self.assertIn("暖", rc.text_hint({"enabled": True, "total": 0.05}))
+
+    def test_cold_hint(self):
+        self.assertIn("凉", rc.text_hint({"enabled": True, "total": -0.05}))
+
+    def test_disabled_hint(self):
+        self.assertEqual(rc.text_hint({"enabled": False, "total": 0.05}), "")
+
+
+class ConserveTest(unittest.TestCase):
+    def test_within_cap_untouched(self):
+        out = rc.conserve([{"drift": 0.03}, {"drift": -0.02}])
+        self.assertEqual(out["scale"], 1.0)
+
+    def test_scales_down(self):
+        out = rc.conserve([{"drift": 0.3}, {"drift": 0.3}])
+        self.assertLessEqual(abs(out["total"]), rc.DRIFT_CAP)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_regulation_strategies.py

@@ -0,0 +1,228 @@
+# -*- coding: utf-8 -*-
+"""task-175 调节策略库单测：Gross 五策略命中、成本/效果、关系调制、关闭。
+
+只依赖 biocore_model.regulation_strategies 的纯函数；不导入 main.py。
+"""
+import unittest
+
+from biocore_model import regulation_strategies as rs
+
+CALM = {"closeness": 0.5, "trust": 0.5, "conflict": 0.0}
+
+SELECT_STATE = {"stress": 0.2, "energy": 0.7}
+SELECT_EVENT = {"when": "before", "controllable": 0.9, "intensity": 0.4}
+
+MODIFY_STATE = {"stress": 0.3, "energy": 0.6}
+MODIFY_EVENT = {"when": "after", "controllable": 0.8, "intensity": 0.5}
+MODIFY_REL = {"closeness": 0.7, "trust": 0.6}
+
+ATTENTION_STATE = {"stress": 0.8, "energy": 0.2, "valence": -0.3}
+ATTENTION_EVENT = {"when": "after", "controllable": 0.1, "intensity": 0.9}
+
+REAPPRAISE_STATE = {"stress": 0.2, "energy": 0.8, "valence": 0.4}
+REAPPRAISE_EVENT = {"when": "after", "controllable": 0.7, "intensity": 0.4}
+REAPPRAISE_REL = {"closeness": 0.9, "trust": 0.9}
+
+MODULATE_STATE = {"stress": 0.7, "energy": 0.4}
+MODULATE_EVENT = {"when": "after", "controllable": 0.5, "intensity": 0.6,
+                  "public": True}
+MODULATE_REL = {"closeness": 0.2, "trust": 0.2, "conflict": 0.8}
+
+
+class ContractTest(unittest.TestCase):
+    def test_result_keys(self):
+        out = rs.evaluate(SELECT_STATE, SELECT_EVENT, CALM)
+        for key in ("enabled", "strategy", "label", "cost", "effect", "reason",
+                    "self_talk", "coping_tier", "confidence", "fit", "scores",
+                    "profiles"):
+            self.assertIn(key, out)
+
+    def test_five_strategies_and_labels(self):
+        self.assertEqual(len(rs.STRATEGIES), 5)
+        self.assertEqual(set(rs.LABELS), set(rs.STRATEGIES))
+        self.assertEqual(rs.LABELS["situation_selection"], "情境选择")
+        self.assertEqual(rs.LABELS["situation_modification"], "情境修正")
+        self.assertEqual(rs.LABELS["attentional_deployment"], "注意部署")
+        self.assertEqual(rs.LABELS["cognitive_reappraisal"], "认知重评")
+        self.assertEqual(rs.LABELS["response_modulation"], "反应调节")
+
+    def test_old_coping_tiers_coexist(self):
+        self.assertEqual(rs.COPING_TIERS,
+                         ("problem_focused", "emotion_focused", "avoidance"))
+        self.assertEqual(set(rs.TIER_OF), set(rs.STRATEGIES))
+        for tier in rs.TIER_OF.values():
+            self.assertIn(tier, rs.COPING_TIERS)
+
+    def test_values_bounded(self):
+        for args in (
+            (SELECT_STATE, SELECT_EVENT, CALM),
+            (ATTENTION_STATE, ATTENTION_EVENT, CALM),
+            (MODULATE_STATE, MODULATE_EVENT, MODULATE_REL),
+        ):
+            out = rs.evaluate(*args)
+            for key in ("cost", "effect", "fit", "confidence"):
+                self.assertGreaterEqual(out[key], 0.0)
+                self.assertLessEqual(out[key], 1.0)
+            self.assertEqual(set(out["scores"]), set(rs.STRATEGIES))
+
+    def test_deterministic(self):
+        first = rs.evaluate(MODULATE_STATE, MODULATE_EVENT, MODULATE_REL)
+        second = rs.evaluate(MODULATE_STATE, MODULATE_EVENT, MODULATE_REL)
+        self.assertEqual(first, second)
+
+
+class FiveStrategiesTest(unittest.TestCase):
+    def test_situation_selection(self):
+        out = rs.evaluate(SELECT_STATE, SELECT_EVENT, CALM)
+        self.assertEqual(out["strategy"], "situation_selection")
+        self.assertEqual(out["coping_tier"], "problem_focused")
+
+    def test_situation_modification(self):
+        out = rs.evaluate(MODIFY_STATE, MODIFY_EVENT, MODIFY_REL)
+        self.assertEqual(out["strategy"], "situation_modification")
+        self.assertEqual(out["coping_tier"], "problem_focused")
+
+    def test_attentional_deployment(self):
+        out = rs.evaluate(ATTENTION_STATE, ATTENTION_EVENT, CALM)
+        self.assertEqual(out["strategy"], "attentional_deployment")
+        self.assertEqual(out["coping_tier"], "avoidance")
+
+    def test_cognitive_reappraisal(self):
+        out = rs.evaluate(REAPPRAISE_STATE, REAPPRAISE_EVENT, REAPPRAISE_REL)
+        self.assertEqual(out["strategy"], "cognitive_reappraisal")
+        self.assertEqual(out["coping_tier"], "emotion_focused")
+
+    def test_response_modulation(self):
+        out = rs.evaluate(MODULATE_STATE, MODULATE_EVENT, MODULATE_REL)
+        self.assertEqual(out["strategy"], "response_modulation")
+        self.assertEqual(out["coping_tier"], "emotion_focused")
+        self.assertGreater(out["cost"], 0.6)
+
+
+class CostEffectTest(unittest.TestCase):
+    def test_suppression_costs_more_than_selection(self):
+        selection = rs.profile("situation_selection", SELECT_STATE,
+                               SELECT_EVENT, CALM)
+        modulation = rs.profile("response_modulation", MODULATE_STATE,
+                                MODULATE_EVENT, MODULATE_REL)
+        self.assertGreater(modulation["cost"], selection["cost"])
+
+    def test_suppression_costs_more_than_reappraisal(self):
+        reappraisal = rs.profile("cognitive_reappraisal", MODULATE_STATE,
+                                 MODULATE_EVENT, MODULATE_REL)
+        modulation = rs.profile("response_modulation", MODULATE_STATE,
+                                MODULATE_EVENT, MODULATE_REL)
+        self.assertGreater(modulation["cost"], reappraisal["cost"])
+
+    def test_reappraisal_costs_more_than_distraction(self):
+        state = {"energy": 0.5, "stress": 0.5}
+        event = {"intensity": 0.5}
+        reappraisal = rs.profile("cognitive_reappraisal", state, event, CALM)
+        attention = rs.profile("attentional_deployment", state, event, CALM)
+        self.assertGreater(reappraisal["cost"], attention["cost"])
+
+    def test_effect_rises_with_control(self):
+        low = rs.profile("situation_selection", {}, {"controllable": 0.1})
+        high = rs.profile("situation_selection", {}, {"controllable": 0.9})
+        self.assertGreater(high["effect"], low["effect"])
+
+    def test_profiles_cover_all_strategies(self):
+        rows = rs.profiles(SELECT_STATE, SELECT_EVENT, CALM)
+        self.assertEqual({row["strategy"] for row in rows},
+                         set(rs.STRATEGIES))
+        for first, second in zip(rows, rows[1:]):
+            self.assertGreaterEqual(first["score"], second["score"])
+        for row in rows:
+            for key in ("cost", "effect", "fit", "score"):
+                self.assertGreaterEqual(row[key], 0.0)
+                self.assertLessEqual(row[key], 1.0)
+
+
+class RelationshipTest(unittest.TestCase):
+    def test_trust_raises_reappraisal_fit(self):
+        near = rs.profile("cognitive_reappraisal", REAPPRAISE_STATE,
+                          REAPPRAISE_EVENT, {"closeness": 0.9, "trust": 0.9})
+        far = rs.profile("cognitive_reappraisal", REAPPRAISE_STATE,
+                         REAPPRAISE_EVENT, {"closeness": 0.1, "trust": 0.1})
+        self.assertGreater(near["fit"], far["fit"])
+
+    def test_close_relationship_prefers_reappraisal(self):
+        near = rs.evaluate(REAPPRAISE_STATE, REAPPRAISE_EVENT,
+                           {"closeness": 0.9, "trust": 0.9})
+        far = rs.evaluate(REAPPRAISE_STATE, REAPPRAISE_EVENT,
+                          {"closeness": 0.1, "trust": 0.1})
+        self.assertEqual(near["strategy"], "cognitive_reappraisal")
+        self.assertNotEqual(far["strategy"], near["strategy"])
+
+    def test_public_conflict_prefers_suppression(self):
+        out = rs.evaluate(MODULATE_STATE, MODULATE_EVENT, MODULATE_REL)
+        self.assertEqual(out["strategy"], "response_modulation")
+        reappraisal_fit = out["scores"]["cognitive_reappraisal"]
+        self.assertLess(reappraisal_fit, out["scores"]["response_modulation"])
+
+
+class SwitchTest(unittest.TestCase):
+    def test_disabled_returns_old_coping(self):
+        out = rs.evaluate(SELECT_STATE, SELECT_EVENT, CALM,
+                          flags={"enabled": False})
+        self.assertFalse(out["enabled"])
+        self.assertEqual(out["strategy"], "none")
+        self.assertEqual(out["cost"], 0.0)
+        self.assertEqual(out["effect"], 0.0)
+        self.assertIsNone(out["scores"].get("situation_selection"))
+        self.assertIn("关闭", out["reason"])
+
+    def test_directives_disabled_is_neutral(self):
+        out = rs.directives(rs.evaluate(flags={"enabled": False}))
+        self.assertEqual(out["strategy"], "none")
+        self.assertEqual(out["tone"], "")
+        self.assertEqual(out["coping_tier"], "")
+
+
+class SelfTalkTest(unittest.TestCase):
+    def test_self_talk_exists_for_every_strategy(self):
+        for strategy in rs.STRATEGIES:
+            row = rs.profile(strategy)
+            self.assertTrue(row["self_talk"])
+            self.assertLessEqual(len(row["self_talk"]), 40)
+            self.assertTrue(row["reason"])
+
+    def test_directives_carry_strategy_and_tone(self):
+        out = rs.directives(rs.evaluate(SELECT_STATE, SELECT_EVENT, CALM))
+        self.assertEqual(out["strategy"], "situation_selection")
+        self.assertIn(out["coping_tier"], rs.COPING_TIERS)
+        self.assertTrue(out["tone"])
+        self.assertGreaterEqual(out["cost"], 0.0)
+        self.assertLessEqual(out["effect"], 1.0)
+
+
+class RobustnessTest(unittest.TestCase):
+    def test_odd_inputs_still_choose(self):
+        for state in (None, {}, "x", 3, [], {"stress": float("nan")}):
+            out = rs.evaluate(state=state)
+            self.assertIn(out["strategy"], rs.STRATEGIES)
+            self.assertTrue(out["reason"])
+        for event in (None, "x", 3, [], {"controllable": "?"}):
+            self.assertIn(rs.evaluate(SELECT_STATE, event)["strategy"],
+                          rs.STRATEGIES)
+        for relationship in (None, "x", 3, []):
+            self.assertIn(rs.evaluate(relationship=relationship)["strategy"],
+                          rs.STRATEGIES)
+
+    def test_unknown_profile_is_neutral(self):
+        out = rs.profile("nope")
+        self.assertEqual(out["strategy"], "none")
+        self.assertEqual(out["cost"], 0.0)
+        self.assertEqual(out["score"], 0.0)
+
+    def test_confidence_within_bounds(self):
+        for args in ((SELECT_STATE, SELECT_EVENT, CALM),
+                     (ATTENTION_STATE, ATTENTION_EVENT, CALM),
+                     ({}, {}, {})):
+            out = rs.evaluate(*args)
+            self.assertGreaterEqual(out["confidence"], 0.0)
+            self.assertLessEqual(out["confidence"], 1.0)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_relation_stage.py

@@ -0,0 +1,114 @@
+# -*- coding: utf-8 -*-
+"""Relationship stage: progress, thresholds, actions, fairness."""
+import unittest
+
+from biocore_model import relation_stage as rs
+
+
+def state(**kwargs):
+    base = {"interactions": 0, "disclosures": 0, "repairs": 0,
+            "days_known": 0, "conflict": 0.0}
+    base.update(kwargs)
+    return base
+
+
+class ProgressTest(unittest.TestCase):
+    def test_empty_is_zero(self):
+        self.assertEqual(rs.progress({}), 0.0)
+
+    def test_more_interactions_more_progress(self):
+        low = rs.progress(state(interactions=2))
+        high = rs.progress(state(interactions=40))
+        self.assertGreater(high, low)
+
+    def test_disclosure_moves_stage_fast(self):
+        low = rs.progress(state(interactions=5))
+        high = rs.progress(state(interactions=5, disclosures=10))
+        self.assertGreater(high, low)
+
+    def test_repairs_add(self):
+        low = rs.progress(state(interactions=10, disclosures=4))
+        high = rs.progress(state(interactions=10, disclosures=4, repairs=3))
+        self.assertGreater(high, low)
+
+    def test_conflict_subtracts(self):
+        calm = rs.progress(state(interactions=20, disclosures=6))
+        tense = rs.progress(state(interactions=20, disclosures=6, conflict=0.9))
+        self.assertLess(tense, calm)
+
+    def test_progress_bounded(self):
+        value = rs.progress(state(interactions=9999, disclosures=9999, repairs=9999,
+                                  days_known=9999))
+        self.assertLessEqual(value, 1.0)
+        self.assertGreaterEqual(value, 0.0)
+
+
+class StageTest(unittest.TestCase):
+    def test_thresholds(self):
+        self.assertEqual(rs.stage_of(0.1), "陌生")
+        self.assertEqual(rs.stage_of(0.5), "熟悉")
+        self.assertEqual(rs.stage_of(0.7), "亲近")
+        self.assertEqual(rs.stage_of(0.9), "稳定")
+
+    def test_actions_match_stages(self):
+        for stage in rs.STAGES:
+            self.assertIn(stage, rs.ACTIONS)
+
+    def test_evaluate_basic(self):
+        out = rs.evaluate(state(interactions=50, disclosures=12))
+        self.assertIn(out["stage"], rs.STAGES)
+        self.assertTrue(out["action"])
+
+
+class FairnessTest(unittest.TestCase):
+    def test_balanced(self):
+        out = rs.comparison({"his_investment": 0.5, "hers_investment": 0.5})
+        self.assertEqual(out["share"], 0.5)
+        self.assertEqual(out["balance"], 0.0)
+
+    def test_one_sided(self):
+        out = rs.comparison({"his_investment": 0.9, "hers_investment": 0.1})
+        self.assertGreater(out["balance"], 0.5)
+
+    def test_one_sided_marks_tentative(self):
+        out = rs.evaluate(state(interactions=50, disclosures=12,
+                                social_comparison={"his_investment": 0.9,
+                                                   "hers_investment": 0.1}))
+        self.assertTrue(out["tentative"])
+
+    def test_unfairness_slows_progress(self):
+        fair = rs.progress(state(interactions=30, disclosures=8,
+                                 social_comparison={"his_investment": 0.5,
+                                                    "hers_investment": 0.5}))
+        unfair = rs.progress(state(interactions=30, disclosures=8,
+                                   social_comparison={"his_investment": 0.95,
+                                                      "hers_investment": 0.05}))
+        self.assertLess(unfair, fair)
+
+
+class FallbackTest(unittest.TestCase):
+    def test_disabled(self):
+        out = rs.evaluate(state(interactions=100), flags={"enabled": False})
+        self.assertFalse(out["enabled"])
+        self.assertEqual(out["progress"], 0.0)
+
+    def test_malformed(self):
+        out = rs.evaluate("nope")
+        self.assertIn(out["stage"], rs.STAGES)
+
+
+class DirectiveTest(unittest.TestCase):
+    def test_stage_tone(self):
+        out = rs.directives({"enabled": True, "stage": "亲近"})
+        self.assertIn("主动", out["tone"])
+
+    def test_tentative_note(self):
+        out = rs.directives({"enabled": True, "stage": "熟悉", "tentative": True})
+        self.assertIn("不对等", out["tone"])
+
+    def test_disabled(self):
+        self.assertEqual(rs.directives({"enabled": False})["tone"], "")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_relationship_stage.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+import random, unittest
+from biocore_model import relationship_stage as rs
+
+NOW = 1_700_000_000
+
+class StageTest(unittest.TestCase):
+    def test_stranger(self):
+        self.assertEqual(rs.stage_for(5), 'stranger')
+    def test_acquaintance(self):
+        self.assertEqual(rs.stage_for(10), 'acquaintance')
+    def test_friend(self):
+        self.assertEqual(rs.stage_for(55), 'friend')
+    def test_close(self):
+        self.assertEqual(rs.stage_for(91), 'close')
+    def test_boundary_50(self):
+        self.assertEqual(rs.stage_for(50), 'friend')
+    def test_boundary_90(self):
+        self.assertEqual(rs.stage_for(90), 'close')
+    def test_friend_config(self):
+        cfg = rs.stage_config(55)
+        self.assertEqual(cfg['tau_hours'], 24); self.assertEqual(cfg['daily_cap'], 5)
+    def test_stranger_config(self):
+        cfg = rs.stage_config(0)
+        self.assertEqual(cfg['tau_hours'], 8); self.assertEqual(cfg['daily_cap'], 1)
+    def test_min_interval(self):
+        cfg = rs.stage_config(55)
+        self.assertAlmostEqual(cfg['min_interval_hours'], round(24 / (5 * 0.6), 2))
+
+class HabituationTest(unittest.TestCase):
+    def test_novelty_decay(self):
+        self.assertAlmostEqual(rs.novelty(0), 1.0)
+        self.assertAlmostEqual(rs.novelty(2), round(0.85 ** 2, 4))
+    def test_disabled_below_threshold(self):
+        usage = {'t1': {'count': 8, 'last_ts': NOW - 60}}
+        info = rs.template_weight('t1', usage, NOW)
+        self.assertTrue(info['disabled']); self.assertLess(info['weight'], 0.3)
+    def test_not_disabled_after_24h(self):
+        usage = {'t1': {'count': 8, 'last_ts': NOW - 25 * 3600}}
+        self.assertFalse(rs.template_weight('t1', usage, NOW)['disabled'])
+    def test_window_reset(self):
+        usage = {'t1': {'count': 8, 'last_ts': NOW - 8 * 86400}}
+        info = rs.template_weight('t1', usage, NOW)
+        self.assertEqual(info['count'], 0)
+    def test_record_template(self):
+        usage = rs.record_template({}, 't1', NOW)
+        self.assertEqual(usage['t1']['count'], 1)
+    def test_templates_view(self):
+        usage = {'t1': {'count': 9, 'last_ts': NOW - 10}, 't2': {'count': 1, 'last_ts': NOW - 10}}
+        view = rs.templates_view(usage, NOW)
+        self.assertIn('t1', view['disabled']); self.assertEqual(view['top_used'][0]['template_id'], 't1')
+    def test_pick_weighted_skips_disabled(self):
+        usage = {'t1': {'count': 9, 'last_ts': NOW - 10}}
+        self.assertEqual(rs.pick_weighted(['t1'], usage, NOW, random.Random(0)), None)
+    def test_pick_weighted_returns_candidate(self):
+        self.assertEqual(rs.pick_weighted(['t1', 't2'], {}, NOW, random.Random(0)) in ('t1', 't2'), True)
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_release_140.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+"""Release consistency + autonomy defaults (version taken from metadata)."""
+import json
+import unittest
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+PLUG = ROOT
+
+
+class VersionTest(unittest.TestCase):
+    def test_all_version_sources_match_metadata(self):
+        meta = (PLUG / "metadata.yaml").read_text(encoding="utf-8")
+        version = None
+        for line in meta.splitlines():
+            if line.startswith("version:"):
+                version = line.split(":", 1)[1].strip()
+                break
+        self.assertIsNotNone(version)
+        main = (PLUG / "main.py").read_text(encoding="utf-8")
+        self.assertIn('"%s")' % version, main)
+        app = (PLUG / "pages" / "dashboard" / "app.js").read_text(encoding="utf-8")
+        self.assertIn('BIO_VERSION = "v%s"' % version, app)
+        index = (PLUG / "pages" / "dashboard" / "index.html").read_text(encoding="utf-8")
+        self.assertIn('BIO_VERSION = "v%s"' % version, index)
+        readme = (PLUG / "README.md").read_text(encoding="utf-8")
+        self.assertIn(version, readme)
+        record = json.loads((ROOT.parent / "docs" / "BIOCORE-MARKET-RECORD-v1.json")
+                            .read_text(encoding="utf-8"))
+        rec = record["Johnhmzm/astrbot_plugin_biocore"]
+        self.assertEqual(rec["version"], version)
+
+
+class AutonomyDefaultTest(unittest.TestCase):
+    def test_schema_defaults_false(self):
+        schema = json.loads((PLUG / "_conf_schema.json").read_text(encoding="utf-8"))
+        self.assertIs(schema["proactive_autonomy"]["default"], False)
+        self.assertIs(schema["proactive_send"]["default"], False)
+        self.assertIs(schema["autonomy_loop_enabled"]["default"], False)
+
+    def test_code_reads_config_with_false_default(self):
+        main = (PLUG / "main.py").read_text(encoding="utf-8")
+        self.assertIn('self.proactive_autonomy = bool(self.config.get("proactive_autonomy", False))', main)
+        self.assertIn('self.proactive_send = bool(self.config.get("proactive_send", False))', main)
+
+    def test_changelog_warnings_and_rollback(self):
+        text = (PLUG / "CHANGELOG.md").read_text(encoding="utf-8")
+        self.assertIn("本版本改动较大", text)
+        self.assertIn("自主主动回复默认关闭", text)
+        self.assertIn("升级失败可回滚", text)
+        self.assertIn("docs/MIGRATION.md", text)
+
+
+if __name__ == "__main__":
+    unittest.main()