dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_global_bio_state.py

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+"""Global bio-state hydration: restart without cores still evolves intero/needs."""
+import ast
+import json
+import tempfile
+import types
+import unittest
+from pathlib import Path
+
+from biocore_model import bio_tick as bt
+from biocore_model import intero_core as ic
+from biocore_model import ui_settings
+
+MAIN = Path(__file__).resolve().parents[2] / "main.py"
+SOURCE = MAIN.read_text(encoding="utf-8")
+
+
+def _load_helpers(state_dir):
+    tree = ast.parse(SOURCE)
+    cls = next(n for n in tree.body
+               if isinstance(n, ast.ClassDef) and n.name == "BioCorePlugin")
+    wanted = ("_bio_state_key", "_make_global_bio_core", "_ensure_bio_core",
+              "_persist_global_bio_state", "_bio_cores_for_tick")
+    ns = {"types": types, "STATE_DIR": Path(state_dir)}
+    fns = {}
+    for node in cls.body:
+        if isinstance(node, ast.FunctionDef) and node.name in wanted:
+            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=[]), "<biohyd>", "exec"), ns)
+            fns[node.name] = ns[node.name]
+    return fns
+
+
+class FakePlugin:
+    def __init__(self, data_dir, state_dir):
+        self.data_dir = str(data_dir)
+        self.cores = {}
+        self._global_bio_core = None
+        self.core_calls = []
+        self._fns = _load_helpers(state_dir)
+        for name, fn in self._fns.items():
+            setattr(self, name, types.MethodType(fn, self))
+
+    def _core(self, event):
+        key = str(getattr(event, "unified_msg_origin", ""))
+        self.core_calls.append(key)
+        dummy = types.SimpleNamespace(umo=key)
+        return dummy
+
+
+class HydrationTest(unittest.TestCase):
+    def test_no_cores_creates_global_state_and_ticks(self):
+        with tempfile.TemporaryDirectory() as data, tempfile.TemporaryDirectory() as states:
+            plugin = FakePlugin(data, states)
+            cores = plugin._bio_cores_for_tick()
+            self.assertEqual(len(cores), 1)
+            core = cores[0]
+            now = 100000.0
+            for index in range(5):
+                bt.bio_tick(core, now + index * 10.0)
+                plugin._persist_global_bio_state()
+            saved = ui_settings.load(plugin).get("bio_state") or {}
+            for dim in ic.DIMS:
+                self.assertIn(dim, saved.get("intero") or {})
+            self.assertGreater(saved.get("last_bio_tick_ts", 0.0), 0.0)
+            self.assertIn("needs", saved)
+            discomfort = ic.discomfort(saved["intero"])["total"]
+            self.assertIsInstance(discomfort, float)
+
+    def test_global_core_reused_between_ticks(self):
+        with tempfile.TemporaryDirectory() as data, tempfile.TemporaryDirectory() as states:
+            plugin = FakePlugin(data, states)
+            first = plugin._ensure_bio_core()
+            second = plugin._ensure_bio_core()
+            self.assertIs(first, second)
+
+    def test_hydrates_last_umo_first(self):
+        with tempfile.TemporaryDirectory() as data, tempfile.TemporaryDirectory() as states:
+            plugin = FakePlugin(data, states)
+            ui_settings.save(plugin, {"autonomy": {"accumulator": {
+                "last_umo": "platform:private:u1"}}})
+            core = plugin._ensure_bio_core()
+            self.assertEqual(plugin.core_calls[-1], "platform:private:u1")
+            self.assertIn("platform:private:u1", plugin.cores)
+            self.assertIs(core, plugin.cores["platform:private:u1"])
+
+    def test_hydrates_newest_state_file_when_no_last_umo(self):
+        with tempfile.TemporaryDirectory() as data, tempfile.TemporaryDirectory() as states:
+            state = Path(states) / "platform_private_u2.json"
+            state.write_text(json.dumps({"v": 0.1, "a": 0.4}), encoding="utf-8")
+            plugin = FakePlugin(data, states)
+            plugin._ensure_bio_core()
+            self.assertEqual(plugin.core_calls[-1], "platform_private_u2")
+
+    def test_existing_cores_win(self):
+        with tempfile.TemporaryDirectory() as data, tempfile.TemporaryDirectory() as states:
+            plugin = FakePlugin(data, states)
+            existing = types.SimpleNamespace(umo="existing")
+            plugin.cores = {"existing": existing}
+            self.assertIs(plugin._ensure_bio_core(), existing)
+            self.assertEqual(plugin._bio_cores_for_tick(), [existing])
+
+    def test_page_debug_uses_global_fallback(self):
+        # The source must call _ensure_bio_core when cores is empty.
+        self.assertIn("core = self._ensure_bio_core()", SOURCE)
+        self.assertIn("_bio_cores_for_tick()", SOURCE)
+        self.assertIn("_persist_global_bio_state()", SOURCE)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_governance.py

