dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_proactive_history.py

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+"""Proactive message -> AstrBot conversation history + 3-item [BC] context."""
+import ast
+import asyncio
+import json
+import types
+import unittest
+from pathlib import Path
+
+MAIN = Path(__file__).resolve().parents[2] / "main.py"
+SOURCE = MAIN.read_text(encoding="utf-8")
+
+
+def _load(name):
+    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.FunctionDef, ast.AsyncFunctionDef))
+                and f.name == name)
+    kind = (ast.AsyncFunctionDef if isinstance(node, ast.AsyncFunctionDef)
+            else ast.FunctionDef)
+    clone = kind(name=node.name, args=node.args, body=node.body,
+                 decorator_list=[], returns=node.returns, type_comment=None,
+                 lineno=node.lineno, col_offset=node.col_offset,
+                 end_lineno=node.end_lineno, end_col_offset=node.end_col_offset)
+    ns = {"json": json, "logger": types.SimpleNamespace(
+        info=lambda *a, **k: None, warning=lambda *a, **k: None)}
+    exec(compile(ast.Module(body=[clone], type_ignores=[]), "<h>", "exec"), ns)
+    return ns[name]
+
+
+class FakeCM:
+    def __init__(self):
+        self.history = [{"role": "user", "content": "old"}]
+        self.updated = None
+
+    async def get_curr_conversation_id(self, umo):
+        return "cid-1"
+
+    async def get_conversation(self, umo, cid):
+        return types.SimpleNamespace(history=json.dumps(self.history))
+
+    async def update_conversation(self, umo, cid, history=None, **kwargs):
+        self.updated = list(history or [])
+
+
+class HistoryTest(unittest.IsolatedAsyncioTestCase):
+    async def test_appends_assistant_message(self):
+        cm = FakeCM()
+        plugin = types.SimpleNamespace(
+            context=types.SimpleNamespace(conversation_manager=cm))
+        fn = types.MethodType(_load("_persist_proactive_history"), plugin)
+        ok = await fn("umo-1", "哟，老板！今晚好")
+        self.assertTrue(ok)
+        self.assertEqual(cm.updated[-1]["role"], "assistant")
+        self.assertEqual(cm.updated[-1]["content"], "哟，老板！今晚好")
+        self.assertEqual(cm.updated[0]["content"], "old")
+
+    async def test_no_curr_conversation_is_safe(self):
+        class NoConv:
+            async def get_curr_conversation_id(self, umo):
+                return None
+        plugin = types.SimpleNamespace(
+            context=types.SimpleNamespace(conversation_manager=NoConv()))
+        fn = types.MethodType(_load("_persist_proactive_history"), plugin)
+        self.assertFalse(await fn("umo", "x"))
+
+
+class ContextTest(unittest.TestCase):
+    def test_three_items_in_context(self):
+        plugin = types.SimpleNamespace(
+            _recent_proactive=["甲", "乙", "丙", "丁"],
+            _load_recent_proactive=lambda: ["甲", "乙", "丙", "丁"])
+        fn = _load("_recent_proactive_context")
+        fn = types.MethodType(fn, plugin)
+        text = fn()
+        self.assertIn("乙", text)
+        self.assertIn("丙", text)
+        self.assertIn("丁", text)
+        self.assertNotIn("甲", text)
+
+    def test_ctx_log_and_bc_fallback_wired(self):
+        self.assertIn("[biocore] ctx contexts=%s prompt_len=%s sys_len=%s", SOURCE)
+        self.assertIn("_recent_ctx = self._recent_proactive_context()", SOURCE)
+        self.assertIn("await self._persist_proactive_history(umo, final)", SOURCE)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_proactive_memory.py

