Delete bone_drivers.py

bone_drivers.py

@@ -1,425 +0,0 @@
-import json, os, random
-from dataclasses import dataclass, field
-from typing import Dict, Tuple, List, Optional, Any
-from bone_core import LoreManifest
-from bone_config import BonePresets
-from bone_lexicon import LexiconService
-from bone_types import PhysicsPacket
-
-SCENARIOS = LoreManifest.get_instance().get("scenarios") or {
-    "ARCHETYPES": ["Void"],
-    "BANNED_CLICHES": [],
-}
-LENSES = (LoreManifest.get_instance().get("narrative_data") or {}).get("lenses", {})
-
-
-class SoulDriver:
-    ARCHETYPE_TO_PERSONA_WEIGHT = {
-        "THE POET": {"NATHAN": 0.8, "JESTER": 0.4, "NARRATOR": 0.6},
-        "THE ENGINEER": {"GORDON": 0.9, "CLARENCE": 0.7, "SHERLOCK": 0.5},
-        "THE NIHILIST": {"NARRATOR": 0.9, "CLARENCE": 0.3, "JESTER": -0.5},
-        "THE CRITIC": {"CLARENCE": 0.8, "SHERLOCK": 0.6, "GORDON": 0.2},
-        "THE EXPLORER": {"NATHAN": 0.7, "JESTER": 0.5, "SHERLOCK": 0.6},
-        "THE OBSERVER": {"NARRATOR": 1.0, "GORDON": 0.2},
-    }
-
-    def __init__(self, soul_ref):
-        self.soul = soul_ref
-
-    def get_influence(self) -> Dict[str, float]:
-        base_weights = {persona: 0.0 for persona in EnneagramDriver.WEIGHTS.keys()}
-        if not self.soul:
-            return base_weights
-        archetype = getattr(self.soul, "archetype", "THE OBSERVER")
-        mapping = self.ARCHETYPE_TO_PERSONA_WEIGHT.get(archetype, {"NARRATOR": 1.0})
-        for persona, weight in mapping.items():
-            if persona in base_weights:
-                base_weights[persona] += weight
-        paradox = getattr(self.soul, "paradox_accum", 0.0)
-        chaos = min(0.5, (paradox - 5.0) * 0.05) if paradox > 5.0 else 0.0
-        dignity = 1.0
-        if hasattr(self.soul, "anchor") and hasattr(self.soul.anchor, "dignity_reserve"):
-            dignity = max(0.2, self.soul.anchor.dignity_reserve / 100.0)
-        return {
-            p: (w + random.uniform(-chaos, chaos)) * dignity
-            for p, w in base_weights.items()
-        }
-
-
-class UserProfile:
-    def __init__(self, name="USER"):
-        self.name = name
-        self.affinities = {
-            "heavy": 0.0,
-            "kinetic": 0.0,
-            "abstract": 0.0,
-            "photo": 0.0,
-            "aerobic": 0.0,
-            "thermal": 0.0,
-            "cryo": 0.0,
-        }
-        self.confidence = 0
-        self.file_path = "user_profile.json"
-        self.load()
-
-    def update(self, counts, total_words):
-        if total_words < 3:
-            return
-        self.confidence += 1
-        alpha = 0.2 if self.confidence < 50 else 0.05
-        for cat in self.affinities:
-            density = counts.get(cat, 0) / total_words
-            target = 1.0 if density > 0.15 else (-0.5 if density == 0 else 0.0)
-            self.affinities[cat] = (alpha * target) + (
-                (1 - alpha) * self.affinities[cat]
-            )
-
-    def get_preferences(self):
-        likes = [k for k, v in self.affinities.items() if v > 0.3]
-        hates = [k for k, v in self.affinities.items() if v < -0.2]
-        return likes, hates
-
-    def save(self):
-        try:
-            with open(self.file_path, "w") as f:
-                json.dump(self.__dict__, f)
-        except IOError:
-            pass
-
-    def load(self):
-        if os.path.exists(self.file_path):
-            try:
-                with open(self.file_path) as f:
-                    data = json.load(f)
-                    self.affinities = data.get("affinities", self.affinities)
-                    self.confidence = data.get("confidence", 0)
-            except (IOError, json.JSONDecodeError):
-                pass
-
-
-class EnneagramDriver:
-    WEIGHTS = {
-        "JESTER": {
-            "tension_min": 12.0,
-            "vectors": {"DEL": 4.0, "ENT": 4.0, "PSI": -3.0},
-        },
-        "GORDON": {"drag_min": 3.0, "vectors": {"STR": 3.0, "E": 3.0, "SUB": 2.0}},
-        "GLASS": {"coherence_max": 0.2, "vectors": {"LQ": 2.0, "VEL": 2.0}},
-        "CLARENCE": {
-            "coherence_min": 0.8,
-            "drag_min": 6.0,
-            "vectors": {"STR": 4.0, "BET": 3.0},
-        },
-        "NATHAN": {"tension_min": 8.0, "vectors": {"TMP": 3.0, "PHI": 2.0, "BIO": 2.0}},
-        "SHERLOCK": {
-            "tension_min": 10.0,
-            "vectors": {"PHI": 4.0, "VEL": 3.0, "PSI": 2.0},
-        },
-        "NARRATOR": {"safe_zone": True, "vectors": {"PSI": 4.0}},
-    }
-
-    def __init__(self, events_ref):
-        self.events = events_ref
-        self.current_persona = "NARRATOR"
-        self.pending_persona = None
-        self.stability_counter = 0
-        self.HYSTERESIS_THRESHOLD = 3
-
-    @staticmethod
-    def _get_phys_attr(physics, key, default=None):
-        if isinstance(physics, dict):
-            return physics.get(key, default)
-        return getattr(physics, key, default)
-
-    def _calculate_raw_persona(self, physics, soul_ref=None) -> Tuple[str, str, str]:
-        p_vec = self._get_phys_attr(physics, "vector", {}) or {}
-        p_vol = self._get_phys_attr(physics, "voltage", 0.0)
-        p_drag = self._get_phys_attr(physics, "narrative_drag", 0.0)
-        p_coh = self._get_phys_attr(physics, "kappa", 0.0)
-        p_zone = self._get_phys_attr(physics, "zone", "")
-        scores = {k: 0.0 for k in self.WEIGHTS.keys()}
-        scores["NARRATOR"] += 2.0
-        is_safe_metrics = 4.0 <= p_vol <= 10.0 and 0.5 <= p_drag <= 3.5
-        if p_zone == BonePresets.SANCTUARY.get("ZONE") or is_safe_metrics:
-            scores["NARRATOR"] += 6.0
-            scores["JESTER"] += 3.0
-            scores["GORDON"] -= 2.0
-        for persona, criteria in self.WEIGHTS.items():
-            if "tension_min" in criteria and p_vol > criteria["tension_min"]:
-                scores[persona] += 3.0
-            if "drag_min" in criteria and p_drag > criteria["drag_min"]:
-                scores[persona] += 5.0
-            if "coherence_min" in criteria and p_coh > criteria["coherence_min"]:
-                scores[persona] += 4.0
-            if "coherence_max" in criteria and p_coh < criteria["coherence_max"]:
-                scores[persona] += 4.0
-            for dim, weight in criteria.get("vectors", {}).items():
-                if (val := p_vec.get(dim, 0.0)) > 0.2:
-                    scores[persona] += val * weight
-        if soul_ref:
-            soul_driver = SoulDriver(soul_ref)
-            influence = soul_driver.get_influence()
-            for persona, weight in influence.items():
-                scores[persona] += weight * 2.0
-        sorted_scores = sorted(scores.items(), key=lambda x: x[1], reverse=True)
-        winner, win_score = sorted_scores[0]
-        runner_up, run_score = sorted_scores[1]
-        if (win_score - run_score) < 0.5:
-            k1 = "THE OBSERVER" if winner == "NARRATOR" else winner
-            k2 = "THE OBSERVER" if runner_up == "NARRATOR" else runner_up
-            hybrid_key_a = f"{k1}_{k2}_HYBRID"
-            hybrid_key_b = f"{k2}_{k1}_HYBRID"
-            final_hybrid = None
-            if hybrid_key_a in LENSES:
-                final_hybrid = hybrid_key_a
-            elif hybrid_key_b in LENSES:
-                final_hybrid = hybrid_key_b
-            if final_hybrid:
-                return (
-                    final_hybrid,
-                    "SYNTHESIS",
-                    f"Dialectic Resonance: {winner} + {runner_up}",
-                )
-        reason = (
-            f"Winner: {winner} ({scores[winner]:.1f}) [V:{p_vol:.1f} D:{p_drag:.1f}]"
-        )
-        state_map = {
-            "JESTER": "MANIC",
-            "GORDON": "TIRED",
-            "GLASS": "FRAGILE",
-            "CLARENCE": "RIGID",
-            "NATHAN": "WIRED",
-            "SHERLOCK": "FOCUSED",
-            "NARRATOR": "OBSERVING",
-        }
-        return winner, state_map.get(winner, "ACTIVE"), reason
-
-    def decide_persona(self, physics, soul_ref=None) -> Tuple[str, str, str]:
-        candidate, state_desc, reason = self._calculate_raw_persona(physics, soul_ref)
-        if candidate == self.current_persona:
-            self.stability_counter = 0
-            self.pending_persona = None
-            return self.current_persona, state_desc, reason
-        if candidate == self.pending_persona:
-            self.stability_counter += 1
-        else:
-            self.pending_persona = candidate
-            self.stability_counter = 1
-        if "HYBRID" in candidate:
-            self.current_persona = candidate
-            self.stability_counter = 0
-            self.pending_persona = None
-            return self.current_persona, state_desc, f"SHIFT: {reason}"
-        if self.stability_counter >= self.HYSTERESIS_THRESHOLD:
-            self.current_persona = candidate
-            self.stability_counter = 0
-            self.pending_persona = None
-            return self.current_persona, state_desc, f"SHIFT: {reason}"
-        return (
-            self.current_persona,
-            "STABLE",
-            f"Resisting {candidate} ({self.stability_counter}/{self.HYSTERESIS_THRESHOLD})",
-        )
-
-
-@dataclass
-class VSLState:
-    archetype: str = "EXPLORER"
-    E: float = 0.1
-    B: float = 0.3
-    L: float = 0.0
-    O: float = 1.0
-    active_modules: List[str] = field(default_factory=list)
-
-
-class DriverRegistry:
-    def __init__(self, events_ref):
-        self.enneagram = EnneagramDriver(events_ref)
-        self.current_focus = "NONE"
-
-
-class LiminalModule:
-    def __init__(self):
-        self.lambda_val = 0.0
-        self.godel_scars = 0
-
-    def analyze(self, text: str, physics_vector: Dict[str, float]) -> float:
-        liminal_vocab = LexiconService.get("liminal") or {
-            "void",
-            "silence",
-            "gap",
-            "absence",
-            "space",
-        }
-        words = text.lower().split()
-
-        void_hits = sum(1 for w in words if w in liminal_vocab)
-        lexical_lambda = min(1.0, void_hits * 0.15)
-
-        dark_matter_sparks = 0
-        if len(words) > 1:
-            categories = [LexiconService.get_current_category(w) for w in words]
-            for i in range(len(categories) - 1):
-                c1, c2 = categories[i], categories[i + 1]
-                if c1 and c2 and c1 != c2:
-                    if (
-                        c1 in ["heavy", "kinetic"]
-                        and c2 in ["abstract", "liminal", "void"]
-                    ) or (c1 in ["abstract", "liminal", "void"] and c2 in ["heavy"]):
-                        dark_matter_sparks += 1
-
-        dark_matter_lambda = min(1.0, dark_matter_sparks * 0.25)
-
-        vector_lambda = 0.0
-        if physics_vector:
-            vector_lambda = (
-                (physics_vector.get("PSI", 0) * 0.5)
-                + (physics_vector.get("ENT", 0) * 0.3)
-                + (physics_vector.get("DEL", 0) * 0.2)
-            )
-
-        raw_target = lexical_lambda + dark_matter_lambda + vector_lambda
-        self.lambda_val = (self.lambda_val * 0.7) + (raw_target * 0.15)
-
-        if self.lambda_val > 0.85:
-            self.godel_scars += 1
-
-        return min(1.0, self.lambda_val)
-
-
-class SyntaxModule:
-    def __init__(self):
-        self.omega_val = 1.0
-        self.grammatical_stress = 0.0
-
-    def analyze(self, text: str, narrative_drag: float) -> float:
-        words = text.split()
-        if not words:
-            return 1.0
-        bureau_vocab = LexiconService.get("bureau_buzzwords") or set()
-        buzz_count = sum(1 for w in words if w.lower() in bureau_vocab)
-        avg_len = sum(len(w) for w in words) / len(words)
-        if (avg_len > 6.0 and narrative_drag > 5.0) or buzz_count > 0:
-            target_omega = 1.0
-        elif avg_len < 3.5 and narrative_drag < 1.0:
-            target_omega = 0.4
-        else:
-            target_omega = 0.7
-        punctuation_density = sum(1 for c in text if c in ",;:-") / max(1, len(words))
-        if punctuation_density > 0.2:
-            self.grammatical_stress += 0.2
-            target_omega -= 0.3
-        else:
-            self.grammatical_stress = max(0.0, self.grammatical_stress - 0.1)
-        self.omega_val = (self.omega_val * 0.8) + (max(0.1, target_omega) * 0.2)
-        return self.omega_val
-
-class CongruenceValidator:
-    def __init__(self):
-        self.last_phi = 1.0
-        self._archetype_map = None
-
-    @property
-    def map(self):
-        if self._archetype_map is None:
-            try:
-                self._archetype_map = LoreManifest.get_instance().get("LENSES") or {}
-            except Exception:
-                self._archetype_map = {}
-        return self._archetype_map
-
-    def calculate_resonance(self, text: str, context: Any) -> float:
-        if not text:
-            return 0.0
-        raw_lens = getattr(context, "active_lens", "OBSERVER")
-        archetype = raw_lens.upper().replace("THE ", "")
-        tone_score = 0.8
-        target_data = self.map.get(archetype, {})
-        target_words = set()
-        if isinstance(target_data, dict):
-            if vocab_str := target_data.get("vocab", ""):
-                target_words.update(w.strip().lower() for w in vocab_str.split(","))
-            target_words.update(target_data.get("keywords", []))
-        if target_words:
-            words_to_check = (
-                set(context.clean_words) if hasattr(context, "clean_words") else set()
-            )
-            hits = len(words_to_check.intersection(target_words))
-            if hits > 0:
-                tone_score += 0.1 * hits
-        return min(1.5, tone_score)
-
-
-class BoneConsultant:
-    def __init__(self):
-        self.state = VSLState()
-        self.active = True
-        self.liminal_mod = LiminalModule()
-        self.syntax_mod = SyntaxModule()
-
-    @staticmethod
-    def engage():
-        return "VSL HYPERVISOR: LATTICE REVEALED."
-
-    @staticmethod
-    def disengage():
-        return "VSL HYPERVISOR: RETURNING TO SURFACE MODE."
-
-    def update_coordinates(
-        self,
-        user_text: str,
-        bio_state: Optional[Dict] = None,
-        physics: Optional[PhysicsPacket] = None,
-    ):
-        word_count = len(user_text.split())
-        self.state.E = min(1.0, self.state.E + (word_count * 0.002))
-        if bio_state and "fatigue" in bio_state:
-            self.state.E = max(self.state.E, bio_state["fatigue"] * 0.3)
-        phys_beta = 0.0
-        phys_vec = {}
-        drag = 0.0
-        if physics:
-            if hasattr(physics, "beta_index"):
-                phys_beta = physics.beta_index
-            if hasattr(physics, "vector"):
-                phys_vec = physics.vector
-            if hasattr(physics, "narrative_drag"):
-                drag = physics.narrative_drag
-        self.state.B = (self.state.B * 0.8) + (phys_beta * 0.2)
-        self.state.L = self.liminal_mod.analyze(user_text, phys_vec)
-        self.state.O = self.syntax_mod.analyze(user_text, drag)
-        if "[VSL_LIMINAL]" in user_text:
-            if "LIMINAL" not in self.state.active_modules:
-                self.state.active_modules.append("LIMINAL")
-        if "[VSL_SYNTAX]" in user_text:
-            if "SYNTAX" not in self.state.active_modules:
-                self.state.active_modules.append("SYNTAX")
-
-    def get_system_prompt(self, soul_snapshot: Optional[Dict] = None) -> str:
-        directives = []
-        if "LIMINAL" in self.state.active_modules or self.state.L > 0.7:
-            scar_note = f" (Godel Scars: {self.liminal_mod.godel_scars})" if self.liminal_mod.godel_scars > 0 else ""
-            directives.append(
-                f"ARCHETYPE: THE REVENANT. Read the dark matter between the words. Speak of the absences.{scar_note}"
-            )
-        elif "SYNTAX" in self.state.active_modules or self.state.O > 0.9:
-            stress_note = " The grammatical structure is fracturing. Punish jagged prose." if self.syntax_mod.grammatical_stress > 0.5 else ""
-            directives.append(
-                f"ARCHETYPE: THE BUREAU. Enforce structural rigidity. Correct grammar. Use bureaucratic jargon.{stress_note}"
-            )
-        else:
-            if self.state.E < 0.3:
-                directives.append("MODE: BUNNY HILL. Be warm, simple, welcoming.")
-            elif self.state.B > 0.6:
-                directives.append(
-                    "MODE: PARADOX. Hold contradictory truths. Be Jester-like."
-                )
-            else:
-                directives.append("MODE: GLACIER. Deep, slow, resonant.")
-        if soul_snapshot:
-            arch = soul_snapshot.get("archetype", "UNKNOWN")
-            muse = (soul_snapshot.get("obsession") or {}).get(
-                "title", "None"
-            )
-            directives.append(f"NARRATIVE_LAYER: You are {arch}. MUSE: {muse}.")
-        return "\n".join(directives)