Create reality adapter

reality adapter

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+"""
+adapter_actual_reality.py
+
+Adapter + persistence for ACTUAL_REALITY_MODULE_v2 -> lm_quant_veritas
+
+Features:
+- Accepts event + optional lm_quant_veritas context (coherence_score, entanglement_signature, metadata)
+- Calls RealityInterface.analyze_event()
+- Persists result to JSONL (append) and optionally to SQLite
+- Loads runtime config from YAML (fallback to defaults)
+- Minimal external deps: pyyaml (optional), sqlite3 (stdlib), json, pathlib
+"""
+
+from __future__ import annotations
+import json
+import sqlite3
+import logging
+from dataclasses import dataclass, field, asdict
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+# Import the RealityInterface from your ACTUAL_REALITY_MODULE_v2
+# Adjust the import path as needed (if it's a module/package).
+try:
+    from ACTUAL_REALITY_MODULE_v2 import RealityInterface
+except Exception:
+    # if module name differs or file is in same folder, try local import fallback
+    from actual_reality_module_v2 import RealityInterface  # type: ignore
+
+# Optional: pyyaml for config; not strictly required
+try:
+    import yaml
+except Exception:
+    yaml = None
+
+logger = logging.getLogger("AR_Adapter")
+logger.addHandler(logging.StreamHandler())
+logger.setLevel(logging.INFO)
+
+
+DEFAULT_CONFIG = {
+    "persistence": {
+        "jsonl_path": "actual_reality_analysis.jsonl",
+        "sqlite_path": "actual_reality_analysis.db",
+        "use_sqlite": True,
+    },
+    "adapter": {
+        "coherence_field": "coherence_score",
+        "entanglement_field": "entanglement_signature",
+        "include_lm_context": True,
+    },
+    "reality_interface": {
+        "keyword_similarity_weight": 0.6,
+        "metrics_shift_sensitivity": 0.25
+    }
+}
+
+
+@dataclass
+class LMContext:
+    """Simple container for lm_quant_veritas-style metrics to be attached to analysis."""
+    coherence_score: Optional[float] = None
+    entanglement_signature: Optional[Dict[str, Any]] = field(default_factory=dict)
+    model_version: Optional[str] = None
+    additional_meta: Dict[str, Any] = field(default_factory=dict)
+
+
+class ActualRealityAdapter:
+    def __init__(self, config_path: Optional[str] = None, reality_interface: Optional[RealityInterface] = None):
+        self.config = self._load_config(config_path)
+        self.ri = reality_interface or RealityInterface()
+        # apply tunables from config to the RealityInterface if present
+        ri_cfg = self.config.get("reality_interface", {})
+        for k, v in ri_cfg.items():
+            if hasattr(self.ri, k):
+                setattr(self.ri, k, v)
+
+        self.jsonl_path = Path(self.config["persistence"]["jsonl_path"])
+        self.sqlite_path = Path(self.config["persistence"]["sqlite_path"])
+        self.use_sqlite = bool(self.config["persistence"].get("use_sqlite", True))
+
+        if self.use_sqlite:
+            # ensure sqlite DB and table exist
+            self._init_sqlite_db()
+
+    def _load_config(self, config_path: Optional[str]) -> Dict[str, Any]:
+        if config_path and yaml and Path(config_path).exists():
+            try:
+                with open(config_path, "r", encoding="utf-8") as fh:
+                    cfg = yaml.safe_load(fh)
+                    merged = DEFAULT_CONFIG.copy()
+                    merged.update(cfg or {})
+                    return merged
+            except Exception as e:
+                logger.warning("Failed to load YAML config (%s). Using defaults. Error: %s", config_path, e)
+        return DEFAULT_CONFIG.copy()
+
+    def _init_sqlite_db(self):
+        conn = sqlite3.connect(self.sqlite_path)
+        cur = conn.cursor()
+        cur.execute(
+            """
+            CREATE TABLE IF NOT EXISTS analyses (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                timestamp TEXT,
+                surface_event TEXT,
+                analysis_json TEXT,
+                coherence_score REAL,
+                entanglement_json TEXT,
+                model_version TEXT
+            )
+            """
+        )
+        conn.commit()
+        conn.close()
+
+    def analyze_and_record(self, surface_event: str, lm_context: Optional[LMContext] = None) -> Dict[str, Any]:
+        """
+        Core API: analyze the event, augment with LM context, persist, and return the analysis dict.
+        """
+        lc = lm_context or LMContext()
+        # 1) perform analysis
+        analysis = self.ri.analyze_event(surface_event)
+
+        # 2) attach lm_quant_veritas context if configured to do so
+        if self.config["adapter"].get("include_lm_context", True):
+            analysis["_lm_context"] = {
+                "coherence_score": lc.coherence