dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_connection_bids.py

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import connection_bids as cb
+
+NOW = 1_700_000_000
+
+class BidsTest(unittest.TestCase):
+    def test_record_bid(self):
+        bids = cb.record_bid([], NOW, 'lonely')
+        self.assertEqual(len(bids), 1); self.assertIsNone(bids[0]['turned'])
+    def test_turned_toward(self):
+        bids = cb.settle_bids(cb.record_bid([], NOW), NOW + 600, responded_ts=NOW + 600)
+        self.assertEqual(bids[0]['turned'], 'toward')
+    def test_turned_away(self):
+        bids = cb.settle_bids(cb.record_bid([], NOW), NOW + 7 * 3600)
+        self.assertEqual(bids[0]['turned'], 'away')
+    def test_streaks(self):
+        bids = [{'turned': 'toward'}, {'turned': 'away'}, {'turned': 'away'}, {'turned': 'away'}]
+        self.assertEqual(cb.streaks(bids), (0, 3))
+        self.assertEqual(cb.streaks([{'turned': 'away'}, {'turned': 'toward'}, {'turned': 'toward'}, {'turned': 'toward'}]), (3, 0))
+    def test_frequency_after_three_away(self):
+        bids = [{'turned': 'away'}] * 3
+        self.assertAlmostEqual(cb.bid_frequency(bids), 0.7)
+    def test_frequency_after_three_toward(self):
+        bids = [{'turned': 'toward'}] * 3
+        self.assertAlmostEqual(cb.bid_frequency(bids), 1.1)
+    def test_frequency_floor(self):
+        bids = [{'turned': 'away'}] * 10
+        self.assertGreaterEqual(cb.bid_frequency(bids, 0.6), cb.FREQ_MIN)
+    def test_frequency_cap(self):
+        bids = [{'turned': 'toward'}] * 10
+        self.assertLessEqual(cb.bid_frequency(bids, 1.25), cb.FREQ_MAX)
+    def test_bid_view(self):
+        view = cb.bid_view([{'turned': 'toward'}, {'turned': 'away'}], 1.1)
+        self.assertEqual(view['sent'], 2); self.assertEqual(view['toward'], 1); self.assertEqual(view['away'], 1)
+
+class ResponsivenessTest(unittest.TestCase):
+    def test_responded_raises(self):
+        self.assertGreater(cb.responsiveness_update(0.5, True), 0.5)
+    def test_ignored_lowers(self):
+        self.assertLess(cb.responsiveness_update(0.5, False), 0.5)
+    def test_gate_cost_low(self):
+        self.assertEqual(cb.gate_cost_adjust(0.2), 0.05)
+    def test_gate_cost_high(self):
+        self.assertEqual(cb.gate_cost_adjust(0.9), -0.05)
+    def test_disclosure_mult_low(self):
+        self.assertEqual(cb.disclosure_mult(0.2), 0.7)
+    def test_disclosure_mult_high(self):
+        self.assertEqual(cb.disclosure_mult(0.8), 1.0)
+
+class TrustTest(unittest.TestCase):
+    def test_three_dimensions(self):
+        trust = cb.trust_update(None, regular=True, kept=True, response_rate=0.8)
+        for key in ('predictability', 'dependability', 'faith', 'overall'):
+            self.assertIn(key, trust)
+    def test_dimensions_independent(self):
+        trust = cb.trust_update(None, regular=True)
+        self.assertGreater(trust['predictability'], 0.5)
+        self.assertAlmostEqual(trust['dependability'], 0.5)
+    def test_delayed_lowers_dependability(self):
+        trust = cb.trust_update(None, delayed=True)
+        self.assertLess(trust['dependability'], 0.5)
+    def test_overall_weights(self):
+        trust = {'predictability': 0.8, 'dependability': 0.6, 'faith': 0.4}
+        out = cb.trust_update(trust)
+        self.assertAlmostEqual(out['overall'], 0.4 * 0.8 + 0.4 * 0.6 + 0.2 * 0.4)
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_core_bridge.py

