dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_embedding_modes.py

@@ -0,0 +1,342 @@
+# -*- coding: utf-8 -*-
+"""task-199 通用 embedding provider 单测。
+
+覆盖四种模式（off / remote / local / remote_with_local_fallback）、通用
+OpenAI 兼容请求体与鉴权头、超时、维度校验与降级、off 无 IO、旧键兼容。
+用 stub 取代真实网络与本地模型，不需要 onnxruntime。
+"""
+import json
+import os
+import unittest
+from unittest import mock
+
+from biocore_memory.recall import embedding as emb
+
+ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+ENV_KEYS = (
+    "BIOCORE_EMBEDDING_MODE", "BIOCORE_EMBEDDING_BASE_URL",
+    "BIOCORE_EMBEDDING_KEY", "BIOCORE_EMBEDDING_MODEL",
+    "BIOCORE_EMBEDDING_DIM", "BIOCORE_EMBEDDING_TIMEOUT",
+    "BIOCORE_EMBEDDING_LOCAL_MODEL", "BIOCORE_EMBEDDING_LOCAL_FALLBACK",
+    "BIOCORE_EMBEDDING_LOCAL_TOKENIZER", "BIOCORE_EMBEDDING_LOCAL_THREADS",
+)
+
+
+class FakeResponse:
+    def __init__(self, payload):
+        self._data = json.dumps(payload).encode("utf-8")
+        self.closed = False
+
+    def read(self):
+        return self._data
+
+    def close(self):
+        self.closed = True
+
+
+def payload(vector, model="m"):
+    return {"data": [{"embedding": list(vector)}], "model": model}
+
+
+class StubLocal:
+    def __init__(self, vector=None, dim=4, fail=False):
+        self.vector = list(vector if vector is not None else [1.0, 0.0, 0.0, 0.0])
+        self.dim = int(dim)
+        self.fail = bool(fail)
+        self.calls = 0
+        self.model_path = "stub.onnx"
+        self.tokenizer_path = ""
+        self.threads = 2
+
+    def encode(self, texts):
+        self.calls += 1
+        if self.fail:
+            raise RuntimeError("local boom")
+        return [list(self.vector) for _ in texts]
+
+
+class EnvIsolated(unittest.TestCase):
+    def setUp(self):
+        self._env = mock.patch.dict(os.environ, {key: "" for key in ENV_KEYS},
+                                    clear=False)
+        self._env.start()
+        emb._LOCAL_WARNED.clear()
+
+    def tearDown(self):
+        emb._LOCAL_WARNED.clear()
+        self._env.stop()
+
+
+class ModeDispatchTest(EnvIsolated):
+    def test_off_mode_returns_none_without_network_or_local_load(self):
+        with mock.patch("urllib.request.urlopen",
+                        side_effect=AssertionError("no network")), \
+                mock.patch.object(emb, "_load_local_embedder",
+                                  side_effect=AssertionError("no local load")):
+            provider = emb.load_provider({
+                "embedding_mode": "off",
+                "embedding_base_url": "https://api.example.com/v1",
+                "embedding_model": "bge-m3",
+                "embedding_local_model_path": "stub.onnx",
+            })
+        self.assertIsNone(provider)
+
+    def test_unknown_mode_behaves_like_off(self):
+        with mock.patch("urllib.request.urlopen") as urlopen, \
+                mock.patch.object(emb, "_load_local_embedder") as loader:
+            self.assertIsNone(emb.load_provider({
+                "embedding_mode": "wired-mode",
+                "embedding_base_url": "https://api.example.com/v1",
+                "embedding_model": "m",
+                "embedding_local_model_path": "stub.onnx",
+            }))
+        self.assertFalse(urlopen.called)
+        self.assertFalse(loader.called)
+
+    def test_legacy_config_without_mode_stays_remote(self):
+        provider = emb.load_provider({
+            "base_url": "http://127.0.0.1:9/v1", "model": "legacy-model"})
+        self.assertIsNotNone(provider)
+        self.assertEqual(provider.mode, "remote")
+        self.assertEqual(provider.endpoint, "http://127.0.0.1:9/v1/embeddings")
+        self.assertEqual(provider.dim, 0)
+
+    def test_legacy_local_only_config_still_loads(self):
+        stub = StubLocal()
+        with mock.patch.object(emb, "_load_local_embedder", return_value=stub):
+            provider = emb.load_provider({
+                "embedding_local_fallback_enabled": True,
+                "embedding_local_model_path": "stub.onnx",
+            })
+        self.assertIsNotNone(provider)
+        self.assertTrue(provider.local_only)
+        self.assertEqual(emb.local_embedding_status(provider), "ok")
+
+    def test_mode_aliases_are_accepted(self):
+        with mock.patch.object(emb, "_load_local_embedder", return_value=StubLocal()):
+            provider = emb.load_provider({
+                "embedding_mode": "local_onnx",
+                "embedding_local_model_path": "stub.onnx",
+            })
+        self.assertIsNotNone(provider)
+        self.assertEqual(provider.mode, "local")
+        remote = emb.load_provider({
+            "embedding_mode": "remote_generic",
+            "embedding_base_url": "https://api.example.com/v1",
+            "embedding_model": "m",
+        })
+        self.assertIsNotNone(remote)
+        self.assertEqual(remote.mode, "remote")
+
+
+class RemoteGenericModeTest(EnvIsolated):
+    def _provider(self, **extra):
+        cfg = {"embedding_mode": "remote",
+               "embedding_base_url": "https://api.example.com/v1",
+               "embedding_model": "bge-m3"}
+        cfg.update(extra)
+        return emb.load_provider(cfg)
+
+    def test_remote_request_is_generic_openai_compatible(self):
+        provider = self._provider(embedding_api_key="sk-test")
+        self.assertIsNotNone(provider)
+        with mock.patch("urllib.request.urlopen",
+                        return_value=FakeResponse(payload([1.0, 0.0, 0.0, 0.0]))) as urlopen:
+            vector = provider.embed_text("  你好  世界 ")
+        self.assertEqual(vector, [1.0, 0.0, 0.0, 0.0])
+        request = urlopen.call_args[0][0]
+        self.assertEqual(request.full_url, "https://api.example.com/v1/embeddings")
+        body = json.loads(request.data.decode("utf-8"))
+        self.assertEqual(body["model"], "bge-m3")
+        self.assertEqual(body["input"], ["你好 世界"])
+        self.assertEqual(body["encoding_format"], "float")
+        headers = {key.lower(): value for key, value in request.headers.items()}
+        self.assertEqual(headers.get("authorization"), "Bearer sk-test")
+        self.assertEqual(urlopen.call_args.kwargs.get("timeout"), emb.DEFAULT_TIMEOUT)
+
+    def test_remote_without_key_sends_no_authorization_header(self):
+        provider = self._provider()
+        with mock.patch("urllib.request.urlopen",
+                        return_value=FakeResponse(payload([1.0, 0.0]))) as urlopen:
+            provider.embed_text("hi")
+        request = urlopen.call_args[0][0]
+        headers = {key.lower(): value for key, value in request.headers.items()}
+        self.assertNotIn("authorization", headers)
+
+    def test_base_url_already_ending_in_embeddings_is_not_duplicated(self):
+        provider = self._provider(
+            embedding_base_url="https://gateway.example.com/v1/embeddings")
+        self.assertEqual(provider.endpoint,
+                         "https://gateway.example.com/v1/embeddings")
+
+    def test_timeout_from_seconds_and_from_milliseconds(self):
+        provider = self._provider(embedding_timeout_s=2.5)
+        self.assertAlmostEqual(provider.timeout, 2.5)
+        with mock.patch("urllib.request.urlopen",
+                        return_value=FakeResponse(payload([1.0]))) as urlopen:
+            provider.embed_text("hi")
+        self.assertAlmostEqual(urlopen.call_args.kwargs.get("timeout"), 2.5)
+        provider_ms = self._provider(embedding_timeout_ms=1500)
+        self.assertAlmostEqual(provider_ms.timeout, 1.5)
+
+    def test_dim_match_accepts_vector(self):
+        provider = self._provider(embedding_dim=4)
+        with mock.patch("urllib.request.urlopen",
+                        return_value=FakeResponse(payload([0.1, 0.2, 0.3, 0.4]))):
+            self.assertEqual(provider.embed_text("hi"), [0.1, 0.2, 0.3, 0.4])
+
+    def test_dim_mismatch_degrades_to_no_vector(self):
+        provider = self._provider(embedding_dim=8)
+        with mock.patch("urllib.request.urlopen",
+                        return_value=FakeResponse(payload([1.0, 0.0, 0.0, 0.0]))):
+            with self.assertRaises(ValueError):
+                provider.embed_text("hi")
+            self.assertIsNone(emb.embed("hi", provider))
+
+    def test_remote_missing_base_or_model_returns_none(self):
+        self.assertIsNone(emb.load_provider({"embedding_mode": "remote"}))
+        self.assertIsNone(emb.load_provider({
+            "embedding_mode": "remote",
+            "embedding_base_url": "https://api.example.com/v1"}))
+        self.assertIsNone(emb.load_provider({
+            "embedding_mode": "remote", "embedding_model": "m"}))
+
+
+class LocalModeTest(EnvIsolated):
+    def test_local_mode_uses_local_embedder_without_network(self):
+        stub = StubLocal(dim=4)
+        with mock.patch.object(emb, "_load_local_embedder",
+                               return_value=stub) as loader, \
+                mock.patch("urllib.request.urlopen") as urlopen:
+            provider = emb.load_provider({
+                "embedding_mode": "local",
+                "embedding_local_model_path": "stub.onnx",
+            })
+            self.assertIsNotNone(provider)
+            self.assertEqual(provider.mode, "local")
+            vector = emb.embed("你好", provider)
+        self.assertEqual(vector, [1.0, 0.0, 0.0, 0.0])
+        self.assertEqual(stub.calls, 1)
+        self.assertTrue(loader.called)
+        self.assertFalse(urlopen.called)
+
+    def test_local_mode_without_model_path_returns_none(self):
+        with mock.patch.object(emb, "_load_local_embedder") as loader:
+            self.assertIsNone(emb.load_provider({"embedding_mode": "local"}))
+        self.assertFalse(loader.called)
+
+    def test_local_mode_load_failure_returns_none(self):
+        with mock.patch.object(emb, "_load_local_embedder", return_value=False):
+            self.assertIsNone(emb.load_provider({
+                "embedding_mode": "local",
+                "embedding_local_model_path": "missing.onnx",
+            }))
+
+    def test_local_mode_dim_mismatch_degrades(self):
+        stub = StubLocal(dim=4, vector=[1.0, 0.0, 0.0])
+        with mock.patch.object(emb, "_load_local_embedder", return_value=stub):
+            provider = emb.load_provider({
+                "embedding_mode": "local",
+                "embedding_local_model_path": "stub.onnx",
+                "embedding_dim": 4,
+            })
+        self.assertIsNone(emb.embed("你好", provider))
+
+    def test_local_mode_keeps_legacy_local_keys(self):
+        captured = {}
+
+        def fake_load(cfg):
+            captured.update(cfg)
+            return StubLocal(dim=4)
+
+        with mock.patch.object(emb, "_load_local_embedder", side_effect=fake_load):
+            provider = emb.load_provider({
+                "embedding_mode": "local",
+                "embedding_local_model_path": "stub.onnx",
+                "embedding_local_tokenizer_path": "tok",
+                "embedding_local_threads": 3,
+            })
+        self.assertIsNotNone(provider)
+        self.assertEqual(captured.get("model_path"), "stub.onnx")
+        self.assertEqual(captured.get("tokenizer_path"), "tok")
+        self.assertEqual(captured.get("threads"), 3)
+
+
+class FallbackModeTest(EnvIsolated):
+    def _config(self, **extra):
+        cfg = {"embedding_mode": "remote_with_local_fallback",
+               "embedding_base_url": "https://api.example.com/v1",
+               "embedding_model": "m",
+               "embedding_local_model_path": "stub.onnx"}
+        cfg.update(extra)
+        return cfg
+
+    def test_fallback_remote_success_skips_local(self):
+        stub = StubLocal(dim=4)
+        with mock.patch.object(emb, "_load_local_embedder", return_value=stub):
+            provider = emb.load_provider(self._config())
+        with mock.patch("urllib.request.urlopen",
+                        return_value=FakeResponse(payload([0.0, 1.0, 0.0, 0.0]))):
+            vector = emb.embed("你好", provider)
+        self.assertEqual(vector, [0.0, 1.0, 0.0, 0.0])
+        self.assertEqual(stub.calls, 0)
+
+    def test_fallback_remote_failure_uses_local(self):
+        stub = StubLocal(dim=4)
+        with mock.patch.object(emb, "_load_local_embedder", return_value=stub):
+            provider = emb.load_provider(self._config())
+        with mock.patch("urllib.request.urlopen", side_effect=OSError("remote down")):
+            vector = emb.embed("你好", provider)
+        self.assertEqual(vector, [1.0, 0.0, 0.0, 0.0])
+        self.assertEqual(stub.calls, 1)
+
+    def test_fallback_dim_mismatch_uses_local(self):
+        stub = StubLocal(dim=8, vector=[1.0] + [0.0] * 7)
+        with mock.patch.object(emb, "_load_local_embedder", return_value=stub):
+            provider = emb.load_provider(self._config(embedding_dim=8))
+        with mock.patch("urllib.request.urlopen",
+                        return_value=FakeResponse(payload([1.0, 0.0, 0.0, 0.0]))):
+            vector = emb.embed("你好", provider)
+        self.assertEqual(vector, [1.0] + [0.0] * 7)
+        self.assertEqual(stub.calls, 1)
+
+    def test_fallback_without_remote_uses_local_only(self):
+        stub = StubLocal(dim=4)
+        with mock.patch.object(emb, "_load_local_embedder", return_value=stub):
+            provider = emb.load_provider({
+                "embedding_mode": "remote_with_local_fallback",
+                "embedding_local_model_path": "stub.onnx",
+            })
+        self.assertIsNotNone(provider)
+        self.assertTrue(provider.local_only)
+        self.assertEqual(emb.embed("你好", provider), [1.0, 0.0, 0.0, 0.0])
+
+    def test_fallback_without_local_path_is_disabled(self):
+        provider = emb.load_provider({
+            "embedding_mode": "remote_with_local_fallback",
+            "embedding_base_url": "https://api.example.com/v1",
+            "embedding_model": "m",
+        })
+        self.assertIsNotNone(provider)
+        self.assertFalse(provider.fallback_config["enabled"])
+
+
+class SchemaDefaultsTest(unittest.TestCase):
+    def test_new_keys_exist_and_mode_defaults_auto(self):
+        with open(os.path.join(ROOT, "_conf_schema.json"),
+                  encoding="utf-8-sig") as handle:
+            schema = json.loads(handle.read())
+        mode = schema["embedding_mode"]
+        self.assertEqual(mode["default"], "auto")
+        self.assertEqual(set(mode["options"]),
+                         {"auto", "off", "remote", "local",
+                          "remote_with_local_fallback"})
+        for key in ("embedding_base_url", "embedding_model",
+                    "embedding_api_key"):
+            self.assertIn(key, schema)
+            self.assertEqual(schema[key]["default"], "")
+        self.assertEqual(schema["embedding_dim"]["default"], 0)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_emotion_geometry.py

