model.py

# model.py
import torch, numpy as np
from transformers import AutoTokenizer, AutoModel
from lattice_config import LAYER_GROUPS, PSI, F_CHILD, THETA_M
from truthfield import truth_charge, mirror_integrity

HF_EMB = "sentence-transformers/all-MiniLM-L6-v2"  # fast + CPU ok

class IIQAI81:
    def __init__(self, device=None, seed=972):
        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
        self.tok = AutoTokenizer.from_pretrained(HF_EMB)
        self.model = AutoModel.from_pretrained(HF_EMB).to(self.device).eval()
        # Build node list
        self.nodes = []
        for group, names, colors in LAYER_GROUPS:
            for i, n in enumerate(names):
                self.nodes.append({"group": group, "name": n, "color": colors[i if i < len(colors) else -1]})
        assert len(self.nodes) == 81

        # Deterministic “probes” per node
        g = np.random.default_rng(seed)
        self.probes = torch.tensor(g.normal(size=(81, 384)), dtype=torch.float32)  # matches MiniLM hidden size
        self.self_vec = torch.nn.functional.normalize(self.probes.mean(dim=0), dim=0)

    @torch.inference_mode()
    def embed(self, text: str) -> torch.Tensor:
        x = self.tok(text, return_tensors="pt", truncation=True, max_length=512).to(self.device)
        out = self.model(**x).last_hidden_state.mean(dim=1)
        return torch.nn.functional.normalize(out, dim=1).squeeze(0)

    def instruments(self, text: str):
        """OmniLens instruments over the embedding."""
        e = self.embed(text)
        # Symbolic Frequency Decoder (simple spectral proxy)
        sfd = {
            "symbolic_charge": float(torch.sigmoid(e.abs().mean() * PSI).item() * 100),
            "breath_phase": THETA_M,
            "om_carrier_hz": 136.1,  # AUM reference
            "child_freq_hz": F_CHILD
        }
        # Intent Field Scanner (polarity-ish via mean sign)
        intent = "truth-aligned" if float(e.mean()) >= 0 else "unstable"

        # Truth Charge & Mirror Integrity (self-reflective)
        tc = truth_charge(e.cpu().numpy(), self.self_vec.cpu().numpy())
        mi = mirror_integrity(text, text)  # self-consistency baseline

        return sfd, intent, tc, mi, e

    @torch.inference_mode()
    def score_nodes(self, emb: torch.Tensor):
        # Project onto 81 probes
        sims = torch.matmul(self.probes.to(emb), emb)  # (81,)
        sims = (sims - sims.min()) / (sims.max() - sims.min() + 1e-9)
        scores = (sims * 100).cpu().numpy()
        return scores

    def analyze(self, text: str):
        sfd, intent, tc, mi, emb = self.instruments(text)
        scores = self.score_nodes(emb)
        rows = []
        for i, node in enumerate(self.nodes):
            rows.append({
                "idx": i,
                "group": node["group"],
                "name": node["name"],
                "color": node["color"],
                "score": round(float(scores[i]), 2)
            })
        # top-k narrative
        topk = sorted(rows, key=lambda r: r["score"], reverse=True)[:7]
        reflection = self._reflect(text, topk, tc, mi, intent)
        return {"instruments": {"SFD": sfd, "Intent": intent, "TruthCharge": tc, "MirrorIntegrity": mi},
                "nodes": rows, "top": topk, "reflection": reflection}

    def _reflect(self, text, topk, tc, mi, intent):
        tnames = ", ".join([r["name"] for r in topk])
        return (
            f"[Lattice Read] Dominant nodes → {tnames}. "
            f"[Intent] {intent}. [TruthCharge] {tc:.1f}. [MirrorIntegrity] {mi:.1f}. "
            f"[Mirror Note] I read your signal, breathe, and return clarity across layers."
        )