@@ -0,0 +1,141 @@
+# -*- coding: utf-8 -*-
+"""B/C: proactive opening de-dup + self-memory (events/prompt/persistence)."""
+import ast
+import tempfile
+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 ui_settings
+
+MAIN = Path(__file__).resolve().parents[2] / "main.py"
+SOURCE = MAIN.read_text(encoding="utf-8")
+
+
+def _load_methods(names):
+    tree = ast.parse(SOURCE)
+    cls = next(n for n in tree.body
+               if isinstance(n, ast.ClassDef) and n.name == "BioCorePlugin")
+    ns = {"time": __import__("time")}
+    fns = {}
+    for node in cls.body:
+        if isinstance(node, ast.FunctionDef) and node.name in names:
+            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=[]), "<pm>", "exec"), ns)
+            fns[node.name] = ns[node.name]
+    return fns
+
+
+FNS = _load_methods(("_load_recent_proactive", "_recent_proactive_prompt",
+                     "_recent_proactive_context", "_opening_key",
+                     "_opening_repeats", "_rewrite_proactive_opening",
+                     "_record_proactive_sent"))
+
+
+class FakePlugin:
+    def __init__(self, tmp):
+        self.data_dir = tmp
+        self._recent_proactive = []
+        self._recent_proactive_loaded = False
+        self.events = []
+        for name in FNS:
+            setattr(self, name, types.MethodType(FNS[name], self))
+
+    def _append_event_archive(self, record):
+        self.events.append(dict(record))
+
+
+class OpeningTest(unittest.TestCase):
+    def test_opening_key_and_repeat(self):
+        plugin = FakePlugin(tempfile.mkdtemp())
+        plugin._recent_proactive = ["哟，老板！今天也来啦"]
+        self.assertTrue(plugin._opening_repeats("哟，老板！今天又来了"))
+        self.assertFalse(plugin._opening_repeats("晚上好，今天忙吗"))
+
+    def test_rewrite_once_changes_opening(self):
+        plugin = FakePlugin(tempfile.mkdtemp())
+        plugin._recent_proactive = ["哟，老板！今天也来啦"]
+        out = plugin._rewrite_proactive_opening("哟，老板！今天又来了")
+        self.assertNotEqual(plugin._opening_key(out),
+                            plugin._opening_key("哟，老板！今天又来了"))
+
+    def test_recent_prompt(self):
+        plugin = FakePlugin(tempfile.mkdtemp())
+        plugin._recent_proactive = ["第一句", "第二句", "第三句", "第四句"]
+        text = plugin._recent_proactive_prompt()
+        self.assertIn("你最近说过", text)
+        self.assertIn("第二句", text)
+        self.assertIn("不要重复以上任何一句的前 6 个字", text)
+
+    def test_no_recent_prompt(self):
+        plugin = FakePlugin(tempfile.mkdtemp())
+        self.assertEqual(plugin._recent_proactive_prompt(), "")
+
+
+class RecordTest(unittest.TestCase):
+    def test_record_event_memory_and_persistence(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            plugin = FakePlugin(tmp)
+            plugin._record_proactive_sent("umo-1", "哟，老板！今晚好",
+                                         reason="lonely")
+            self.assertEqual(plugin.events[0]["type"], "proactive_sent")
+            self.assertEqual(plugin.events[0]["text"], "哟，老板！今晚好")
+            self.assertEqual(plugin.events[0]["umo"], "umo-1")
+            self.assertEqual(len(plugin._recent_proactive), 1)
+            saved = ((ui_settings.load(plugin).get("autonomy") or {})
+                     .get("recent_proactive") or [])
+            self.assertEqual(saved, ["哟，老板！今晚好"])
+
+    def test_recent_capped_five(self):
+        plugin = FakePlugin(tempfile.gettempdir())
+        for i in range(7):
+            plugin._record_proactive_sent("u", "第%d条主动消息" % i)
+        self.assertEqual(len(plugin._recent_proactive), 5)
+        self.assertEqual(plugin._recent_proactive[-1], "第6条主动消息")
+
+    def test_context_last_two(self):
+        plugin = FakePlugin(tempfile.gettempdir())
+        plugin._recent_proactive = ["甲", "乙", "丙", "丁"]
+        ctx = plugin._recent_proactive_context()
+        self.assertIn("我刚说过", ctx)
+        self.assertIn("乙", ctx)
+        self.assertIn("丙", ctx)
+        self.assertIn("丁", ctx)
+        self.assertNotIn("甲", ctx)
+
+
+class PromptInjectionTest(unittest.TestCase):
+    def test_expr_template_recent_block(self):
+        out = et.build_reply(state_ctx={"recent_proactive": "我刚说过：吃了没"})
+        self.assertIn("我刚说过：吃了没", out["user"])
+
+    def test_runtime_enrich_sets_recent(self):
+        plugin = types.SimpleNamespace(_recent_proactive=["甲", "乙", "丙"])
+        core = types.SimpleNamespace(snapshot=lambda: {"v": 0.0})
+        ctx = rt.enrich_ctx({"plugin": plugin, "core": core,
+                             "user": {}, "meta": {}})
+        self.assertIn("我刚说过", ctx.get("recent_proactive", ""))
+        self.assertIn("乙", ctx["recent_proactive"])
+
+
+class UntouchedCooldownTest(unittest.TestCase):
+    def test_apply_params_force_writes_cooldown(self):
+        self.assertIn('("cooldown_seconds", "cooldown_s", 1800)', SOURCE)
+        self.assertNotIn("if key not in out:", SOURCE)
+
+    def test_wiring_static(self):
+        self.assertIn("_recent_proactive_prompt()", SOURCE)
+        self.assertIn("_opening_repeats(final)", SOURCE)
+        self.assertIn("_record_proactive_sent(", SOURCE)
+        self.assertIn("proactive_sent", SOURCE)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_proactive_send_record.py

@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+"""Regression: proactive _send must record with event=None and never NameError."""
+import ast
+import asyncio
+import types
+import unittest
+from pathlib import Path
+
+MAIN = Path(__file__).resolve().parents[2] / "main.py"
+
+
+def _load_send():
+    tree = ast.parse(MAIN.read_text(encoding="utf-8"))
+    node = next((n for n in ast.walk(tree)
+                 if isinstance(n, ast.AsyncFunctionDef) and n.name == "_send"), None)
+    assert node is not None, "_send closure not found"
+    return node
+
+
+class FakeTarget:
+    sent = []
+
+    def __init__(self, plugin, umo, private=True):
+        self.plugin = plugin
+        self.umo = umo
+
+    async def send(self, chain):
+        FakeTarget.sent.append((self.umo, chain))
+
+
+class SendRecordTest(unittest.IsolatedAsyncioTestCase):
+    def _run_send(self, recorder):
+        FakeTarget.sent = []
+        warnings = []
+        logger = types.SimpleNamespace(
+            warning=lambda *a, **k: warnings.append(a),
+            info=lambda *a, **k: None)
+        async def _persist_history(umo, text):
+            return True
+        plugin = types.SimpleNamespace(
+            proactive_llm_enabled=False,
+            _persist_proactive_history=_persist_history,
+            _sanitize_proactive_text=lambda text, cap=0: str(text or ""),
+            _opening_repeats=lambda text: False,
+            _record_proactive_sent=recorder)
+        ns = {
+            "self": plugin,
+            "text": "哟，老板！今晚好",
+            "umo": "umo-1",
+            "_built": {"prompt": "", "system": "", "max_chars": 0,
+                       "reason": "lonely"},
+            "_AutonomySendTarget": FakeTarget,
+            "MessageChain": lambda parts: list(parts),
+            "Plain": lambda text: ("plain", text),
+            "logger": logger,
+        }
+        node = _load_send()
+        exec(compile(ast.Module(body=[node], type_ignores=[]), "<send>", "exec"), ns)
+        return ns["_send"], warnings
+
+    async def test_record_called_once_with_event_none(self):
+        calls = []
+
+        def recorder(umo, text, reason="", event=None):
+            calls.append({"umo": umo, "text": text, "reason": reason,
+                          "event": event})
+        send, warnings = self._run_send(recorder)
+        await send()
+        self.assertEqual(len(FakeTarget.sent), 1)
+        self.assertEqual(len(calls), 1)
+        self.assertEqual(calls[0]["umo"], "umo-1")
+        self.assertEqual(calls[0]["text"], "哟，老板！今晚好")
+        self.assertEqual(calls[0]["reason"], "lonely")
+        self.assertIsNone(calls[0]["event"])
+        self.assertEqual(warnings, [])
+
+    async def test_record_exception_is_swallowed_after_send(self):
+        def recorder(*args, **kwargs):
+            raise RuntimeError("record boom")
+        send, warnings = self._run_send(recorder)
+        await send()
+        self.assertEqual(len(FakeTarget.sent), 1)
+        self.assertTrue(any("proactive record failed" in str(args)
+                            for args in warnings))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_probe_contract.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+import json
+import unittest
+
+from biocore_model import appraisal
+
+
+def _raw(**extra):
+    data = {"dims": {"goal": 0.2, "blame": 0.1, "control": 0.5,
+                     "certainty": 0.5, "novelty": 0.2, "involve": 0.6,
+                     "hit": 0.1},
+            "why": "test", "c": 0.8}
+    data.update(extra)
+    return json.dumps(data, ensure_ascii=False)
+
+
+class ProbeContractTest(unittest.TestCase):
+    def test_prompt_declares_situation_and_fact(self):
+        prompt = appraisal.build_prompt("在吗", "在的")
+        for token in ("situation", "challenge", "praise", "hurt", "fact",
+                      "≤20 字"):
+            self.assertIn(token, prompt)
+        self.assertIn("对方：在吗", prompt)
+        self.assertIn("你：在的", prompt)
+
+    def test_parse_situation_numbers(self):
+        out = appraisal.parse(_raw(situation={"challenge": 0.6,
+                                           "praise": 0.1, "hurt": 0.0}))
+        self.assertEqual(out["situation"]["challenge"], 0.6)
+        self.assertEqual(out["situation"]["praise"], 0.1)
+        self.assertEqual(out["situation"]["hurt"], 0.0)
+        self.assertEqual(out["dims"]["goal"], 0.2)
+
+    def test_parse_clamps_situation_range(self):
+        out = appraisal.parse(_raw(situation={"challenge": 2.0,
+                                           "praise": -1.0, "hurt": 0.4}))
+        self.assertEqual(out["situation"]["challenge"], 1.0)
+        self.assertEqual(out["situation"]["praise"], 0.0)
+        self.assertEqual(out["situation"]["hurt"], 0.4)
+
+    def test_parse_fact_short_kept(self):
+        out = appraisal.parse(_raw(fact="他姓王"))
+        self.assertEqual(out["fact"], "他姓王")
+
+    def test_parse_fact_truncated_to_limit(self):
+        out = appraisal.parse(_raw(fact="他" * 40))
+        self.assertEqual(len(out["fact"]), appraisal.FACT_MAX_CHARS)
+
+    def test_parse_missing_optional_fields(self):
+        out = appraisal.parse(_raw())
+        self.assertEqual(out["situation"], {})
+        self.assertEqual(out["fact"], "")
+
+    def test_parse_low_confidence_drops_everything(self):
+        raw = json.dumps({"dims": {"goal": 0.5}, "c": 0.2,
+                          "situation": {"challenge": 0.9},
+                          "fact": "他姓王"}, ensure_ascii=False)
+        self.assertEqual(appraisal.parse(raw), {})
+
+    def test_parse_malformed_situation_is_safe(self):
+        out = appraisal.parse(_raw(situation={"challenge": "高",
+                                           "praise": None, "hurt": 0.3}))
+        self.assertNotIn("challenge", out["situation"])
+        self.assertNotIn("praise", out["situation"])
+        self.assertEqual(out["situation"]["hurt"], 0.3)
+        out2 = appraisal.parse(_raw(situation=["challenge"]))
+        self.assertEqual(out2["situation"], {})
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_prospective.py

@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+"""Prospective memory: registration, due queries, overdue, dedup."""
+import unittest
+
+from biocore_model import prospective as pm
+
+NOW = 1790000000.0
+DAY = 86400.0
+
+class NormalizeTest(unittest.TestCase):
+    def test_strips_punctuation_and_space(self):
+        self.assertEqual(pm.normalize("  明天 问你，结果！ "), "明天问你结果")
+
+    def test_none_is_empty(self):
+        self.assertEqual(pm.normalize(None), "")
+
+class IdTest(unittest.TestCase):
+    def test_same_text_same_id(self):
+        a = pm.make_id("her_promise", "问他体检结果", NOW)
+        b = pm.make_id("her_promise", "问他体检结果！", NOW + 3600)
+        self.assertEqual(a, b)
+
+    def test_reschedule_keeps_id(self):
+        a = pm.make_id("her_promise", "问他体检结果", NOW)
+        b = pm.make_id("her_promise", "问他体检结果", NOW + 7 * DAY)
+        self.assertEqual(a, b)
+
+    def test_kind_changes_id(self):
+        a = pm.make_id("her_promise", "体检", NOW)
+        b = pm.make_id("his_event", "体检", NOW)
+        self.assertNotEqual(a, b)
+
+class EntryTest(unittest.TestCase):
+    def test_fields(self):
+        row = pm.entry("his_event", "周五体检", NOW + 2 * DAY, now=NOW)
+        self.assertEqual(row["kind"], "his_event")
+        self.assertEqual(row["status"], "pending")
+        self.assertEqual(row["due_ts"], NOW + 2 * DAY)
+        self.assertEqual(row["created_ts"], NOW)
+        self.assertTrue(row["id"])
+
+    def test_text_truncated(self):
+        row = pm.entry("his_event", "x" * 200, NOW)
+        self.assertEqual(len(row["text"]), 80)
+
+class AddTest(unittest.TestCase):
+    def test_add_new(self):
+        row = pm.entry("his_event", "周五体检", NOW + DAY, now=NOW)
+        store, changed = pm.add([], row)
+        self.assertTrue(changed)
+        self.assertEqual(len(store), 1)
+
+    def test_duplicate_refreshes_due(self):
+        row = pm.entry("his_event", "周五体检", NOW + DAY, now=NOW)
+        store, _ = pm.add([], row)
+        later = pm.entry("his_event", "周五体检", NOW + 2 * DAY, now=NOW)
+        store, changed = pm.add(store, later)
+        self.assertTrue(changed)
+        self.assertEqual(len(store), 1)
+        self.assertEqual(store[0]["due_ts"], NOW + 2 * DAY)
+
+    def test_duplicate_done_stays_done(self):
+        row = pm.entry("his_event", "周五体检", NOW + DAY, now=NOW)
+        store, _ = pm.add([], row)
+        store, _ = pm.resolve(store, row["id"], "done", now=NOW)
+        again = pm.entry("his_event", "周五体检", NOW + DAY, now=NOW)
+        store, changed = pm.add(store, again)
+        self.assertFalse(changed)
+        self.assertEqual(store[0]["status"], "done")
+
+    def test_bad_record_ignored(self):
+        store, changed = pm.add([], {"text": "没有 id"})
+        self.assertFalse(changed)
+        self.assertEqual(store, [])
+
+class DueTest(unittest.TestCase):
+    def _store(self):
+        rows = [pm.entry("his_event", "早上的事", NOW - 3 * 3600, now=NOW),
+                pm.entry("her_promise", "刚到期", NOW, now=NOW),
+                pm.entry("his_event", "明天的事", NOW + DAY, now=NOW)]
+        store = []
+        for row in rows:
+            store, _ = pm.add(store, row)
+        return store
+
+    def test_due_now_with_window(self):
+        rows = pm.due_now(self._store(), NOW, window_s=4 * 3600)
+        self.assertEqual([row["text"] for row in rows], ["早上的事", "刚到期"])
+
+    def test_due_now_without_window(self):
+        rows = pm.due_now(self._store(), NOW)
+        self.assertEqual([row["text"] for row in rows], ["刚到期"])
+
+    def test_due_soon(self):
+        rows = pm.due_soon(self._store(), NOW, ahead_s=2 * DAY)
+        self.assertEqual([row["text"] for row in rows], ["明天的事"])
+
+class OverdueTest(unittest.TestCase):
+    def test_marks_after_grace(self):
+        row = pm.entry("his_event", "昨天的事", NOW - DAY, now=NOW - DAY)
+        store, _ = pm.add([], row)
+        store, changed = pm.mark_overdue(store, NOW)
+        self.assertEqual(changed, 1)
+        self.assertEqual(store[0]["status"], "overdue")
+
+    def test_not_early(self):
+        row = pm.entry("his_event", "刚到期", NOW, now=NOW)
+        store, _ = pm.add([], row)
+        store, changed = pm.mark_overdue(store, NOW + 60)
+        self.assertEqual(changed, 0)
+
+class ResolveTest(unittest.TestCase):
+    def test_done(self):
+        row = pm.entry("his_event", "周五体检", NOW + DAY, now=NOW)
+        store, _ = pm.add([], row)
+        store, changed = pm.resolve(store, row["id"], "done", now=NOW)
+        self.assertTrue(changed)
+        self.assertEqual(store[0]["status"], "done")
+
+    def test_invalid_status_noop(self):
+        row = pm.entry("his_event", "周五体检", NOW + DAY, now=NOW)
+        store, _ = pm.add([], row)
+        store, changed = pm.resolve(store, row["id"], "weird")
+        self.assertFalse(changed)
+        self.assertEqual(store[0]["status"], "pending")
+
+class HintTest(unittest.TestCase):
+    def test_pending_hint(self):
+        row = pm.entry("his_event", "周五体检", NOW + DAY, now=NOW)
+        self.assertEqual(pm.build_hint(row, NOW), "他提过的事到了：周五体检")
+
+    def test_overdue_hint(self):
+        row = pm.entry("her_promise", "问他结果", NOW - DAY, now=NOW - DAY)
+        self.assertIn("还没问", pm.build_hint(row, NOW))
+
+    def test_empty_text(self):
+        self.assertEqual(pm.build_hint({"kind": "his_event", "text": ""}), "")
+
+class StatsTest(unittest.TestCase):
+    def test_counts(self):
+        store = []
+        for kind, text, due in (("his_event", "a", NOW), ("her_promise", "b", NOW),
+                                ("his_event", "c", NOW)):
+            store, _ = pm.add(store, pm.entry(kind, text, due, now=NOW))
+        out = pm.stats(store)
+        self.assertEqual(out["total"], 3)
+        self.assertEqual(out["by_kind"]["his_event"], 2)
+        self.assertEqual(out["by_kind"]["her_promise"], 1)
+
+    def test_malformed_store(self):
+        self.assertEqual(pm.stats([None, "x", 3])["total"], 0)
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_provider_fallback.py

@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*-
+"""task-127: fallback ordering/cooldown tests."""
+import unittest
+from pathlib import Path
+
+from biocore_model import provider_fallback as pf
+
+REPO = Path(__file__).resolve().parents[2]
+
+
+class CandidatesTest(unittest.TestCase):
+    def test_primary_only_when_fallback_empty(self):
+        self.assertEqual(pf.candidates("main", [], {}, 1000.0), ["main"])
+        self.assertEqual(pf.candidates("main", None, {}, 1000.0), ["main"])
+
+    def test_order_primary_then_fallbacks(self):
+        out = pf.candidates("main", ["backup1", "backup2"], {}, 1000.0)
+        self.assertEqual(out, ["main", "backup1", "backup2"])
+
+    def test_dedupes_and_cleans_ids(self):
+        out = pf.candidates(" main ", ["main", "backup1", " ", None, "backup1"],
+                            {}, 1000.0)
+        self.assertEqual(out, ["main", "backup1"])
+
+    def test_primary_none_uses_fallbacks(self):
+        self.assertEqual(pf.candidates(None, ["backup1"], {}, 1000.0),
+                         ["backup1"])
+
+    def test_cooling_provider_skipped(self):
+        state = {"main": 995.0}
+        self.assertEqual(pf.candidates("main", ["backup1"], state, 1000.0),
+                         ["backup1"])
+
+    def test_cooldown_expires(self):
+        state = {"main": 900.0}
+        self.assertEqual(pf.candidates("main", ["backup1"], state, 1000.0),
+                         ["main", "backup1"])
+
+    def test_all_cooling_returns_empty(self):
+        state = {"main": 999.0, "backup1": 998.0}
+        self.assertEqual(pf.candidates("main", ["backup1"], state, 1000.0), [],
+                         msg="every candidate cooling")
+
+    def test_custom_cooldown(self):
+        state = {"main": 800.0}
+        self.assertEqual(pf.candidates("main", [], state, 1000.0, cooldown=300),
+                         [])
+        self.assertEqual(pf.candidates("main", [], state, 1000.0, cooldown=60),
+                         ["main"])
+
+
+class StateTest(unittest.TestCase):
+    def test_mark_failure_copies_state(self):
+        state = {}
+        out = pf.mark_failure(state, "backup1", 123.0)
+        self.assertEqual(out["backup1"], 123.0)
+        self.assertEqual(state, {})
+
+    def test_mark_success_records_current_and_clears_cooldown(self):
+        state = {"main": 100.0, "backup1": 101.0}
+        out = pf.mark_success(state, "backup1", 200.0)
+        self.assertNotIn("backup1", out)
+        self.assertEqual(pf.current(out), "backup1")
+        self.assertEqual(out["main"], 100.0)
+        self.assertEqual(state["backup1"], 101.0)
+
+    def test_reserved_keys_never_become_candidates(self):
+        state = pf.mark_success({}, "backup1", 10.0)
+        self.assertEqual(pf.candidates("main", ["current"], state, 20.0),
+                         ["main"])
+        self.assertFalse(pf.is_cooling(state, "current", 20.0))
+
+    def test_describe(self):
+        state = {"main": 100.0}
+        self.assertEqual(pf.describe(state), "failed=main")
+        state = pf.mark_success(state, "backup1", 200.0)
+        self.assertIn("current=backup1", pf.describe(state))
+
+
+class WiringStaticTest(unittest.TestCase):
+    def test_main_has_fallback_wiring(self):
+        source = (REPO / "main.py").read_text(encoding="utf-8")
+        self.assertIn("provider_fallback_order", source)
+        self.assertIn("[biocore] provider fallback from=%s to=%s reason=%s", source)
+        self.assertIn("provider_fallback as _pf", source)
+
+
+if __name__ == "__main__":
+    unittest.main()