@@ -0,0 +1,114 @@
+# -*- coding: utf-8 -*-
+"""Emotion geometry tests: prototypes, mixed distributions, tone mixing."""
+import unittest
+
+from biocore_model import emotion_geometry as eg
+from biocore_model import expr_tone as et
+from biocore_model import stages as st
+
+
+def core_state(proto):
+    state = {"v": proto.get("v", 0.0)}
+    for name in ("a", "d", "social", "stress", "trust"):
+        if name in proto:
+            state[name] = (float(proto[name]) + 1.0) / 2.0
+    return state
+
+
+class PrototypeTest(unittest.TestCase):
+    def test_each_prototype_wins(self):
+        for label, proto in eg.PROTOTYPES.items():
+            out = eg.classify(core_state(proto))
+            self.assertEqual(out["label"], label, label)
+            self.assertGreater(out["probs"][label], 0.5, label)
+
+    def test_probs_sum_to_one(self):
+        out = eg.classify(core_state(eg.PROTOTYPES["joy"]))
+        self.assertAlmostEqual(sum(out["probs"].values()), 1.0, places=3)
+
+    def test_mixed_state_has_low_confidence(self):
+        a = core_state(eg.PROTOTYPES["sadness"])
+        b = core_state(eg.PROTOTYPES["anger"])
+        mixed = {key: (a.get(key, 0.5) + b.get(key, 0.5)) / 2.0 for key in a}
+        out = eg.classify(mixed)
+        single = eg.classify(a)
+        self.assertLess(out["confidence"], single["confidence"])
+        self.assertLess(out["probs"][out["label"]], 0.8)
+
+    def test_missing_dimensions_do_not_crash_and_lower_confidence(self):
+        full = eg.classify(core_state(eg.PROTOTYPES["joy"]))
+        partial = eg.classify({"v": 0.7, "a": 0.7})
+        self.assertIn(partial["label"], eg.LABELS)
+        self.assertLess(partial["confidence"], full["confidence"])
+
+    def test_temperature_changes_entropy(self):
+        state = core_state(eg.PROTOTYPES["fear"])
+        cold = eg.classify(state, temperature=0.08)
+        hot = eg.classify(state, temperature=0.8)
+        self.assertLess(eg.entropy(cold["probs"]), eg.entropy(hot["probs"]))
+        self.assertGreaterEqual(cold["probs"][cold["label"]],
+                                hot["probs"][hot["label"]])
+
+    def test_confidence_and_prob_bounds(self):
+        out = eg.classify({"v": 0.0, "a": 0.5, "d": 0.5})
+        self.assertGreaterEqual(out["confidence"], 0.0)
+        self.assertLessEqual(out["confidence"], 1.0)
+        for prob in out["probs"].values():
+            self.assertGreaterEqual(prob, 0.0)
+            self.assertLessEqual(prob, 1.0)
+
+    def test_single_prototype_has_low_entropy(self):
+        out = eg.classify(core_state(eg.PROTOTYPES["joy"]))
+        self.assertLess(eg.entropy(out["probs"]), 2.0)
+
+    def test_top2_structure(self):
+        out = eg.classify(core_state(eg.PROTOTYPES["trust"]))
+        self.assertEqual(len(out["top2"]), 2)
+        self.assertIn("label", out["top2"][0])
+        self.assertEqual(eg.top_probs(out, 3)[0]["label"], out["label"])
+
+
+class ToneTest(unittest.TestCase):
+    def test_no_probs_is_backward_compatible(self):
+        old = et.tone_block("sadness", emotion="sadness", intensity=0.6,
+                            self_esteem=0.6)
+        self.assertEqual(old["tendency"], "sadness")
+        self.assertIn("少说两句", old["text"])
+        self.assertFalse(old["mixed"])
+
+    def test_single_distribution_keeps_tendency(self):
+        probs = {"joy": 0.8, "trust": 0.1, "sadness": 0.05,
+                 "anger": 0.02, "fear": 0.02, "loneliness": 0.01}
+        out = et.tone_block("", probs=probs)
+        self.assertEqual(out["tendency"], "joy")
+        self.assertIn("分享", out["text"])
+
+    def test_mixed_distribution_uses_mixed_branch(self):
+        probs = {"sadness": 0.36, "anger": 0.33, "fear": 0.12,
+                 "joy": 0.08, "loneliness": 0.07, "trust": 0.04}
+        out = et.tone_block("", probs=probs)
+        self.assertTrue(out["mixed"])
+        self.assertEqual(out["tendency"], "mixed")
+        self.assertIn("混合情绪", out["text"])
+        for token in ("轻", "慢", "留点空白"):
+            self.assertIn(token, out["text"])
+
+    def test_tone_stage_attaches_distribution(self):
+        ctx = {"state": core_state(eg.PROTOTYPES["joy"]),
+               "meta": {"template_opts": {}}}
+        out = st.expr_tone().run(ctx)
+        self.assertIn("dist", out["meta"]["expr_tone"])
+        self.assertIn("top1", out["meta"]["expr_tone"])
+
+
+class WiringStaticTest(unittest.TestCase):
+    def test_page_debug_exposes_emotion_dist(self):
+        from pathlib import Path
+        source = (Path(__file__).resolve().parents[2] / "main.py").read_text(
+            encoding="utf-8")
+        self.assertIn("emotion_geometry", source)
+        self.assertIn("emotion_dist", source)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_emotion_probe.py