@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+import json, tempfile, unittest
+from pathlib import Path
+import sys
+sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+from biocore_model.core_bridge import CoreBridge
+class FakeCore:
+    def __init__(self, store=None, enabled=True, timeout=2.0, fail=False):
+        self.calls=[]; self.fail=fail; self.store=store
+    def remember(self,text,**kw):
+        self.calls.append(("remember",text))
+        return None if self.fail else {"ok":True,"id":"core1"}
+    def recall(self,q,limit=3):
+        self.calls.append(("recall",q))
+        return None if self.fail else {"ok":True,"results":[{"id":"core1","text":"core result"}]}
+    def forget(self,entry_id=None,query=None,limit=5):
+        self.calls.append(("forget",entry_id or query))
+        return None if self.fail else {"ok":True,"removed":[entry_id]}
+class BridgeTest(unittest.TestCase):
+    def setUp(self): self.tmp=tempfile.TemporaryDirectory(); self.dir=Path(self.tmp.name); self.bridge=CoreBridge({"core_client_mode":"off"},self.dir,core_factory=FakeCore)
+    def tearDown(self): self.tmp.cleanup()
+    def test_off_no_calls(self): self.assertIsNone(self.bridge.recall("x")); self.assertEqual(self.bridge.calls,0)
+    def test_disabled_default(self): self.assertFalse(CoreBridge({},self.dir,core_factory=FakeCore).enabled)
+    def test_shadow_recall(self):
+        b=CoreBridge({"core_client_enabled":True,"core_client_mode":"shadow"},self.dir,core_factory=FakeCore); self.assertTrue(b.enabled); rows=b.recall("q"); self.assertEqual(rows["results"][0]["id"],"core1"); self.assertGreaterEqual(b.calls,1)
+    def test_primary_format(self):
+        b=CoreBridge({"core_client_enabled":True,"core_client_mode":"primary"},self.dir,core_factory=FakeCore); text=b.rows_to_text(b.recall("q")["results"]); self.assertIn("core result",text)
+    def test_shadow_record(self):
+        b=CoreBridge({"core_client_enabled":True,"core_client_mode":"shadow"},self.dir,core_factory=FakeCore); row=b.record_shadow("q",["a","b"],["b","c"],0.1,0.2); self.assertEqual(row["overlap"],1); lines=(self.dir/"shadow_diff.jsonl").read_text(encoding="utf-8").strip().splitlines(); self.assertEqual(len(lines),1); self.assertIn("old_ids",json.loads(lines[0]))
+    def test_failure_degrades(self):
+        b=CoreBridge({"core_client_enabled":True,"core_client_mode":"primary"},self.dir,core_factory=lambda **kw: FakeCore(fail=True)); self.assertIsNone(b.recall("q")); self.assertEqual(b.failures,1)
+    def test_circuit_after_five(self):
+        b=CoreBridge({"core_client_enabled":True,"core_client_mode":"primary"},self.dir,core_factory=lambda **kw: FakeCore(fail=True))
+        for _ in range(5): b.recall("q")
+        self.assertTrue(b.circuit_open); before=b.calls; self.assertIsNone(b.recall("q")); self.assertEqual(b.calls,before)
+    def test_migrated_store_detection(self):
+        core=self.dir/"core_store"; core.mkdir(); (core/"memory.json").write_text('{"entries":[]}',encoding="utf-8"); b=CoreBridge({"core_client_enabled":True},self.dir,core_factory=FakeCore); self.assertTrue(b.migrated_available); self.assertTrue(b.store_path().endswith("core_store\\memory.json") or b.store_path().endswith("core_store/memory.json"))
+    def test_remember_primary(self):
+        b=CoreBridge({"core_client_enabled":True,"core_client_mode":"primary"},self.dir,core_factory=FakeCore); self.assertEqual(b.remember("hello")["id"],"core1")
+    def test_remember_shadow_not_written(self):
+        b=CoreBridge({"core_client_enabled":True,"core_client_mode":"shadow"},self.dir,core_factory=FakeCore); self.assertIsNone(b.remember("hello"))
+    def test_forget_primary(self):
+        b=CoreBridge({"core_client_enabled":True,"core_client_mode":"primary"},self.dir,core_factory=FakeCore); self.assertTrue(b.forget(entry_id="a")["ok"])
+
+class TimeoutTest(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory(); self.dir = Path(self.tmp.name)
+    def tearDown(self):
+        self.tmp.cleanup()
+    def test_core_client_timeout_default_and_set(self):
+        from biocore_model.core_client import CoreClient
+        client = CoreClient(enabled=False)
+        self.assertEqual(client.timeout, 3.0)
+        self.assertEqual(client.set_timeout(2.5), 2.5)
+        self.assertEqual(client.timeout, 2.5)
+        self.assertEqual(client.set_timeout(0.1), 2.5)
+        self.assertEqual(client.set_timeout("bad"), 2.5)
+
+    def test_bridge_uses_two_second_timeout(self):
+        seen = {}
+        def factory(**kw):
+            seen.update(kw)
+            return FakeCore(**kw)
+        b = CoreBridge({"core_client_enabled": True, "core_client_mode": "primary"}, self.dir, core_factory=factory)
+        b.recall("q")
+        self.assertEqual(seen.get("timeout"), 2.0)
+
+class ShadowRememberTest(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory(); self.dir = Path(self.tmp.name)
+    def tearDown(self):
+        self.tmp.cleanup()
+    def test_shadow_remember_writes_diff(self):
+        b = CoreBridge({"core_client_enabled": True, "core_client_mode": "shadow"}, self.dir, core_factory=FakeCore)
+        self.assertIsNone(b.remember("hello"))
+        lines = (self.dir / "shadow_diff.jsonl").read_text(encoding="utf-8").strip().splitlines()
+        self.assertEqual(len(lines), 1)
+        row = json.loads(lines[0])
+        self.assertIn("text_hash", row); self.assertTrue(row["core_ok"])
+    def test_primary_remember_no_diff(self):
+        b = CoreBridge({"core_client_enabled": True, "core_client_mode": "primary"}, self.dir, core_factory=FakeCore)
+        self.assertIsNotNone(b.remember("hello"))
+        self.assertFalse((self.dir / "shadow_diff.jsonl").exists())
+    def test_off_remember_zero(self):
+        calls = []
+        def factory(**kw): calls.append(kw); return FakeCore(**kw)
+        b = CoreBridge({"core_client_mode": "off"}, self.dir, core_factory=factory)
+        self.assertIsNone(b.remember("hello")); self.assertEqual(calls, []); self.assertFalse((self.dir / "shadow_diff.jsonl").exists())

package/python/biocore_model/tests/test_core_bridge_episode.py

@@ -0,0 +1,14 @@
+import tempfile, unittest
+from pathlib import Path
+import sys
+sys.path.insert(0,str(Path(__file__).resolve().parents[2]))
+from biocore_model.core_bridge import CoreBridge
+class EpisodeTest(unittest.TestCase):
+    def setUp(self): self.tmp=tempfile.TemporaryDirectory(); self.dir=Path(self.tmp.name)
+    def tearDown(self): self.tmp.cleanup()
+    def test_record_episode_local_once(self):
+        b=CoreBridge({'core_client_enabled':True,'core_client_mode':'shadow'},self.dir,core_factory=lambda **kw: None)
+        self.assertIsNotNone(b.record_episode('guard:refusal','blocked',0.0,{'reason':'x'}))
+        lines=(self.dir/'episodes-local.jsonl').read_text(encoding='utf-8').strip().splitlines(); self.assertEqual(len(lines),1); self.assertIn('guard:refusal',lines[0])
+    def test_off_no_episode(self):
+        b=CoreBridge({'core_client_mode':'off'},self.dir,core_factory=lambda **kw: None); self.assertIsNone(b.record_episode('guard:refusal','blocked'))

package/python/biocore_model/tests/test_core_bridge_forget.py

@@ -0,0 +1,17 @@
+import tempfile, unittest
+from pathlib import Path
+import sys
+sys.path.insert(0,str(Path(__file__).resolve().parents[2]))
+from biocore_model.core_bridge import CoreBridge
+class FakeCore:
+    def __init__(self,store=None,enabled=True,timeout=2.0,fail=False,**kw): self.calls=[]; self.fail=fail
+    def forget(self,entry_id=None,query=None,limit=5): self.calls.append(1); return None if self.fail else {"ok":True,"removed":[entry_id]}
+class T(unittest.TestCase):
+    def setUp(self): self.tmp=tempfile.TemporaryDirectory(); self.dir=Path(self.tmp.name)
+    def tearDown(self): self.tmp.cleanup()
+    def test_ok(self):
+        b=CoreBridge({"core_client_enabled":True,"core_client_mode":"primary"},self.dir,core_factory=FakeCore); self.assertTrue(b.forget_via_core(entry_id="a")["used_core"])
+    def test_fail(self):
+        b=CoreBridge({"core_client_enabled":True,"core_client_mode":"primary"},self.dir,core_factory=lambda **kw: FakeCore(fail=True)); self.assertFalse(b.forget_via_core(entry_id="a")["used_core"])
+    def test_off(self):
+        b=CoreBridge({"core_client_mode":"off"},self.dir,core_factory=FakeCore); self.assertFalse(b.forget_via_core(entry_id="a")["used_core"]); self.assertEqual(b.calls,0)

package/python/biocore_model/tests/test_core_bridge_identity.py

@@ -0,0 +1,15 @@
+import tempfile, unittest
+from pathlib import Path
+import sys
+sys.path.insert(0,str(Path(__file__).resolve().parents[2]))
+from biocore_model.core_bridge import CoreBridge
+class Fake:
+    def __init__(self,**kw): self.calls=[]
+    def _call(self,m,p): self.calls.append((m,p)); return {'ok':True}
+class T(unittest.TestCase):
+    def setUp(self): self.tmp=tempfile.TemporaryDirectory(); self.dir=Path(self.tmp.name)
+    def tearDown(self): self.tmp.cleanup()
+    def test_primary_identity(self):
+        b=CoreBridge({'core_client_enabled':True,'core_client_mode':'primary'},self.dir,core_factory=Fake); r=b.identity_signal({'level':'high'}); self.assertIsNotNone(r); self.assertEqual(b._client.calls[0][0],'identity.writeback')
+    def test_off_identity(self):
+        b=CoreBridge({'core_client_mode':'off'},self.dir,core_factory=Fake); self.assertIsNone(b.identity_signal({'level':'high'})); self.assertEqual(b.calls,0)

package/python/biocore_model/tests/test_core_bridge_media.py

@@ -0,0 +1,17 @@
+import tempfile, unittest
+from pathlib import Path
+import sys
+sys.path.insert(0,str(Path(__file__).resolve().parents[2]))
+from biocore_model.core_bridge import CoreBridge
+class Fake:
+    def __init__(self,**kw): self.calls=[]; self.last_error='provider_unavailable'
+    def _call(self,m,p): self.calls.append((m,p)); return None
+class T(unittest.TestCase):
+    def setUp(self): self.tmp=tempfile.TemporaryDirectory(); self.dir=Path(self.tmp.name)
+    def tearDown(self): self.tmp.cleanup()
+    def test_enabled_probe_writes(self):
+        b=CoreBridge({'core_client_enabled':True,'core_client_mode':'shadow'},self.dir,core_factory=Fake); r=b.media_probe(); self.assertIsNotNone(r); self.assertTrue((self.dir/'media-probe.jsonl').exists()); row=(self.dir/'media-probe.jsonl').read_text(encoding='utf-8'); self.assertIn('provider_unavailable',row)
+    def test_off_probe(self):
+        calls=[]
+        def f(**kw): calls.append(kw); return Fake(**kw)
+        b=CoreBridge({'core_client_mode':'off'},self.dir,core_factory=f); self.assertIsNone(b.media_probe()); self.assertEqual(calls,[]); self.assertFalse((self.dir/'media-probe.jsonl').exists())

package/python/biocore_model/tests/test_core_bridge_relation.py

@@ -0,0 +1,17 @@
+import tempfile, unittest
+from pathlib import Path
+import sys
+sys.path.insert(0,str(Path(__file__).resolve().parents[2]))
+from biocore_model.core_bridge import CoreBridge
+class Fake:
+    def __init__(self,**kw): self.calls=[]
+    def _call(self,m,p): self.calls.append((m,p)); return {'ok':True}
+class T(unittest.TestCase):
+    def setUp(self): self.tmp=tempfile.TemporaryDirectory(); self.dir=Path(self.tmp.name)
+    def tearDown(self): self.tmp.cleanup()
+    def test_primary_relation(self):
+        b=CoreBridge({'core_client_enabled':True,'core_client_mode':'primary'},self.dir,core_factory=Fake); self.assertIsNotNone(b.relation_update({'trust_delta':0.1})); self.assertTrue(b._client.calls)
+    def test_off_relation(self):
+        calls=[]
+        def f(**kw): calls.append(kw); return Fake(**kw)
+        b=CoreBridge({'core_client_mode':'off'},self.dir,core_factory=f); self.assertIsNone(b.relation_update({'trust_delta':0.1})); self.assertEqual(calls,[])

package/python/biocore_model/tests/test_core_bridge_summary.py

@@ -0,0 +1,17 @@
+import tempfile, unittest
+from pathlib import Path
+import sys
+sys.path.insert(0,str(Path(__file__).resolve().parents[2]))
+from biocore_model.core_bridge import CoreBridge
+class Fake:
+    def __init__(self,**kw): self.calls=[]
+    def _call(self,m,p): self.calls.append((m,p)); return {'ok':True}
+class T(unittest.TestCase):
+    def setUp(self): self.tmp=tempfile.TemporaryDirectory(); self.dir=Path(self.tmp.name)
+    def tearDown(self): self.tmp.cleanup()
+    def test_primary_summary(self):
+        b=CoreBridge({'core_client_enabled':True,'core_client_mode':'primary'},self.dir,core_factory=Fake); self.assertIsNone(b.summary_dry_run({'text':'hello'})); self.assertEqual(b._client.calls[0][0],'summary.daily'); self.assertTrue((self.dir/'summary-dryrun.jsonl').exists())
+    def test_off_summary(self):
+        calls=[]
+        def f(**kw): calls.append(kw); return Fake(**kw)
+        b=CoreBridge({'core_client_mode':'off'},self.dir,core_factory=f); self.assertIsNone(b.summary_dry_run({'text':'x'})); self.assertEqual(calls,[]); self.assertFalse((self.dir/'summary-dryrun.jsonl').exists())

package/python/biocore_model/tests/test_core_client.py

@@ -0,0 +1,156 @@
+# -*- coding: utf-8 -*-
+"""Offline tests for biocore_model.core_client (fake runner; no real service)."""
+import os
+import unittest
+
+from biocore_model.core_client import CoreClient
+
+
+class FakeRunner:
+    """Transport stub: records requests and returns scripted responses."""
+
+    def __init__(self, responses=None, errors=None):
+        self.requests = []
+        self.timeouts = []
+        self.responses = list(responses or [])
+        self.errors = list(errors or [])
+
+    def __call__(self, request, timeout):
+        self.requests.append(request)
+        self.timeouts.append(timeout)
+        if self.errors:
+            raise self.errors.pop(0)
+        if self.responses:
+            return self.responses.pop(0)
+        return {"id": request.get("id"), "ok": True, "result": {"ok": True, "echo": request.get("method")}}
+
+
+def ok(result=None):
+    return {"id": 0, "ok": True, "result": result if result is not None else {"ok": True}}
+
+
+def client(runner, **kwargs):
+    options = {"store": "C:/tmp/biocore-test-store", "enabled": True, "runner": runner}
+    options.update(kwargs)
+    return CoreClient(**options)
+
+
+class CoreClientTest(unittest.TestCase):
+    def test_disabled_by_default_returns_none(self):
+        os.environ.pop("BIOCORE_CORE_CLIENT", None)
+        fake = FakeRunner()
+        core = client(fake, enabled=False)
+        self.assertFalse(core.enabled)
+        self.assertIsNone(core.remember("hello"))
+        self.assertIsNone(core.recall("hello"))
+        self.assertIsNone(core.forget(entry_id="abc"))
+        self.assertIsNone(core.state())
+        self.assertIsNone(core.bio_snapshot())
+        self.assertIsNone(core.health())
+        self.assertEqual(fake.requests, [])
+
+    def test_env_switch_enables_client(self):
+        os.environ["BIOCORE_CORE_CLIENT"] = "1"
+        try:
+            fake = FakeRunner()
+            core = CoreClient(store="C:/tmp/biocore-test-store", runner=fake)
+            self.assertTrue(core.enabled)
+            self.assertEqual(core.health().get("ok"), True)
+            self.assertEqual(len(fake.requests), 1)
+        finally:
+            os.environ.pop("BIOCORE_CORE_CLIENT", None)
+
+    def test_remember_parses_result(self):
+        fake = FakeRunner([ok({"ok": True, "entry": {"id": "abc", "text": "hello"}})])
+        core = client(fake)
+        result = core.remember("hello", tags=["plan"], importance=0.8)
+        self.assertEqual(result["entry"]["id"], "abc")
+        self.assertEqual(core.last_error, "")
+        request = fake.requests[0]
+        self.assertEqual(request["method"], "memory.remember")
+        self.assertEqual(request["params"]["text"], "hello")
+        self.assertEqual(request["params"]["tags"], ["plan"])
+        self.assertEqual(request["params"]["importance"], 0.8)
+        self.assertEqual(request["params"]["role"], "user")
+
+    def test_id_and_method_passthrough(self):
+        fake = FakeRunner([ok({"results": []}), ok({"ok": True})])
+        core = client(fake)
+        core.recall("friday", limit=4)
+        core.health()
+        self.assertEqual([request["method"] for request in fake.requests], ["memory.recall", "health.check"])
+        self.assertEqual([request["id"] for request in fake.requests], [1, 2])
+        self.assertEqual(fake.requests[0]["params"], {"query": "friday", "limit": 4})
+
+    def test_timeout_returns_none_without_raise(self):
+        fake = FakeRunner(errors=[TimeoutError("slow")])
+        core = client(fake)
+        self.assertIsNone(core.recall("anything"))
+        self.assertIn("timeout", core.last_error)
+        self.assertEqual(len(fake.requests), 1)
+
+    def test_crash_once_restarts_and_succeeds(self):
+        fake = FakeRunner(responses=[ok({"ok": True, "entry": {"id": "after-restart"}})], errors=[ChildProcessError("boom")])
+        core = client(fake, max_restarts=1)
+        result = core.remember("survives a crash")
+        self.assertEqual(result["entry"]["id"], "after-restart")
+        self.assertEqual(len(fake.requests), 2)
+        self.assertEqual([request["method"] for request in fake.requests], ["memory.remember", "memory.remember"])
+        self.assertIn("process_error", core.last_error) if False else None
+        self.assertEqual(core.last_error, "")
+
+    def test_crash_twice_degrades_to_none(self):
+        fake = FakeRunner(errors=[ChildProcessError("boom"), ChildProcessError("boom again")])
+        core = client(fake, max_restarts=1)
+        self.assertIsNone(core.remember("never succeeds"))
+        self.assertEqual(len(fake.requests), 2)
+        self.assertIn("process_error", core.last_error)
+
+    def test_error_envelope_returns_none_with_code(self):
+        fake = FakeRunner([{"id": 1, "ok": False, "error": {"code": "readonly", "message": "store is read-only"}}])
+        core = client(fake)
+        self.assertIsNone(core.remember("blocked"))
+        self.assertIn("readonly", core.last_error)
+
+    def test_forget_by_id_and_by_query(self):
+        fake = FakeRunner([
+            ok({"ok": True, "id": "abc", "removed": True}),
+            ok({"results": [{"id": "r1"}, {"id": "r2"}]}),
+            ok({"ok": True, "id": "r1", "removed": True}),
+            ok({"ok": True, "id": "r2", "removed": False}),
+        ])
+        core = client(fake)
+        self.assertTrue(core.forget(entry_id="abc")["removed"])
+        result = core.forget(query="friday")
+        self.assertEqual(result["removed"], ["r1"])
+        self.assertEqual(result["count"], 1)
+        methods = [request["method"] for request in fake.requests]
+        self.assertEqual(methods, ["memory.forget", "memory.recall", "memory.forget", "memory.forget"])
+
+    def test_state_scope_and_bio_health_method_names(self):
+        fake = FakeRunner([ok({"ok": True}), ok({"ok": True}), ok({"ok": True})])
+        core = client(fake)
+        core.state(limit=5, scope="session:s1")
+        core.bio_snapshot()
+        core.health()
+        self.assertEqual([request["method"] for request in fake.requests], ["memory.state", "bio.snapshot", "health.check"])
+        self.assertEqual(fake.requests[0]["params"], {"limit": 5, "scope": "session:s1"})
+
+    def test_timeout_is_configurable_and_forwarded(self):
+        fake = FakeRunner()
+        core = client(fake, timeout=0.5)
+        core.health()
+        self.assertEqual(fake.timeouts[0], 0.5)
+
+    def test_close_blocks_later_calls(self):
+        fake = FakeRunner()
+        core = client(fake)
+        self.assertEqual(core.health().get("ok"), True)
+        core.close()
+        self.assertIsNone(core.recall("after close"))
+        self.assertEqual(len(fake.requests), 1)
+
+    def test_missing_service_script_degrades_without_throw(self):
+        core = CoreClient(store="C:/tmp/biocore-test-store", enabled=True, service_script="", runner=None)
+        self.assertIsNone(core.health())
+        self.assertIn("service_script_missing", core.last_error)

package/python/biocore_model/tests/test_core_commands.py

@@ -0,0 +1,146 @@
+class _Recorder:
+    """Logger stub so tests never import the stdlib logging module."""
+
+    def __init__(self):
+        self.lines = []
+        self.level = 0
+
+    def _log(self, msg, *args, **kwargs):
+        try:
+            self.lines.append(str(msg) % args if args else str(msg))
+        except Exception:
+            self.lines.append(str(msg))
+
+    def setLevel(self, *_a, **_k):
+        return None
+
+    def addHandler(self, *_a, **_k):
+        return None
+
+    def removeHandler(self, *_a, **_k):
+        return None
+
+    debug = info = warning = error = exception = critical = _log
+
+
+# -*- coding: utf-8 -*-
+"""Chat commands /biocore_core and /biocore_rollback (admin only, thin over core_mode)."""
+import unittest
+
+from biocore_model import core_commands
+from biocore_model import core_mode, core_mode
+
+
+class FakeEvent:
+    def __init__(self, admin=True, private=True, sender="u1", message=""):
+        self.admin = admin
+        self.private = private
+        self.sender = sender
+        self.message_str = message
+
+    def is_admin(self):
+        return bool(self.admin)
+
+    def is_private_chat(self):
+        return bool(self.private)
+
+    def get_sender_id(self):
+        return self.sender
+
+
+class NoAdminEvent(FakeEvent):
+    is_admin = None  # attribute absent path -> private chat + whitelist
+
+
+class FakePlugin:
+    def __init__(self, admin_ids=None):
+        self.config = {"core_client_mode": "off", "core_client_enabled": False,
+                       "command_admin_ids": list(admin_ids or [])}
+        self.data_admin_token = ""
+        self.saved = []
+
+    async def _persist_plugin_config(self, updates):
+        self.saved.append(dict(updates))
+        self.config.update(updates)
+
+    def _rebuild_core_bridge(self):
+        return True
+
+
+class ParseTest(unittest.TestCase):
+    def test_three_modes(self):
+        for mode in ("off", "shadow", "primary"):
+            parsed = core_commands.parse_args("/biocore_core " + mode)
+            self.assertTrue(parsed["usable"])
+            self.assertEqual(parsed["mode"], mode)
+
+    def test_invalid_usage(self):
+        for raw in ("/biocore_core", "/biocore_core bogus", "/biocore_core shadow extra"):
+            parsed = core_commands.parse_args(raw)
+            self.assertFalse(parsed["usable"])
+            self.assertIn("off|shadow|primary", parsed["usage"])
+
+
+class PermissionTest(unittest.TestCase):
+    def test_admin_event_allowed(self):
+        self.assertTrue(core_commands.is_admin(FakeEvent(admin=True), {}))
+
+    def test_plain_user_denied(self):
+        event = NoAdminEvent(admin=False, private=False)
+        self.assertFalse(core_commands.is_admin(event, {}))
+
+    def test_whitelist_allows_group_user(self):
+        event = NoAdminEvent(admin=False, private=False, sender="42")
+        self.assertTrue(core_commands.is_admin(event, {"command_admin_ids": ["42"]}))
+
+    def test_private_chat_fallback_allows(self):
+        event = NoAdminEvent(admin=False, private=True)
+        self.assertTrue(core_commands.is_admin(event, {}))
+
+
+class RunTest(unittest.IsolatedAsyncioTestCase):
+    async def test_switch_reply_and_config(self):
+        plugin = FakePlugin()
+        reply = await core_commands.run_core_command(plugin, "/biocore_core shadow", FakeEvent())
+        self.assertEqual(reply, "核心模式已切换：off → shadow（立即生效）")
+        self.assertEqual(plugin.config["core_client_mode"], "shadow")
+        self.assertTrue(plugin.config["core_client_enabled"])
+        self.assertEqual(plugin.saved[-1], {"core_client_enabled": True, "core_client_mode": "shadow"})
+
+    async def test_invalid_argument_reply(self):
+        plugin = FakePlugin()
+        reply = await core_commands.run_core_command(plugin, "/biocore_core nope", FakeEvent())
+        self.assertIn("off|shadow|primary", reply)
+        self.assertEqual(plugin.saved, [])
+
+    async def test_non_admin_rejected(self):
+        plugin = FakePlugin()
+        reply = await core_commands.run_core_command(plugin, "/biocore_core primary", NoAdminEvent(admin=False, private=False))
+        self.assertIn("仅管理员可用", reply)
+        self.assertEqual(plugin.saved, [])
+
+    async def test_rollback_command(self):
+        plugin = FakePlugin()
+        plugin.config.update({"core_client_enabled": True, "core_client_mode": "primary"})
+        reply = await core_commands.run_rollback_command(plugin, FakeEvent())
+        self.assertEqual(reply, "已回退旧版引擎（off）")
+        self.assertFalse(plugin.config["core_client_enabled"])
+        self.assertEqual(plugin.config["core_client_mode"], "off")
+
+    async def test_log_via_command(self):
+        plugin = FakePlugin()
+        rec = _Recorder()
+        saved = core_mode.LOGGER
+        core_mode.LOGGER = rec
+        try:
+            await core_commands.run_core_command(plugin, "/biocore_core shadow", FakeEvent())
+        finally:
+            core_mode.LOGGER = saved
+        joined = "\n".join(rec.lines)
+        self.assertIn("core_mode_changed from=off to=shadow via=command", joined)
+
+    async def test_pending_restart_reply(self):
+        plugin = FakePlugin()
+        plugin._rebuild_core_bridge = lambda: False
+        reply = await core_commands.run_core_command(plugin, "/biocore_core primary", FakeEvent())
+        self.assertIn("重启后生效", reply)