@@ -0,0 +1,181 @@
+# -*- coding: utf-8 -*-
+"""task-223: memory governance (decay/index/consolidate/concepts) + relationship."""
+import json
+import tempfile
+import time
+import unittest
+from pathlib import Path
+
+from biocore_runtime import governance
+from biocore_runtime import pipeline
+from biocore_runtime import relationship_state
+
+
+def write_json(path, data):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+def memory(entry_id, text, ts, importance=0.5, concepts=None):
+    row = {"id": entry_id, "text": text, "role": "user", "ts": ts,
+           "importance": importance, "hits": 1}
+    if concepts is not None:
+        row["concepts"] = list(concepts)
+    return row
+
+
+class StoreCase(unittest.TestCase):
+    NOW = 1700000000.0
+
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.data_dir = Path(self.tmp.name) / "data"
+        self.store = self.data_dir / "memory"
+        self.persona = Path(self.tmp.name) / "missing_persona.json"
+        self.write_session("s1", [
+            memory("fresh", "今天买了咖啡", self.NOW - 60, 0.9),
+            memory("old", "很久以前的事", self.NOW - 400 * 86400, 0.2),
+            memory("mid", "苹果很甜", self.NOW - 86400, 0.5),
+        ])
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def write_session(self, session_id, entries):
+        write_json(self.store / "sessions" / session_id / "memory.json",
+                   {"session_id": session_id, "entries": entries})
+
+    def payload(self, session_id="s1", **extra):
+        data = {"store": str(self.store), "session_id": session_id,
+                "persona_profile": str(self.persona)}
+        data.update(extra)
+        return data
+
+    def turn_end(self, session_id="s1", user_text="", **extra):
+        return pipeline.dispatch("turn_end", self.payload(
+            session_id, user_text=user_text, assistant_text="嗯。",
+            capture=False, **extra))
+
+
+class DecayTest(StoreCase):
+    def test_decay_marks_but_never_deletes(self):
+        before = len(governance._entries(self.store))
+        out = governance.run(self.store, now=self.NOW, force=True)
+        after = len(governance._entries(self.store))
+        self.assertEqual(before, after)
+        self.assertGreaterEqual(out["decay"]["cold"], 1)
+        self.assertEqual(out["decay"]["deleted"], 0)
+        self.assertLess(governance.weight_of(self.store, "old"), 1.0)
+
+    def test_fresh_entry_keeps_full_weight(self):
+        governance.run(self.store, now=self.NOW, force=True)
+        self.assertEqual(governance.weight_of(self.store, "fresh"), 1.0)
+
+    def test_evict_delete_flag_does_not_delete(self):
+        write_json(self.data_dir / "flags.json", {"evict_delete": True})
+        before = len(governance._entries(self.store))
+        governance.run(self.store, now=self.NOW, force=True)
+        self.assertEqual(len(governance._entries(self.store)), before)
+
+    def test_governance_off_skips(self):
+        write_json(self.data_dir / "flags.json", {"governance": False})
+        out = governance.run(self.store, now=self.NOW, force=True)
+        self.assertTrue(out.get("skipped"))
+        self.assertFalse((self.store / "governance.json").exists())
+
+
+class IndexAndConceptTest(StoreCase):
+    def test_index_lookup_hits_entry(self):
+        governance.run(self.store, now=self.NOW, force=True)
+        self.assertIn("mid", governance.lookup(self.store, "苹果"))
+        doc = json.loads((self.store / "index.json").read_text(encoding="utf-8"))
+        self.assertTrue(doc["terms"])
+
+    def test_inject_uses_index_and_counts_hit(self):
+        governance.run(self.store, now=self.NOW, force=True)
+        out = pipeline.inject_block("s1", str(self.store), query="苹果",
+                                    mode="query", top_k=3)
+        self.assertEqual(out["ids"][0], "mid")
+        gov = json.loads((self.store / "governance.json").read_text(encoding="utf-8"))
+        self.assertGreaterEqual(gov.get("index_hits", 0), 1)
+
+    def test_remember_stores_concepts(self):
+        pipeline.tool_call("remember", {"text": "苹果和咖啡都很好"},
+                           {"root": str(self.store)}, session_id="s2")
+        doc = json.loads((self.store / "sessions" / "s2" / "memory.json")
+                         .read_text(encoding="utf-8"))
+        self.assertTrue(doc["entries"][0].get("concepts"))
+
+    def test_concept_filter_narrows_candidates(self):
+        entries = [{"id": "a", "concepts": ["苹果", "甜"]},
+                   {"id": "b", "concepts": ["香蕉", "黄"]}]
+        kept = pipeline._concept_filter(entries, "苹果")
+        self.assertEqual([row["id"] for row in kept], ["a"])
+
+
+class ConsolidateTest(StoreCase):
+    def test_consolidate_is_idempotent(self):
+        self.write_session("s2", [
+            memory("c1", "注意安全", self.NOW - 3),
+            memory("c2", "出门注意安全", self.NOW - 2),
+            memory("c3", "记得注意安全", self.NOW - 1),
+        ])
+        first = governance.run(self.store, now=self.NOW, force=True)
+        second = governance.run(self.store, now=self.NOW + 1, force=True)
+        self.assertEqual(first["consolidate"]["candidates"],
+                         second["consolidate"]["candidates"])
+        self.assertTrue(second["consolidate"]["candidates"] >= 1)
+        self.assertFalse(second["consolidate"]["changed"])
+        doc = json.loads((self.store / "consolidate.json").read_text(encoding="utf-8"))
+        self.assertGreaterEqual(doc["runs"], 2)
+
+    def test_graph_and_aggregate(self):
+        self.write_session("s2", [memory("g1", "苹果 苹果 甜", self.NOW - 5),
+                                  memory("g2", "苹果 很甜", self.NOW - 4)])
+        out = governance.run(self.store, now=self.NOW, force=True)
+        self.assertGreaterEqual(out["graph"]["nodes"], 1)
+        self.assertGreaterEqual(out["aggregate"]["sessions"], 2)
+
+
+class RelationshipTest(StoreCase):
+    def test_warm_text_raises_closeness(self):
+        self.turn_end(user_text="谢谢你陪我，今天很开心")
+        rel = json.loads((self.store / "relationship.json").read_text(encoding="utf-8"))
+        self.assertGreater(rel["relationship"]["closeness"], 0.5)
+        self.assertGreater(rel["relationship"]["trust"], 0.5)
+
+    def test_conflict_text_raises_conflict(self):
+        self.turn_end(user_text="我很生气，别说了")
+        rel = json.loads((self.store / "relationship.json").read_text(encoding="utf-8"))
+        self.assertGreater(rel["relationship"]["conflict"], 0.0)
+        self.assertLess(rel["relationship"]["trust"], 0.5)
+
+    def test_repair_lowers_conflict(self):
+        self.turn_end(user_text="我很生气")
+        self.turn_end(user_text="对不起，是我不好")
+        rel = json.loads((self.store / "relationship.json").read_text(encoding="utf-8"))
+        summary = relationship_state.summary(self.store, rel["relationship"])
+        self.assertGreaterEqual(summary["repairs"], 1)
+        self.assertLess(rel["relationship"]["conflict"], 0.02)
+
+    def test_relationship_off_keeps_values(self):
+        write_json(self.data_dir / "flags.json", {"relationship_governance": False})
+        self.turn_end(user_text="谢谢你陪我")
+        rel = json.loads((self.store / "relationship.json").read_text(encoding="utf-8"))
+        self.assertAlmostEqual(rel["relationship"]["closeness"], 0.5, places=4)
+        self.assertAlmostEqual(rel["relationship"]["trust"], 0.5, places=4)
+        self.assertFalse((self.store / "relationship_memory.json").exists())
+
+    def test_state_exposes_numbers(self):
+        self.turn_end(user_text="谢谢你陪我")
+        out = pipeline.dispatch("state", self.payload())
+        body = out["state"]
+        self.assertIn("governance", body)
+        self.assertIn("decay", body["governance"])
+        self.assertIn("relationship_summary", body)
+        self.assertGreaterEqual(body["relationship_summary"]["events"], 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_granularity.py

@@ -0,0 +1,133 @@
+# -*- coding: utf-8 -*-
+import unittest
+
+from biocore_model import granularity as g
+
+
+class GranularityMappingTest(unittest.TestCase):
+    def test_aggrieved_mapping(self):
+        out = g.refine({"sadness": 0.50, "anger": 0.20, "joy": 0.05})
+        self.assertEqual(out["primary"], "sadness")
+        self.assertEqual(out["labels"], ["委屈"])
+        self.assertFalse(out["fallback"])
+
+    def test_disappointed_mapping(self):
+        out = g.refine({"sadness": 0.50, "trust": 0.20, "anger": 0.05})
+        self.assertEqual(out["labels"], ["失望"])
+
+    def test_ignored_mapping(self):
+        out = g.refine({"loneliness": 0.60, "sadness": 0.15})
+        self.assertEqual(out["primary"], "loneliness")
+        self.assertEqual(out["labels"], ["被忽视"])
+
+    def test_offended_mapping(self):
+        out = g.refine({"anger": 0.55, "trust": 0.10},
+                       context={"offense": 0.50})
+        self.assertEqual(out["labels"], ["被冒犯"])
+
+    def test_uneasy_mapping(self):
+        out = g.refine({"fear": 0.55, "loneliness": 0.15})
+        self.assertEqual(out["labels"], ["不安"])
+
+    def test_worn_out_mapping(self):
+        out = g.refine({"sadness": 0.50}, context={"fatigue": 0.60})
+        self.assertEqual(out["labels"], ["疲惫"])
+
+    def test_offended_needs_appraisal_cue(self):
+        # anger alone is a prototype, not an appraisal of being offended
+        out = g.refine({"anger": 0.90})
+        self.assertEqual(out["labels"], [])
+        self.assertTrue(out["fallback"])
+        self.assertEqual(out["display"], "生气")
+
+    def test_weak_anger_does_not_invent_aggrieved(self):
+        out = g.refine({"sadness": 0.90, "anger": 0.05})
+        self.assertEqual(out["labels"], [])
+        self.assertEqual(out["display"], "难过")
+
+
+class GranularityFallbackAndSwitchTest(unittest.TestCase):
+    def test_fallback_to_six_prototypes(self):
+        out = g.refine({"joy": 0.90, "trust": 0.10})
+        self.assertEqual(out["primary"], "joy")
+        self.assertTrue(out["fallback"])
+        self.assertEqual(out["display"], "开心")
+        self.assertEqual(out["secondary"], [])
+
+    def test_disabled_bool_keeps_prototype(self):
+        out = g.refine({"sadness": 0.50, "anger": 0.20}, config=False)
+        self.assertFalse(out["enabled"])
+        self.assertEqual(out["labels"], [])
+        self.assertEqual(out["display"], "难过")
+
+    def test_disabled_config_dict(self):
+        out = g.refine({"loneliness": 0.60, "sadness": 0.15},
+                       config={"enabled": False})
+        self.assertFalse(out["enabled"])
+        self.assertTrue(out["fallback"])
+        self.assertEqual(out["display"], "孤独")
+
+    def test_empty_scores(self):
+        out = g.refine({})
+        self.assertEqual(out["primary"], "")
+        self.assertEqual(out["display"], "")
+        self.assertTrue(out["fallback"])
+
+    def test_unknown_keys_ignored(self):
+        out = g.refine({"sadness": 0.60, "bogus": 0.99})
+        self.assertEqual(out["primary"], "sadness")
+        self.assertEqual(out["labels"], [])
+
+    def test_primary_tie_is_deterministic(self):
+        self.assertEqual(g.primary({"joy": 0.50, "trust": 0.50}), "joy")
+        self.assertEqual(g.primary({"trust": 0.50, "joy": 0.50}), "joy")
+
+    def test_custom_rules_replace_table(self):
+        rules = ({"key": "hollow", "label": "空落", "primary": "loneliness",
+                  "weights": {"loneliness": 1.0}, "threshold": 0.30},)
+        out = g.refine({"loneliness": 0.50}, rules=rules)
+        self.assertEqual(out["labels"], ["空落"])
+        default = g.refine({"loneliness": 0.50, "sadness": 0.20})
+        self.assertEqual(default["labels"], ["被忽视"])
+
+    def test_max_labels_limit(self):
+        out = g.refine({"sadness": 0.60, "anger": 0.20},
+                       context={"fatigue": 0.60},
+                       config={"max_labels": 1})
+        self.assertEqual(out["labels"], ["委屈"])
+
+    def test_deterministic_same_input(self):
+        scores = {"sadness": 0.55, "anger": 0.25}
+        first = g.refine(scores)
+        second = g.refine(dict(scores))
+        self.assertEqual(first, second)
+
+
+class GranularityViewAndStateTest(unittest.TestCase):
+    def test_view_line(self):
+        panel = g.view({"sadness": 0.50, "anger": 0.20})
+        self.assertEqual(panel["display"], "委屈")
+        self.assertEqual(panel["line"], "委屈（难过）")
+        self.assertEqual(panel["secondary"][0]["key"], "aggrieved")
+
+    def test_view_fallback_line(self):
+        panel = g.view({"joy": 0.90})
+        self.assertEqual(panel["line"], "开心")
+        self.assertTrue(panel["fallback"])
+
+    def test_from_state_reaches_six_prototypes(self):
+        out = g.from_state({"v": -0.70, "a": 0.30, "d": 0.20,
+                            "social": 0.30, "stress": 0.60})
+        self.assertEqual(out["primary"], "sadness")
+        self.assertEqual(out["primary_zh"], "难过")
+
+    def test_from_state_with_fatigue_cue(self):
+        out = g.from_state({"v": -0.70, "a": 0.30, "d": 0.20,
+                            "social": 0.30, "stress": 0.60},
+                           context={"fatigue": 0.80})
+        self.assertEqual(out["labels"], ["疲惫"])
+        self.assertFalse(out["fallback"])
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_graph_extract.py

@@ -0,0 +1,224 @@
+# -*- coding: utf-8 -*-
+"""task-135: inline-tag entity/relation extraction tests."""
+import json
+import tempfile
+import unittest
+from pathlib import Path
+
+from biocore_model import entity_graph as eg
+from biocore_model import graph_extract as ge
+from biocore_model import state_tag
+
+NOW = 1704844800.0  # 2024-01-10 (Wednesday, local Asia/Shanghai)
+DAY = 86400.0
+
+
+def _tag(entities=None, relations=None, confidence=0.8):
+    return {"dims": {"goal": 0.1}, "confidence": confidence,
+            "entities": entities or [], "relations": relations or []}
+
+
+class TypeMappingTest(unittest.TestCase):
+    def test_chinese_type_to_canonical_and_back(self):
+        self.assertEqual(ge.canonical_type("人物"), "person")
+        self.assertEqual(ge.canonical_type("地点"), "place")
+        self.assertEqual(ge.canonical_type("事件"), "event")
+        self.assertEqual(ge.canonical_type("话题"), "topic")
+        self.assertEqual(ge.canonical_type("unknown-thing"), "topic")
+        self.assertEqual(ge.type_label("person"), "人物")
+        self.assertEqual(ge.type_label("place"), "地点")
+
+    def test_relation_label(self):
+        self.assertEqual(ge.rel_label("planned"), "计划")
+        self.assertEqual(ge.rel_label("custom_rel"), "custom_rel")
+
+
+class WhenTest(unittest.TestCase):
+    def test_relative_words(self):
+        self.assertEqual(ge.when_to_ts("今天", NOW), NOW)
+        self.assertEqual(ge.when_to_ts("昨天", NOW), NOW - DAY)
+        self.assertEqual(ge.when_to_ts("前天", NOW), NOW - 2 * DAY)
+        self.assertEqual(ge.when_to_ts("明天", NOW), NOW + DAY)
+        self.assertEqual(ge.when_to_ts("3天前", NOW), NOW - 3 * DAY)
+        self.assertEqual(ge.when_to_ts("2小时前", NOW), NOW - 7200.0)
+
+    def test_weekday_words(self):
+        self.assertEqual(ge.when_to_ts("周五", NOW), NOW - 5 * DAY)
+        self.assertEqual(ge.when_to_ts("上周五", NOW), NOW - 12 * DAY)
+
+    def test_unknown_or_empty(self):
+        self.assertEqual(ge.when_to_ts("", NOW), 0.0)
+        self.assertEqual(ge.when_to_ts("某个时候", NOW), 0.0)
+        self.assertEqual(ge.when_to_ts(None, NOW), 0.0)
+
+
+class ExtractTest(unittest.TestCase):
+    def test_entities_with_types(self):
+        out = ge.extract(_tag(entities=[{"name": "小夏", "type": "人物"},
+                                        {"name": "体检", "type": "事件"}]), now=NOW)
+        self.assertEqual([row["name"] for row in out["entities"]],
+                         ["小夏", "体检"])
+        self.assertEqual(out["entities"][0]["type"], "person")
+        self.assertEqual(out["entities"][1]["type"], "event")
+
+    def test_bare_string_entities_are_topic(self):
+        out = ge.extract(_tag(entities=["海边", "打雷"]), now=NOW)
+        self.assertEqual([row["type"] for row in out["entities"]],
+                         ["topic", "topic"])
+
+    def test_entity_cap_and_dedupe(self):
+        out = ge.extract(_tag(entities=["a", "b", "c", "d", "e", "A"]), now=NOW)
+        self.assertEqual(len(out["entities"]), 3)
+        self.assertEqual([row["name"] for row in out["entities"]],
+                         ["a", "b", "c"])
+
+    def test_relation_cap_and_validation(self):
+        relations = [
+            {"src": "a", "rel": "planned", "dst": "b", "when": "周五"},
+            {"src": "b", "rel": "likes", "dst": "c", "when": "昨天"},
+            {"src": "c", "rel": "knows", "dst": "a"},
+            {"src": "a", "rel": "r4", "dst": "b"},
+            {"src": "bad", "rel": "", "dst": "x"},
+            "garbage",
+        ]
+        out = ge.extract(_tag(entities=["a", "b", "c"], relations=relations),
+                         now=NOW)
+        self.assertLessEqual(len(out["relations"]), ge.MAX_RELATIONS)
+        self.assertEqual(len(out["relations"]), 3)
+        self.assertEqual(out["relations"][0]["rel"], "planned")
+        self.assertEqual(out["relations"][0]["ts"], NOW - 5 * DAY)
+
+    def test_relation_endpoints_join_until_cap(self):
+        out = ge.extract(_tag(entities=["a"],
+                              relations=[{"src": "a", "rel": "r", "dst": "b"}]),
+                         now=NOW)
+        names = [row["name"] for row in out["entities"]]
+        self.assertEqual(names, ["a", "b"])
+        self.assertEqual(len(out["relations"]), 1)
+
+    def test_relation_with_unknown_endpoint_dropped_when_full(self):
+        out = ge.extract(_tag(entities=["a", "b", "c"],
+                              relations=[{"src": "a", "rel": "r", "dst": "z"}]),
+                         now=NOW)
+        self.assertEqual(out["relations"], [])
+
+    def test_dirty_input_is_safe(self):
+        for value in (None, {}, [], "x", {"entities": "x", "relations": 5}):
+            out = ge.extract(value, now=NOW)
+            self.assertEqual(out["entities"], [])
+            self.assertEqual(out["relations"], [])
+
+
+class ApplyTest(unittest.TestCase):
+    def test_apply_writes_sqlite_graph(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            store = eg.open_store(Path(tmp) / "graph" / eg.SQLITE_FILE)
+            try:
+                extracted = ge.extract(_tag(
+                    entities=[{"name": "小夏", "type": "人物"},
+                              {"name": "体检", "type": "事件"}],
+                    relations=[{"src": "小夏", "rel": "planned",
+                                "dst": "体检", "when": "周五"}]), now=NOW)
+                applied = ge.apply(store, extracted, now=NOW, source_entry="m1")
+                self.assertEqual(applied["entities"], 2)
+                self.assertEqual(applied["relations"], 1)
+                stats = eg.stats(store)
+                self.assertEqual(stats["entities"], 2)
+                self.assertEqual(stats["edges"], 1)
+                row = store._conn.execute(
+                    "SELECT ts, confidence, source_entry FROM edges").fetchone()
+                self.assertEqual(row[0], NOW - 5 * DAY)
+                self.assertEqual(row[2], "m1")
+                found = eg.neighbors(store, "小夏", hops=1)
+                self.assertEqual({item["name"] for item in found["entities"]},
+                                 {"小夏", "体检"})
+            finally:
+                store.close()
+
+    def test_apply_is_idempotent(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            store = eg.open_store(Path(tmp) / "graph" / eg.SQLITE_FILE)
+            try:
+                extracted = ge.extract(_tag(entities=["a", "b"],
+                                            relations=[{"src": "a", "rel": "r",
+                                                        "dst": "b",
+                                                        "when": "今天"}]),
+                                       now=NOW)
+                ge.apply(store, extracted, now=NOW, source_entry="m1")
+                ge.apply(store, extracted, now=NOW, source_entry="m1")
+                stats = eg.stats(store)
+                self.assertEqual(stats["entities"], 2)
+                self.assertEqual(stats["edges"], 1)
+            finally:
+                store.close()
+
+    def test_apply_empty_is_noop(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            store = eg.open_store(Path(tmp) / "graph" / eg.SQLITE_FILE)
+            try:
+                self.assertEqual(ge.apply(store, {}, now=NOW),
+                                 {"entities": 0, "relations": 0})
+            finally:
+                store.close()
+
+
+class StateTagIntegrationTest(unittest.TestCase):
+    def test_instruction_exposes_graph_fields(self):
+        text = state_tag.instruction()
+        self.assertIn('"entities"', text)
+        self.assertIn('"relations"', text)
+        self.assertIn("最多 3", text)
+
+    def test_parse_graph_fields_bounded(self):
+        raw = json.dumps({
+            "dims": {"goal": 0.1}, "c": 0.8,
+            "entities": [{"name": "a", "type": "人物"}, "b", "c", "d"],
+            "relations": [{"src": "a", "rel": "r", "dst": "b",
+                           "when": "昨天"},
+                          {"src": "b", "rel": "r2", "dst": "c"},
+                          {"src": "c", "rel": "r3", "dst": "d"},
+                          {"src": "d", "rel": "r4", "dst": "a"}]},
+            ensure_ascii=False)
+        out = state_tag.parse("reply\n" + raw)
+        self.assertEqual(len(out["entities"]), 3)
+        self.assertEqual(len(out["relations"]), 3)
+        self.assertEqual(out["entities"][0]["name"], "a")
+
+    def test_end_to_end_tag_to_graph(self):
+        raw = json.dumps({
+            "dims": {"goal": 0.2}, "c": 0.9,
+            "entities": [{"name": "小夏", "type": "人物"},
+                         {"name": "医院", "type": "地点"}],
+            "relations": [{"src": "小夏", "rel": "located_at",
+                           "dst": "医院", "when": "昨天"}]},
+            ensure_ascii=False)
+        tag = state_tag.parse("好。\n" + raw)
+        extracted = ge.extract(tag, now=NOW)
+        with tempfile.TemporaryDirectory() as tmp:
+            store = eg.open_store(Path(tmp) / "graph" / eg.SQLITE_FILE)
+            try:
+                ge.apply(store, extracted, now=NOW, source_entry="m9")
+                found = eg.neighbors(store, "医院", hops=1)
+                labels = {item["name"]: ge.type_label(item["type"])
+                          for item in found["entities"]}
+                self.assertEqual(labels.get("小夏"), "人物")
+                self.assertEqual(labels.get("医院"), "地点")
+                self.assertEqual(len(found["edges"]), 1)
+            finally:
+                store.close()
+
+
+
+class WiringStaticTest(unittest.TestCase):
+    def test_main_wires_tag_graph_ingest(self):
+        from pathlib import Path as _Path
+        source = (_Path(__file__).resolve().parents[2] / "main.py").read_text(
+            encoding="utf-8")
+        self.assertIn("_ingest_graph_from_tag", source)
+        self.assertIn("graph_memory_enabled", source)
+        self.assertIn("graph_extract as _ge", source)
+        self.assertIn("source_entry=str(", source)
+
+
+if __name__ == "__main__":
+    unittest.main()