@@ -0,0 +1,214 @@
+# -*- coding: utf-8 -*-
+"""Emotion probe tests: model-chosen deltas, protections, feedback integration."""
+import asyncio
+import json
+import re
+import unittest
+from pathlib import Path
+
+from biocore_model import emotion_probe as ep
+from biocore_model import feedback_flow as ff
+
+MAIN = Path(__file__).resolve().parents[2] / "main.py"
+FENCE = "\x60\x60\x60"
+
+
+class FakeCore:
+    def __init__(self):
+        self._snapshot = {"v": 0.1, "a": 0.4, "stress": 0.2,
+                          "self_esteem": 0.5, "social": 0.5, "trust": 0.5}
+
+    def snapshot(self):
+        return dict(self._snapshot)
+
+    def load_state(self, state):
+        self._snapshot.update(state)
+
+
+def payload(deltas, c=0.8, why="有点被扎到"):
+    return json.dumps({"deltas": deltas, "why": why, "c": c})
+
+
+class ParseTest(unittest.TestCase):
+    def setUp(self):
+        ep.reset_rate()
+
+    def test_normal_deltas(self):
+        out = ep.parse(payload({"v": -0.3, "a": 0.1}), core=object(), now=1000.0)
+        self.assertEqual(out["deltas"], {"v": -0.2, "a": 0.1})
+        self.assertEqual(out["why"], "有点被扎到")
+        self.assertEqual(out["source"], "probe")
+
+    def test_empty_deltas_is_valid_but_no_write(self):
+        out = ep.parse(payload({}, c=0.9, why="没影响"), core=object(), now=1000.0)
+        self.assertEqual(out["deltas"], {})
+        self.assertEqual(ep.to_feedback_payload(out), {})
+
+    def test_unknown_fields_dropped(self):
+        out = ep.parse(payload({"mood": 0.5, "v": -0.1}), core=object(), now=1000.0)
+        self.assertEqual(out["deltas"], {"v": -0.1})
+
+    def test_per_item_clamp(self):
+        out = ep.parse(payload({"v": 0.9, "trust": -0.5}), core=object(), now=1000.0)
+        self.assertEqual(out["deltas"], {"v": 0.2, "trust": -0.2})
+
+    def test_rate_limit_same_minute(self):
+        core = object()
+        first = ep.parse(payload({"v": 0.2, "a": 0.2}), core=core, now=1000.0)
+        self.assertEqual(first["deltas"], {"v": 0.2, "a": 0.2})
+        second = ep.parse(payload({"v": 0.2}), core=core, now=1001.0)
+        self.assertEqual(second["deltas"], {})
+        third = ep.parse(payload({"v": 0.2}), core=core, now=1002.0)
+        self.assertEqual(third["deltas"], {})
+
+    def test_rate_limit_resets_next_minute(self):
+        core = object()
+        ep.parse(payload({"v": 0.2, "a": 0.2}), core=core, now=1000.0)
+        later = ep.parse(payload({"v": 0.2}), core=core, now=1060.0)
+        self.assertEqual(later["deltas"], {"v": 0.2})
+
+    def test_low_confidence_dropped(self):
+        self.assertEqual(ep.parse(payload({"v": -0.2}, c=0.39), core=object(),
+                                  now=1000.0), {})
+
+    def test_garbage_json(self):
+        self.assertEqual(ep.parse("我不是 JSON", core=object(), now=1000.0), {})
+        self.assertEqual(ep.parse("", core=object(), now=1000.0), {})
+
+    def test_fenced_json(self):
+        raw = "好的\n" + FENCE + "json\n" + payload({"v": -0.1}) + "\n" + FENCE
+        out = ep.parse(raw, core=object(), now=1000.0)
+        self.assertEqual(out["deltas"], {"v": -0.1})
+
+    def test_why_truncated_to_30(self):
+        out = ep.parse(payload({}, why="x" * 80), core=object(), now=1000.0)
+        self.assertEqual(len(out["why"]), ep.WHY_MAX_CHARS)
+
+
+class ProbeAsyncTest(unittest.IsolatedAsyncioTestCase):
+    def setUp(self):
+        ep.reset_rate()
+
+    async def test_success(self):
+        async def call(prompt):
+            return payload({"v": -0.2, "trust": -0.05}, c=0.9, why="被质疑")
+        out = await ep.probe("好。", "你什么意思", call, core=object(), now=2000.0)
+        self.assertEqual(out["deltas"], {"v": -0.2, "trust": -0.05})
+        self.assertEqual(out["why"], "被质疑")
+
+    async def test_timeout_returns_empty(self):
+        async def call(prompt):
+            await asyncio.sleep(1.0)
+            return payload({"v": -0.2})
+        self.assertEqual(await ep.probe("x", "y", call, timeout=0.05,
+                                        core=object(), now=2000.0), {})
+
+    async def test_exception_returns_empty(self):
+        async def call(prompt):
+            raise RuntimeError("boom")
+        self.assertEqual(await ep.probe("x", "y", call, core=object(),
+                                        now=2000.0), {})
+
+    async def test_prompt_short_and_has_contract(self):
+        seen = {}
+        async def call(prompt):
+            seen["prompt"] = prompt
+            return payload({}, c=0.9)
+        await ep.probe("回复", "消息", call, core=object(), now=2000.0)
+        self.assertLessEqual(len(ep._INSTRUCTION), 120)
+        for token in ("deltas", "why", "self_esteem", "无影响", "对方刚说", "回复"):
+            self.assertIn(token, seen["prompt"])
+
+
+class FeedbackIntegrationTest(unittest.TestCase):
+    def setUp(self):
+        ep.reset_rate()
+        ff.reset_seen()
+
+    def tearDown(self):
+        ff.reset_seen()
+
+    def test_write_takes_effect(self):
+        core = FakeCore()
+        out = ep.parse(payload({"v": -0.2, "stress": 0.1, "trust": -0.05},
+                               c=1.0), core=object(), now=3000.0)
+        meta = ep.to_feedback_payload(out)
+        self.assertIn("valence_delta", meta)
+        self.assertIn("self_esteem_delta" if False else "stress_delta", meta)
+        result = ff.apply_llm(meta, core, now=3000.0)
+        self.assertTrue(result["written"])
+        self.assertLess(core.snapshot()["v"], 0.1)
+
+    def test_idempotent_same_now(self):
+        core = FakeCore()
+        meta = ep.to_feedback_payload(ep.parse(payload({"v": -0.2}, c=1.0),
+                                               core=object(), now=4000.0))
+        first = ff.apply_llm(meta, core, now=4000.0)
+        second = ff.apply_llm(meta, core, now=4000.0)
+        self.assertTrue(first["written"])
+        self.assertEqual(second["deltas"], {})
+
+    def test_empty_deltas_no_write(self):
+        core = FakeCore()
+        meta = ep.to_feedback_payload(ep.parse(payload({}), core=object(), now=5000.0))
+        self.assertEqual(meta, {})
+        result = ff.apply_llm(meta, core, now=5000.0)
+        self.assertFalse(result["written"])
+
+
+class _Recorder:
+    """Minimal logger stub; keeps tests free of the stdlib logging import."""
+
+    def __init__(self):
+        self.lines = []
+
+    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))
+
+    debug = info = warning = error = exception = critical = _log
+
+
+class RawDiagnosticTest(unittest.TestCase):
+    def _with_recorder(self, call):
+        rec = _Recorder()
+        saved = ep.logger
+        ep.logger = rec
+        try:
+            call()
+        finally:
+            ep.logger = saved
+        return rec
+
+    def test_invalid_raw_is_logged(self):
+        rec = self._with_recorder(
+            lambda: ep.parse("我不是JSON", core=object(), now=1000.0))
+        self.assertTrue(any("emotion probe raw=" in line for line in rec.lines))
+
+    def test_low_confidence_raw_is_logged(self):
+        rec = self._with_recorder(
+            lambda: ep.parse(payload({"v": -0.2}, c=0.1), core=object(), now=1000.0))
+        self.assertTrue(any("emotion probe raw=" in line for line in rec.lines))
+
+
+class WiringStaticTest(unittest.TestCase):
+    def test_main_consumes_new_contract(self):
+        source = MAIN.read_text(encoding="utf-8")
+        self.assertIn("emotion_probe_enabled", source)
+        self.assertIn("feedback_payload", source)
+        self.assertIn("appraisal src=reply dims=%s deltas=%s c=%.2f", source)
+        self.assertIn("core=_core, now=time.time()", source)
+        self.assertIn("asyncio.create_task(_emotion_probe_task())", source)
+        self.assertIn("_probe_raw", source)
+        self.assertIn("isinstance(_raw, str)", source)
+        self.assertIn("[biocore] emotion probe raw=%r", source)
+        self.assertIn("[biocore] emotion probe start", source)
+        self.assertIn("emotion probe task failed", source)
+        self.assertIn("emotion probe llm returned None", source)
+        self.assertIn("exc_info=True", source)
+
+
+if __name__ == "__main__":
+    unittest.main()