bone_diag.py

"""bone_diag.py - BoneAmanita Master Test Suite - "Trust, but verify. Then verify the verification." """
import io
import os
import random
import time
import unittest
import urllib
from dataclasses import dataclass
from typing import List, Tuple, Optional, Dict
from unittest.mock import MagicMock, patch

from bone_akashic import TheAkashicRecord
from bone_body import (
    SemanticEndocrinologist,
    EndocrineSystem,
    SemanticSignal,
    MitochondrialState,
    MitochondrialForge,
)
from bone_brain import LLMInterface, DreamEngine, ResponseValidator, SynapseError
from bone_brain import NeurotransmitterModulator
from bone_config import BoneConfig
from bone_core import EventBus, Prisma, LoreManifest
from bone_cycle import SoulPhase, GatekeeperPhase, NavigationPhase, MetabolismPhase
from bone_drivers import EnneagramDriver, SoulDriver, LiminalModule, SyntaxModule
from bone_gui import GeodesicRenderer
from bone_inventory import GordonKnot, Item
from bone_lexicon import LexiconStore, LinguisticAnalyzer, SemanticField
from bone_machine import TheCrucible, TheTheremin, PanicRoom, ThePacemaker, TheForge
from bone_main import BoneAmanita
from bone_physics import (
    GeodesicEngine,
    GeodesicConstants,
    CycleStabilizer,
    ZoneInertia,
    TRIGRAM_MAP,
)
from bone_protocols import ZenGarden, TheBureau, TheFolly, KintsugiProtocol, LimboLayer
from bone_soul import TraitVector, HumanityAnchor, NarrativeSelf, TheOroboros
from bone_spores import ImmuneMycelium, BioLichen, BioParasite, MemoryCore
from bone_symbiosis import SymbiosisManager
from bone_types import PhysicsPacket
from bone_village import TheTinkerer, TheCartographer, MirrorGraph, DeathGen, TownHall


@dataclass
class MockLexicon:
    @staticmethod
    def sanitize(text: str) -> List[str]:
        return text.split()

    @staticmethod
    def classify(word: str) -> Tuple[Optional[str], float]:
        if word in ["void", "chaos"]:
            return "abstract", 0.9
        return "neutral", 0.1

    @staticmethod
    def get_random(_cat: str) -> str:
        return "test_word"

    @staticmethod
    def measure_viscosity(word: str) -> float:
        return 0.8 if word == "void" else 0.2


@dataclass
class MockAkashic:

    @staticmethod
    def calculate_manifold_shift(_archetype: str, _traits: Dict) -> Dict:
        return {"shift": 0.5}

    @staticmethod
    def forge_new_item(_vector: Dict) -> Tuple[str, Dict]:
        return "QUANTUM_SPHERE", {
            "description": "A dense ball of mock data.",
            "passive_traits": ["HEAVY"],
        }


class MockLore:
    @staticmethod
    def get_lenses():
        return {
            "JESTER": {
                "role": "The Paradox",
                "directives": ["Break the fourth wall.", "Celebrate entropy."],
            }
        }

    @staticmethod
    def get_item_gen():
        return {
            "PREFIXES": {"kinetic": ["Fast"], "heavy": ["Heavy"]},
            "BASES": {"TOOL": ["Wrench"], "ARTIFACT": ["Orb"]},
            "SUFFIXES": {"kinetic": ["of Speed"], "heavy": ["of Weight"]},
        }


class MockGovernor:
    def recalibrate(self, _v, _d):
        pass

    @staticmethod
    def regulate(_p, _dt):
        return 0.0, 0.0


class TestBed:
    @staticmethod
    def create_physics(voltage=10.0, drag=1.0, psi=0.0, kappa=1.0):
        class DynPhys:
            def __init__(self, v, d, p, k):
                self.voltage = v
                self.narrative_drag = d
                self.psi = p
                self.kappa = k
                self.vector = {}
                self.flow_state = "STANDARD"
                self.zone = "TEST_ZONE"

            def to_dict(self):
                return {
                    "voltage": self.voltage,
                    "narrative_drag": self.narrative_drag,
                    "psi": self.psi,
                    "kappa": self.kappa,
                    "vector": self.vector,
                    "flow_state": self.flow_state,
                    "zone": self.zone,
                }

        return DynPhys(voltage, drag, psi, kappa)

    @staticmethod
    def create_context(physics=None, clean_words=None):
        class DynCtx:
            def __init__(self, phys, cw):
                self.physics = phys or TestBed.create_physics()
                self.clean_words = cw or ["test", "words"]
                self.world_state = {}
                self.is_system_event = False
                self.input_text = "test input"
                self.bio_result = {}
                self.refusal_triggered = False
                self.refusal_packet = None
                self.logs = []

            def log(self, msg):
                self.logs.append(msg)

            def record_flux(self, *args):
                pass

        return DynCtx(physics, clean_words)

    @staticmethod
    def create_engine():
        class DynEng:
            def __init__(self):
                self.lex = MagicMock()
                self.bureau = None
                self.soul = MagicMock()
                self.soul.anchor.dignity_reserve = 50.0
                self.soul.anchor.agency_lock = False
                self.soul.traits.to_dict.return_value = {}
                self.soul.current_obsession = "Testing"
                self.gordon = None
                self.tinkerer = None
                self.navigator = None
                self.oroboros = MagicMock()
                self.oroboros.myths = []
                self.council = MagicMock()
                self.council.convene.return_value = ([], {}, [])
                self.tick_count = 1
                self.mode_settings = {}

            @staticmethod
            def get_metrics(atp=0.0):
                return {"atp": atp, "health": 100.0, "stamina": 100.0}

        return DynEng()


class TestBedrockIntegrity(unittest.TestCase):
    def test_lore_manifest_loading(self):
        print(f"\n{Prisma.CYN}[PROBE] Testing LoreManifest Integrity...{Prisma.RST}")
        manifest = LoreManifest.get_instance()
        narrative = manifest.get("narrative_data")
        self.assertIsNotNone(narrative, "CRITICAL: narrative_data.json failed to load.")
        seeds = narrative.get("SEEDS", [])
        self.assertGreater(len(seeds), 0, "No seeds found in narrative_data.")
        lenses = narrative.get("lenses", {})
        self.assertIn(
            "SHERLOCK", lenses, "Core 'SHERLOCK' lens missing from narrative_data."
        )
        print(f"{Prisma.GRN}   >>> PASS: Bedrock data loaded successfully.{Prisma.RST}")


class TestSomaticPhysics(unittest.TestCase):
    def setUp(self):
        self.events = EventBus()
        self.lex_stub = MagicMock()

    def test_pinker_geodesic_constants(self):
        print(
            f"\n{Prisma.MAG}[PINKER] Testing Geodesic Constants & Logarithmic Friction...{Prisma.RST}"
        )
        self.assertTrue(
            hasattr(GeodesicConstants, "DENSITY_SCALAR"),
            "GeodesicConstants class missing!",
        )
        counts = {"suburban": 500, "heavy": 0}
        clean_words = ["the"] * 500
        vector = GeodesicEngine.collapse_wavefunction(clean_words, counts)
        self.assertLess(
            vector.compression,
            50.0,
            f"Friction Explosion! Drag: {vector.compression:.1f}",
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Logarithmic Friction Active (Drag: {vector.compression:.1f}){Prisma.RST}"
        )

    def test_pinker_mitochondrial_metabolism(self):
        print(
            f"\n{Prisma.MAG}[PINKER] Testing Mitochondrial ATP Burn & Anaerobic Bypass...{Prisma.RST}"
        )
        state = MitochondrialState(
            atp_pool=50.0, ros_buildup=0.0, membrane_potential=0.8
        )
        forge = MitochondrialForge(state, self.events)

        receipt = forge.process_cycle(
            TestBed.create_physics(voltage=10.0, drag=2.0), modifier=1.0
        )
        self.assertEqual(
            receipt.status, "RESPIRING", "Standard cycle should be respiring."
        )
        self.assertLess(
            state.atp_pool, 50.0, "ATP pool did not decrease after standard burn."
        )
        self.assertGreater(
            state.ros_buildup, 0.0, "Cycle failed to generate ROS waste."
        )

        heavy_phys = TestBed.create_physics(voltage=50.0, drag=150.0)
        heavy_phys.E, heavy_phys.C, heavy_phys.D = 1.0, 1.0, 1.0

        heavy_receipt = forge.process_cycle(heavy_phys, modifier=5.0)
        self.assertEqual(
            heavy_receipt.status,
            "ANAEROBIC",
            "Heavy load failed to trigger Anaerobic bypass.",
        )
        self.assertGreater(
            heavy_receipt.total_burn, 0.0, "Anaerobic bypass did not burn health."
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Mitochondria correctly burned ATP, generated ROS, and triggered Anaerobic fallback.{Prisma.RST}"
        )

    def test_meadows_hard_fuse_and_starvation(self):
        print(
            f"\n{Prisma.YEL}[MEADOWS] Testing Hard Fuses and Starvation Clamps...{Prisma.RST}"
        )
        gov = MockGovernor()
        stabilizer = CycleStabilizer(self.events, gov)

        phys = TestBed.create_physics(voltage=105.0)
        phys.flow_state = "CRITICAL"
        ctx = TestBed.create_context(physics=phys)
        ctx.input_text = "System Overload"

        triggered = stabilizer.stabilize(ctx, "TEST_PHASE")
        self.assertTrue(triggered, "Stabilizer did not trigger correction.")
        self.assertEqual(ctx.physics.voltage, 10.0, "Hard Fuse did not reset voltage.")
        print(
            f"{Prisma.GRN}   >>> PASS: Hard Fuse Blew successfully at 105V.{Prisma.RST}"
        )


class TestCognitionAndInventory(unittest.TestCase):
    def setUp(self):
        self.events = EventBus()
        self.lore_mock = MagicMock()
        self.lore_mock.get.side_effect = lambda k: (
            MockLore.get_lenses() if k == "LENSES" else {}
        )

    def test_schur_self_care(self):
        print(
            f"\n{Prisma.VIOLET}[SCHUR] Testing Cognitive Self-Care Routine...{Prisma.RST}"
        )
        bio_stub = MagicMock()
        bio_stub.endo.get_state.return_value = {}
        modulator = NeurotransmitterModulator(bio_stub, self.events)
        modulator.current_chem.dopamine = 0.05
        initial_dop = modulator.current_chem.dopamine
        for _ in range(12):
            modulator.modulate(base_voltage=10.0)
        self.assertGreater(
            modulator.current_chem.dopamine,
            initial_dop,
            "Dopamine did not increase after starvation.",
        )
        print(f"{Prisma.GRN}   >>> PASS: System administered self-care.{Prisma.RST}")

    def test_schur_dream_engine_rem_cycles(self):
        print(
            f"\n{Prisma.VIOLET}[SCHUR] Testing Dream Engine REM Cycles & Nightmares...{Prisma.RST}"
        )
        mock_lore = {
            "DREAMS": {
                "VISIONS": ["A vision of {ghost}"],
                "BARIC": ["Crushing weight on {ghost}"],
            }
        }
        dreamer = DreamEngine(self.events, mock_lore)
        bio_zen = {"chem": {"dopamine": 0.8, "cortisol": 0.1}}
        soul_snap = {"obsession": {"title": "The Light"}}
        dream_lucid, shift_lucid = dreamer.enter_rem_cycle(soul_snap, bio_zen)
        self.assertIn(
            "The Light", dream_lucid, "Dream failed to incorporate soul residue."
        )
        self.assertLess(
            shift_lucid.get("cortisol", 0), 0, "Lucid dream failed to reduce cortisol."
        )
        bio_panic = {"chem": {"cortisol": 0.9}, "trauma_vector": {"BARIC": 10.0}}
        dream_nightmare, shift_nightmare = dreamer.enter_rem_cycle(soul_snap, bio_panic)
        self.assertIn(
            "weight",
            dream_nightmare.lower(),
            "Nightmare failed to pull from BARIC trauma dictionary.",
        )
        self.assertGreater(
            shift_nightmare.get("cortisol", 0),
            0,
            "Nightmare failed to increase cortisol.",
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Dream Engine successfully wove REM cycles based on somatic chemistry and trauma.{Prisma.RST}"
        )

    def test_fuller_inventory_stacking_and_reflexes(self):
        print(
            f"\n{Prisma.CYN}[FULLER] Testing Inventory Reflexes & Diminishing Returns...{Prisma.RST}"
        )
        gordon = GordonKnot(self.events)

        anchor = Item(
            name="ANCHOR_STONE",
            description="Heavy.",
            function="ANCHOR",
            reflex_trigger="DRIFT_CRITICAL",
        )
        gordon.registry["ANCHOR_STONE"] = anchor
        gordon.inventory.append("ANCHOR_STONE")
        phys = {"narrative_drag": 8.0, "voltage": 10.0}
        triggered, msg = gordon.emergency_reflex(phys)
        self.assertTrue(triggered, "Anchor Stone failed to trigger.")
        self.assertEqual(
            phys["narrative_drag"], 0.0, "Anchor Stone failed to zero out drag."
        )
        self.assertNotIn(
            "ANCHOR_STONE", gordon.inventory, "Anchor Stone was not consumed."
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Anchor Stone deployed. Drag neutralized.{Prisma.RST}"
        )


class TestLiveFireIntegration(unittest.TestCase):
    def test_ollama_handshake(self):
        if not LLMInterface:
            print(
                f"\n{Prisma.OCHRE}[LIVE FIRE] LLMInterface not imported. Skipping.{Prisma.RST}"
            )
            self.skipTest("LLMInterface missing")
        print(
            f"\n{Prisma.CYN}[LIVE FIRE] Testing Local LLM Uplink (Ollama)...{Prisma.RST}"
        )
        llm = LLMInterface(
            events_ref=EventBus(),
            provider="ollama",
            base_url="http://127.0.0.1:11434/v1/chat/completions",
            model="mistral-nemo",
        )
        try:
            start_t = time.time()
            response = llm.generate(
                "System check. Reply with the single word: ONLINE.", {"max_tokens": 10}
            )
            duration = time.time() - start_t
            self.assertIsNotNone(response)
            self.assertGreater(len(response), 0)
            if "ONLINE" in response.upper():
                print(
                    f"{Prisma.GRN}   >>> PASS: LLM Responded strictly in {duration:.2f}s.{Prisma.RST}"
                )
            else:
                print(
                    f"{Prisma.OCHRE}   >>> WARN: LLM Drifted: {response.strip()}{Prisma.RST}"
                )
        except Exception as e:
            self.fail(f"LLM Connection Failed: {e}")


class TestSemanticEndocrine(unittest.TestCase):
    def setUp(self):
        self.events = EventBus()
        self.lex_stub = MockLexicon()
        self.akashic_stub = MockAkashic()

    def test_cortisol_spike_on_void_exposure(self):
        print(f"\n{Prisma.RED}[MEADOWS] Testing Somatic Stress Response...{Prisma.RST}")
        endo = EndocrineSystem()
        initial_cortisol = endo.cortisol
        stress_signal = SemanticSignal(
            novelty=0.9, resonance=0.1, valence=-0.8, coherence=0.2
        )
        endo._apply_semantic_pressure(stress_signal)
        self.assertGreater(
            endo.cortisol,
            initial_cortisol,
            "Cortisol failed to spike under negative semantic pressure.",
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Negative valence triggered Cortisol rise (from {initial_cortisol:.2f} to {endo.cortisol:.2f}).{Prisma.RST}"
        )

    def test_semantic_signal_generation(self):
        print(
            f"\n{Prisma.VIOLET}[PINKER] Testing Lexical-to-Chemical Translation...{Prisma.RST}"
        )
        mem_stub = type(
            "MemStub", (), {"check_for_resurrection": lambda self_stub, w, v: None}
        )()
        endocrinologist = SemanticEndocrinologist(
            memory_ref=mem_stub, lexicon_ref=self.lex_stub
        )
        phys = PhysicsPacket(voltage=20.0, narrative_drag=5.0)
        signal = endocrinologist.assess(["void", "chaos", "void"], phys)
        self.assertIsInstance(
            signal,
            SemanticSignal,
            "Endocrinologist did not return a valid SemanticSignal.",
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Semantic signal generated successfully.{Prisma.RST}"
        )

    def test_akashic_handshake(self):
        print(
            f"\n{Prisma.YEL}[FULLER] Testing Akashic-to-Inventory Handshake...{Prisma.RST}"
        )
        gordon = GordonKnot(self.events)
        vector = {"PHI": 0.9, "ENT": 0.1}
        name, data = self.akashic_stub.forge_new_item(vector)
        gordon.register_dynamic_item(name, data)
        retrieved = gordon.get_item_data(name)
        self.assertIsNotNone(retrieved, "Gordon failed to register the forged item.")
        self.assertEqual(
            retrieved.name, "QUANTUM_SPHERE", "Gordon registered the wrong item data."
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Akashic Forge created '{name}', Gordon successfully caught it.{Prisma.RST}"
        )


class TestMechanicalSystems(unittest.TestCase):

    def test_crucible_dampening_and_meltdown(self):
        print(
            f"\n{Prisma.RED}[FULLER] Testing Crucible Load Bearing & Meltdowns...{Prisma.RST}"
        )
        crucible = TheCrucible()
        initial_charges = crucible.dampener_charges
        success, msg, reduction = crucible.dampen(
            voltage_spike=18.0, stability_index=1.0
        )
        self.assertTrue(success, "Crucible failed to dampen a spike above tolerance.")
        self.assertEqual(
            crucible.dampener_charges,
            initial_charges - 1,
            "Dampener charge not consumed.",
        )
        self.assertGreater(reduction, 0.0, "Voltage reduction was 0.")
        crucible.dampen(18.0, 1.0)
        crucible.dampen(18.0, 1.0)
        fail_success, fail_msg, fail_red = crucible.dampen(18.0, 1.0)
        self.assertFalse(fail_success, "Crucible dampened without charges.")
        self.assertIn("EMPTY", fail_msg, "Crucible did not warn of empty dampener.")
        phys_meltdown = {"voltage": 19.0, "kappa": 0.2}
        state, effect, msg = crucible.audit_fire(phys_meltdown)
        self.assertEqual(
            state, "MELTDOWN", "Low structure high voltage did not cause Meltdown."
        )
        phys_ritual = {"voltage": 19.0, "kappa": 0.8}
        state_r, effect_r, msg_r = crucible.audit_fire(phys_ritual)
        self.assertEqual(
            state_r, "RITUAL", "High structure high voltage did not trigger Ritual."
        )
        self.assertGreater(
            crucible.max_voltage_cap,
            20.0,
            "Ritual failed to increase max voltage capacity.",
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Crucible safely exhausted charges and routed voltage to Ritual/Meltdown based on structure.{Prisma.RST}"
        )

    def test_theremin_accumulation_and_airstrike(self):
        print(
            f"\n{Prisma.YEL}[MEADOWS] Testing Theremin Resin Accumulation & Airstrike...{Prisma.RST}"
        )
        theremin = TheTheremin()
        phys_rep = {
            "voltage": 4.0,
            "repetition": 0.8,
            "counts": {"heavy": 1, "abstract": 1},
        }
        msg = ""
        for _ in range(3):
            is_stuck, flow, msg, crit = theremin.listen(phys_rep)
        self.assertGreater(
            theremin.decoherence_buildup, 0.0, "Theremin failed to accumulate Resin."
        )
        self.assertIn("CALCIFICATION", msg, "Theremin did not log Calcification.")
        theremin.decoherence_buildup = 99.0
        phys_strike = {
            "voltage": 10.0,
            "narrative_drag": 2.0,
            "counts": {"abstract": 10, "heavy": 10},
        }
        is_stuck, flow, msg, crit = theremin.listen(phys_strike)
        self.assertEqual(
            crit,
            "AIRSTRIKE",
            "Theremin breached 100 Resin but did not trigger AIRSTRIKE.",
        )
        self.assertEqual(
            theremin.decoherence_buildup, 0.0, "Resin did not reset after AIRSTRIKE."
        )
        self.assertEqual(
            phys_strike["voltage"], 0.0, "AIRSTRIKE did not zero out voltage."
        )
        self.assertGreaterEqual(
            phys_strike["narrative_drag"],
            20.0,
            "AIRSTRIKE did not apply massive narrative drag penalty.",
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Theremin accumulated stock and correctly blew the Airstrike pressure valve.{Prisma.RST}"
        )

    def test_theremin_relief_valves(self):
        print(
            f"\n{Prisma.CYN}[MEADOWS] Testing Theremin Thermal/Turbulence Relief...{Prisma.RST}"
        )
        theremin = TheTheremin()
        theremin.decoherence_buildup = 50.0
        phys_turb = {"turbulence": 0.8, "voltage": 2.0}
        theremin.listen(phys_turb)
        self.assertLess(
            theremin.decoherence_buildup,
            50.0,
            "Turbulence failed to reduce Resin buildup.",
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Turbulence successfully drained the Resin stock.{Prisma.RST}"
        )

    def test_panic_room_fallbacks(self):
        print(
            f"\n{Prisma.VIOLET}[SCHUR] Testing Panic Room Graceful Degradation...{Prisma.RST}"
        )
        safe_phys = PanicRoom.get_safe_physics()
        self.assertEqual(
            safe_phys.flow_state, "SAFE_MODE", "Panic physics not in SAFE_MODE."
        )
        self.assertEqual(
            safe_phys.zone, "PANIC_ROOM", "Panic physics zone is incorrect."
        )
        safe_bio = PanicRoom.get_safe_bio()
        self.assertTrue(
            safe_bio["is_alive"], "Panic bio killed the system instead of saving it."
        )
        self.assertEqual(
            safe_bio["respiration"],
            "NECROSIS",
            "Panic bio respiration not set to fallback.",
        )
        safe_mind = PanicRoom.get_safe_mind()
        self.assertEqual(
            safe_mind["lens"], "GORDON", "Panic mind lens not reset to Gordon."
        )

        print(
            f"{Prisma.GRN}   >>> PASS: Panic Room successfully generated safe fallback states.{Prisma.RST}"
        )

    def test_forge_alchemy_and_hammering(self):
        print(f"\n{Prisma.CYN}[FULLER] Testing TheForge Synthesis...{Prisma.RST}")
        forge = TheForge()
        forge.recipe_map = {
            "ANCHOR_STONE": [{"catalyst_category": "kinetic", "result": "GRAVITY_BOMB"}]
        }

        phys_hammer = {
            "counts": {"heavy": 4, "kinetic": 0},
            "clean_words": ["lead", "lead", "lead", "lead"],
            "voltage": 20.0,
        }
        success, msg, item = forge.hammer_alloy(phys_hammer)
        self.assertTrue(success, "Forge failed to hammer high-density words.")
        self.assertEqual(
            item, "LEAD_BOOTS", "Forge yielded wrong item for heavy words."
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Forge successfully hammered LEAD_BOOTS.{Prisma.RST}"
        )

    def test_pacemaker_boredom(self):
        print(
            f"\n{Prisma.VIOLET}[SCHUR] Testing Pacemaker Boredom Metrics...{Prisma.RST}"
        )
        pace = ThePacemaker()
        pace.BOREDOM_THRESHOLD = 5.0

        for _ in range(6):
            pace.update(repetition_score=0.9, voltage=2.0)

        self.assertTrue(pace.is_bored(), "Pacemaker failed to cross boredom threshold.")
        print(
            f"{Prisma.GRN}   >>> PASS: Pacemaker correctly detected systemic boredom.{Prisma.RST}"
        )


class TestMycelialEcosystem(unittest.TestCase):
    def setUp(self):
        self.events = EventBus()

    def test_pinker_immune_response(self):
        print(
            f"\n{Prisma.MAG}[PINKER] Testing Phonetic Immune Rejection...{Prisma.RST}"
        )
        immune = ImmuneMycelium()
        status_smooth, msg_smooth = immune.assay("flow", None, None, None, None)
        self.assertIsNone(status_smooth, "Immune system rejected a smooth word.")
        status_toxic, msg_toxic = immune.assay("kbdgpt", None, None, None, None)
        self.assertEqual(
            status_toxic,
            "TOXIN_HEAVY",
            "Immune system failed to detect phonetic toxicity.",
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Phonetic density correctly triggered immune response.{Prisma.RST}"
        )

    @patch("bone_spores.LexiconService.get")
    @patch("bone_spores.LexiconService.teach")
    def test_schur_lichen_photosynthesis(self, _mock_teach, mock_get):
        print(
            f"\n{Prisma.VIOLET}[SCHUR] Testing Lichen Sugar Generation...{Prisma.RST}"
        )
        lichen = BioLichen()
        mock_get.return_value = {"rock"}

        phys = TestBed.create_physics(drag=1.0)
        phys.counts = {"photo": 3}

        sugar, msg = lichen.photosynthesize(
            phys, ["solar", "bloom", "rock"], tick_count=1
        )
        self.assertGreater(
            sugar, 0.0, "Lichen failed to generate sugar from photo-words."
        )
        self.assertIn("PHOTOSYNTHESIS", msg, "Lichen did not log photosynthesis event.")
        self.assertIn("SUBLIMATION", msg, "Lichen did not sublimate the heavy word.")
        print(
            f"{Prisma.GRN}   >>> PASS: Lichen successfully converted light into {sugar} ATP/Sugar.{Prisma.RST}"
        )

    def test_fuller_parasitic_bridging(self):
        print(
            f"\n{Prisma.CYN}[FULLER] Testing Parasitic Synapse Forcing...{Prisma.RST}"
        )
        mock_mem = MagicMock()
        mock_mem.graph = {
            "rock": {"edges": {}, "last_tick": 0},
            "void": {"edges": {}, "last_tick": 0},
        }
        mock_lex = MagicMock()
        mock_lex.get.side_effect = lambda cat: {"rock"} if cat == "heavy" else {"void"}
        parasite = BioParasite(mock_mem, mock_lex)
        infected, msg = parasite.infect({"psi": 0.8}, stamina=50.0)
        self.assertTrue(infected, "Parasite failed to infect the graph.")
        self.assertIn(
            "void",
            mock_mem.graph["rock"]["edges"],
            "Parasite failed to bridge rock -> void.",
        )
        self.assertEqual(
            mock_mem.graph["rock"]["edges"]["void"],
            8.88,
            "Parasitic edge weight incorrect.",
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Parasite successfully bridged Heavy and Abstract nodes.{Prisma.RST}"
        )

    def test_meadows_memory_cannibalization(self):
        print(
            f"\n{Prisma.YEL}[MEADOWS] Testing Memory Cannibalization (Stock Limits)...{Prisma.RST}"
        )
        mock_strata = type("MockStrata", (), {"bury": lambda self, data: True})()
        core = MemoryCore(self.events, mock_strata)
        core.graph["old_node"] = {
            "edges": {"x": 1.0},
            "last_tick": 5,
        }
        core.graph["new_node"] = {
            "edges": {"x": 1.0, "y": 1.0},
            "last_tick": 10,
        }
        victim, msg = core.cannibalize(current_tick=12)
        self.assertEqual(victim, "old_node", "Cannibalize selected the wrong node.")
        self.assertNotIn(
            "old_node", core.graph, "Victim node was not removed from graph."
        )
        print(
            f"{Prisma.GRN}   >>> PASS: System properly repressed the weakest memory to protect the limit.{Prisma.RST}"
        )


class TestSoulDynamics(unittest.TestCase):
    def setUp(self):
        self.events = EventBus()

    def test_pinker_trait_normalization(self):
        print(f"\n{Prisma.MAG}[PINKER] Testing Trait Math & Decay...{Prisma.RST}")
        traits = TraitVector(hope=1.8, cynicism=-0.5, wisdom=0.9)
        self.assertEqual(traits.hope, 1.0, "TraitVector failed to clamp upper bound.")
        self.assertEqual(
            traits.cynicism, 0.0, "TraitVector failed to clamp lower bound."
        )
        traits.normalize(decay_rate=0.2)
        self.assertLess(traits.hope, 1.0, "Hope did not decay downward.")
        self.assertGreater(traits.cynicism, 0.0, "Cynicism did not decay upward.")
        print(
            f"{Prisma.GRN}   >>> PASS: Personality traits correctly clamped and decayed to baseline.{Prisma.RST}"
        )

    @patch("bone_core.LoreManifest.get_instance")
    def test_meadows_humanity_anchor_lockdown(self, mock_lore):
        print(
            f"\n{Prisma.YEL}[MEADOWS] Testing Existential Lockdown & Riddle...{Prisma.RST}"
        )
        mock_lore.return_value.get.return_value = [
            {"question": "Who goes there?", "triggers": ["friend"]}
        ]
        anchor = HumanityAnchor(self.events)
        anchor.dignity_reserve = 0.0
        anchor.audit_existence(physics={"voltage": 1.0, "vector": {}}, bio={"atp": 1.0})
        self.assertTrue(
            anchor.agency_lock,
            "Anchor failed to engage lockdown when dignity reached 0.",
        )
        unlocked_fail = anchor.assess_humanity("enemy")
        self.assertFalse(unlocked_fail, "Anchor unlocked with incorrect riddle answer.")
        self.assertTrue(anchor.agency_lock, "Agency lock incorrectly released.")
        unlocked_pass = anchor.assess_humanity("i am a friend")
        self.assertTrue(
            unlocked_pass, "Anchor failed to unlock with correct riddle answer."
        )
        self.assertFalse(
            anchor.agency_lock, "Agency lock remained active after correct answer."
        )
        self.assertEqual(
            anchor.dignity_reserve, 50.0, "Dignity not restored after unlock."
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Anchor successfully locked the system and yielded to the correct password.{Prisma.RST}"
        )

    def test_schur_archetype_shifting(self):
        print(
            f"\n{Prisma.VIOLET}[SCHUR] Testing Identity/Archetype Shifts...{Prisma.RST}"
        )
        soul = NarrativeSelf(
            engine_ref=MagicMock(), events_ref=self.events, memory_ref=MagicMock()
        )
        soul.traits.empathy = 0.9
        soul.traits.hope = 0.9
        soul._update_archetype()
        self.assertEqual(
            soul.archetype, "THE HEALER", "Soul failed to recognize Healer traits."
        )
        soul.traits.empathy = 0.1
        soul.traits.cynicism = 0.9
        soul.traits.hope = 0.2
        soul._update_archetype()
        self.assertEqual(
            soul.archetype, "THE NIHILIST", "Soul failed to recognize Nihilist traits."
        )
        print(
            f"{Prisma.GRN}   >>> PASS: The Soul dynamically shifted its archetype based on mathematical traits.{Prisma.RST}"
        )

    @patch("bone_lexicon.LexiconService.get")
    def test_fuller_obsession_pursuit(self, mock_lex_get):
        print(
            f"\n{Prisma.CYN}[FULLER] Testing Obsession Pursuit & Gravity Assist...{Prisma.RST}"
        )
        mock_lex_get.return_value = {"star", "sky"}
        soul = NarrativeSelf(
            engine_ref=MagicMock(), events_ref=self.events, memory_ref=MagicMock()
        )
        soul.current_obsession = "The Pursuit of Stars"
        soul.current_target_cat = "astronomy"
        phys_packet = {"clean_words": ["star", "dust"], "narrative_drag": 5.0}
        msg = soul.pursue_obsession(phys_packet)
        self.assertIsNotNone(msg, "Muse did not trigger.")
        self.assertGreater(
            soul.obsession_progress, 0.0, "Obsession progress did not advance."
        )
        self.assertLess(
            phys_packet["narrative_drag"],
            5.0,
            "Gravity Assist failed to reduce narrative drag.",
        )
        self.assertIn("SYNERGY", msg, "Did not log synergy.")
        print(
            f"{Prisma.GRN}   >>> PASS: Hitting obsession keywords granted Gravity Assist (reduced drag).{Prisma.RST}"
        )

    def test_oroboros_reincarnation_scars(self):
        print(
            f"\n{Prisma.RED}[FULLER] Testing Oroboros Death & Reincarnation Scars...{Prisma.RST}"
        )
        original_legacy_file = TheOroboros.LEGACY_FILE
        TheOroboros.LEGACY_FILE = "test_legacy.json"
        try:
            if os.path.exists("test_legacy.json"):
                os.remove("test_legacy.json")
            oro = TheOroboros()
            oro.scars = []
            oro.myths = []
            oro.generation_count = 0
            mock_soul = MagicMock()
            mock_soul.core_memories = []
            oro.crystallize(cause_of_death="TOXICITY", soul=mock_soul)
            reborn_oro = TheOroboros()
            self.assertTrue(
                any(s.name == "Burnt Synapses" for s in reborn_oro.scars),
                "Oroboros did not apply Toxicity scar upon rebirth.",
            )
            phys = {"voltage": 15.0, "narrative_drag": 0.0}
            bio = {}
            log = reborn_oro.apply_legacy(phys, bio)
            self.assertEqual(
                phys["voltage"],
                10.0,
                "Burnt Synapses failed to penalize voltage capacity.",
            )
            self.assertTrue(
                any("Burnt Synapses" in l for l in log),
                "Legacy log missing scar application.",
            )
            print(
                f"{Prisma.GRN}   >>> PASS: Oroboros successfully crystallized death and scarred the next generation.{Prisma.RST}"
            )
        finally:
            TheOroboros.LEGACY_FILE = original_legacy_file
            if os.path.exists("test_legacy.json"):
                os.remove("test_legacy.json")


class TestSlashAkashic(unittest.TestCase):
    def setUp(self):
        self.events = EventBus()
        self.mock_lore = MagicMock()
        self.mock_lore.get.side_effect = self._mock_lore_get
        self.captured_events = []

        def capture(payload):
            self.captured_events.append(payload)

        self.events.subscribe("RESONANCE_ACHIEVED", capture)
        self.akashic = TheAkashicRecord(
            lore_manifest=self.mock_lore, events_ref=self.events
        )

    @staticmethod
    def _mock_lore_get(key):
        if key == "LENSES":
            return {
                "THE POET": {"weights": {"voltage": 5.0, "drag": 1.0}},
                "THE ENGINEER": {"weights": {"voltage": 1.0, "drag": 5.0}},
                "_META_RESONANCE_": [
                    {
                        "trigram": "ZHEN",
                        "lens": "MANIC",
                        "result": "STORM_CHASER",
                        "msg": "Thunder resonates.",
                    }
                ],
            }
        elif key == "GORDON":
            return {"ITEM_REGISTRY": {}}
        return None

    def test_fuller_lens_hybridization(self):
        print(
            f"\n{Prisma.CYN}[FULLER] Testing Emergent Lens Hybridization...{Prisma.RST}"
        )
        for _ in range(self.akashic.HYBRID_LENS_THRESHOLD):
            self.akashic.record_interaction(["THE POET", "THE ENGINEER"])
        self.mock_lore.inject.assert_called()
        args, kwargs = self.mock_lore.inject.call_args
        target_dict, injected_data = args
        self.assertEqual(
            target_dict, "LENSES", "Akashic did not target LENSES for injection."
        )
        self.assertIn(
            "THE ENGINEER-POET",
            injected_data,
            "Akashic did not create the correctly named hybrid lens.",
        )
        new_weights = injected_data["THE ENGINEER-POET"]["weights"]
        self.assertEqual(new_weights["voltage"], 3.0, "Hybrid voltage math incorrect.")
        self.assertEqual(new_weights["drag"], 3.0, "Hybrid drag math incorrect.")
        print(
            f"{Prisma.GRN}   >>> PASS: Akashic Record successfully fused two lenses into a new paradigm.{Prisma.RST}"
        )

    def test_meadows_meta_resonance(self):
        print(
            f"\n{Prisma.YEL}[MEADOWS] Testing Meta-Resonance (Physics to Event)...{Prisma.RST}"
        )
        payload = {"lens": "MANIC", "physics": {"vector": {"VEL": 0.9, "STR": 0.1}}}
        self.akashic._on_mythology_update(payload)
        self.assertTrue(
            len(self.captured_events) > 0,
            "Akashic failed to fire RESONANCE_ACHIEVED event.",
        )
        self.assertEqual(
            self.captured_events[0]["result"],
            "STORM_CHASER",
            "Akashic fired the wrong resonance.",
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Physics vector correctly aligned with trigram to trigger Meta-Resonance.{Prisma.RST}"
        )

    def test_pinker_artifact_forging(self):
        print(
            f"\n{Prisma.MAG}[PINKER] Testing Akashic Artifact Generation...{Prisma.RST}"
        )
        vector = {"PHI": 0.8, "ENT": 0.2}
        name, data = self.akashic.forge_new_item(vector)
        self.assertTrue(
            name.startswith("SOLAR_ARTIFACT_8_"),
            "Artifact prefix did not match dominant force.",
        )
        self.assertIn(
            "CONDUCTIVE_HAZARD",
            data["passive_traits"],
            "High PHI did not grant conductive hazard trait.",
        )
        self.mock_lore.inject.assert_called()
        args, _ = self.mock_lore.inject.call_args
        self.assertEqual(
            args[0], "GORDON", "Akashic did not inject artifact into GORDON registry."
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Akashic successfully generated and registered a new artifact based on physics.{Prisma.RST}"
        )


class TestVillageEcosystem(unittest.TestCase):
    def setUp(self):
        self.events = EventBus()
        DeathGen.load_protocols()

    def test_meadows_tinkerer_passives(self):
        print(
            f"\n{Prisma.YEL}[MEADOWS] Testing Tinkerer Inventory Physics...{Prisma.RST}"
        )
        tinkerer = TheTinkerer(
            gordon_ref=MagicMock(), events_ref=self.events, akashic_ref=MagicMock()
        )
        inventory_data = [
            {"name": "Lead Boots", "passive_traits": ["HEAVY_LOAD"]},
            {"name": "Pocket Watch", "passive_traits": ["TIME_DILATION"]},
        ]
        deltas = tinkerer.calculate_passive_deltas(inventory_data)
        heavy_delta = next((d for d in deltas if d.message == "Heavy Load"), None)
        self.assertIsNotNone(heavy_delta, "Tinkerer missed HEAVY_LOAD trait.")
        self.assertEqual(heavy_delta.operator, "ADD", "Heavy Load should ADD drag.")
        self.assertGreater(heavy_delta.value, 0.0, "Heavy Load drag value is 0.")
        time_delta = next((d for d in deltas if d.message == "Time Dilation"), None)
        self.assertIsNotNone(time_delta, "Tinkerer missed TIME_DILATION trait.")
        self.assertEqual(
            time_delta.operator, "MULT", "Time Dilation should MULTIPLY drag."
        )
        self.assertLess(
            time_delta.value,
            1.0,
            "Time Dilation failed to reduce drag multiplier below 1.0.",
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Tinkerer correctly translated item traits into PhysicsDeltas.{Prisma.RST}"
        )

    def test_fuller_cartographer_navigation(self):
        print(
            f"\n{Prisma.CYN}[FULLER] Testing Cartographer Geography & Environment...{Prisma.RST}"
        )
        cartographer = TheCartographer(shimmer_ref=MagicMock())

        packet = PhysicsPacket(
            vector={"STR": 0.9, "VEL": 0.8}, voltage=5.0, narrative_drag=1.0
        )
        loc_name, msg = cartographer.locate(packet)
        self.assertIsNotNone(loc_name)
        self.assertIn(
            "STR90-VEL80",
            cartographer.world_graph,
            "Cartographer failed to hash and store the new coordinates.",
        )
        current_node = cartographer.world_graph[cartographer.current_node_id]
        current_node.atmosphere = "It is very heavy here."
        logs = cartographer.apply_environment(packet)
        self.assertGreater(
            packet.narrative_drag,
            1.0,
            "Heavy atmosphere failed to apply narrative drag.",
        )
        self.assertTrue(
            any("heavy" in log.lower() for log in logs), "Environment log missing."
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Cartographer mapped vector to location and applied environmental physics.{Prisma.RST}"
        )

    def test_pinker_mirror_graph_reflection(self):
        print(
            f"\n{Prisma.MAG}[PINKER] Testing Mirror Graph Punctuation Analysis...{Prisma.RST}"
        )
        mirror = MirrorGraph(events_ref=self.events)
        packet_art = PhysicsPacket(
            raw_text="What is this place?", voltage=5.0, narrative_drag=1.0
        )
        mirror.reflect(packet_art)
        packet_war = PhysicsPacket(
            raw_text="Watch out!", voltage=50.0, narrative_drag=1.0
        )
        mirror.reflect(packet_war)
        self.assertGreater(
            mirror.stats["ART"], 0.0, "Mirror failed to register ART (?)"
        )
        self.assertGreater(
            mirror.stats["WAR"], 0.0, "Mirror failed to register WAR (!)"
        )
        modifiers = mirror.get_reflection_modifiers()
        self.assertIn(
            "WAR",
            modifiers["flavor"],
            "Mirror failed to identify the dominant reflection.",
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Mirror Graph accurately reflected punctuation and voltage into disposition.{Prisma.RST}"
        )

    def test_schur_death_generator(self):
        print(
            f"\n{Prisma.VIOLET}[SCHUR] Testing Death Generation Diagnostics...{Prisma.RST}"
        )
        gluttony_packet = PhysicsPacket(voltage=999.0, narrative_drag=0.0)
        _, cause_g = DeathGen.eulogy(gluttony_packet, mito_state={"atp": 50.0})
        self.assertEqual(
            cause_g,
            "GLUTTONY",
            "DeathGen failed to diagnose Gluttony from high voltage.",
        )
        starve_packet = PhysicsPacket(voltage=5.0, narrative_drag=0.0)
        _, cause_s = DeathGen.eulogy(starve_packet, mito_state={"atp": 0.0})
        self.assertEqual(
            cause_s, "STARVATION", "DeathGen failed to diagnose Starvation from 0 ATP."
        )
        bored_packet = PhysicsPacket(voltage=5.0, narrative_drag=99.0)
        _, cause_b = DeathGen.eulogy(bored_packet, mito_state={"atp": 50.0})
        self.assertEqual(
            cause_b, "BOREDOM", "DeathGen failed to diagnose Boredom from high drag."
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Death Generator correctly diagnosed causes of system termination.{Prisma.RST}"
        )


class TestGordonInventory(unittest.TestCase):
    def setUp(self):
        self.events = EventBus()

    @patch("bone_core.LoreManifest.get_instance")
    def test_pinker_natural_language_parsing(self, mock_lore):
        print(f"\n{Prisma.MAG}[PINKER] Testing Organic Loot Parsing...{Prisma.RST}")
        mock_lore.return_value.get.return_value = {}
        gordon = GordonKnot(self.events)
        user_in = "I carefully"
        sys_out = "picked up a silver key from the table."
        found = gordon.parse_loot(user_in, sys_out)
        self.assertEqual(
            found, "silver key", "Gordon failed to extract the organic item."
        )
        sys_out_refusal = "I try, but I cannot pick up the heavy anvil."
        found_refused = gordon.parse_loot(user_in, sys_out_refusal)
        self.assertIsNone(
            found_refused,
            "Gordon ignored the 'cannot' refusal marker and looted anyway.",
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Natural language extraction respects syntax and refusal bounds.{Prisma.RST}"
        )

    @patch("bone_core.LoreManifest.get_instance")
    def test_schur_explicit_tag_processing(self, mock_lore):
        print(
            f"\n{Prisma.VIOLET}[SCHUR] Testing [[LOOT]] / [[LOST]] Tag Extraction...{Prisma.RST}"
        )
        mock_lore.return_value.get.return_value = {}
        gordon = GordonKnot(self.events)
        gordon.inventory = ["OLD_RATIONS"]
        text = "You open the chest. [[LOOT: Magic Sword]] [[LOST: Old Rations]]"
        user_in = "I take the contents."
        clean_text, logs = gordon.process_loot_tags(text, user_in)
        self.assertNotIn("[[LOOT:", clean_text, "Loot tag was not stripped from text.")
        self.assertIn(
            "MAGIC_SWORD", gordon.inventory, "Gordon failed to add tagged loot."
        )
        self.assertNotIn(
            "OLD_RATIONS", gordon.inventory, "Gordon failed to remove tagged lost item."
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Explicit tags successfully parsed and applied to inventory.{Prisma.RST}"
        )

    @patch("bone_core.LoreManifest.get_instance")
    def test_meadows_fifo_capacity_limits(self, mock_lore):
        print(
            f"\n{Prisma.YEL}[MEADOWS] Testing Inventory Stock Limits (FIFO)...{Prisma.RST}"
        )
        mock_lore.return_value.get.return_value = {}
        gordon = GordonKnot(self.events)
        gordon.max_slots = 3
        gordon.acquire("ITEM_1")
        gordon.acquire("ITEM_2")
        gordon.acquire("ITEM_3")
        gordon.acquire("ITEM_4")
        self.assertEqual(len(gordon.inventory), 3, "Inventory exceeded max slots.")
        self.assertNotIn("ITEM_1", gordon.inventory, "Oldest item was not dropped.")
        self.assertIn("ITEM_4", gordon.inventory, "Newest item was not added.")
        print(
            f"{Prisma.GRN}   >>> PASS: Inventory safely dropped oldest item when capacity breached.{Prisma.RST}"
        )

    @patch("bone_core.LoreManifest.get_instance")
    def test_fuller_stamina_rummaging(self, mock_lore):
        print(f"\n{Prisma.CYN}[FULLER] Testing Rummage Stamina Tax...{Prisma.RST}")
        mock_lore.return_value.get.return_value = {}
        gordon = GordonKnot(self.events)
        gordon.registry["POCKET_LINT"] = Item(
            "POCKET_LINT", "Dust.", "MISC", spawn_context="COMMON"
        )
        success_fail, msg, cost = gordon.rummage(physics_ref={}, stamina_pool=5.0)
        self.assertFalse(success_fail, "Gordon rummaged without enough stamina.")
        success_pass, msg, cost = gordon.rummage(physics_ref={}, stamina_pool=50.0)
        self.assertTrue(
            success_pass, "Gordon failed to rummage despite having stamina."
        )
        self.assertEqual(cost, 15.0, "Rummage returned incorrect stamina cost.")
        self.assertIn(
            "POCKET_LINT", gordon.inventory, "Gordon did not acquire the rummaged item."
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Rummaging correctly checked ATP/Stamina bounds before yielding loot.{Prisma.RST}"
        )


class TestLexicalSystems(unittest.TestCase):
    def setUp(self):
        self.store = LexiconStore()
        self.store.VOCAB["sentiment_pos"] = {"good", "joy", "bright"}
        self.store.VOCAB["sentiment_neg"] = {"bad", "pain", "dark"}
        self.store.VOCAB["sentiment_negators"] = {"not", "never", "no"}
        self.store.VOCAB["heavy"] = {"lead", "iron", "rock"}
        self.store.VOCAB["kinetic"] = {"dash", "run", "speed"}
        self.store.SOLVENTS = {"the", "a", "an", "is"}
        for cat, words in self.store.VOCAB.items():
            for w in words:
                self.store._index_word(w, cat)
        self.analyzer = LinguisticAnalyzer(self.store)

    def test_pinker_viscosity_and_turbulence(self):
        print(
            f"\n{Prisma.MAG}[PINKER] Testing Phonetic Viscosity & Turbulence...{Prisma.RST}"
        )
        visc_plosive = self.analyzer.measure_viscosity("kbdgpt")
        visc_liquid = self.analyzer.measure_viscosity("flowery")
        self.assertGreater(visc_plosive, 0.0, "Plosive viscosity failed to calculate.")
        self.assertGreater(visc_liquid, 0.0, "Liquid viscosity failed to calculate.")
        turb_low = self.analyzer.get_turbulence(["cat", "dog", "bat"])
        turb_high = self.analyzer.get_turbulence(["a", "hippopotamus", "is", "large"])
        self.assertEqual(
            turb_low, 0.0, "Turbulence should be 0 for words of equal length."
        )
        self.assertGreater(
            turb_high, 0.0, "Turbulence failed to detect length variance."
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Phonetic viscosity and length-variance turbulence mathematically sound.{Prisma.RST}"
        )

    def test_schur_valence_and_negation(self):
        print(f"\n{Prisma.VIOLET}[SCHUR] Testing Sentiment & Negation...{Prisma.RST}")
        val_pos = self.analyzer.measure_valence(["good", "joy"])
        self.assertGreater(val_pos, 0.0, "Failed to detect positive valence.")
        val_neg = self.analyzer.measure_valence(["bad", "pain"])
        self.assertLess(val_neg, 0.0, "Failed to detect negative valence.")
        val_negated = self.analyzer.measure_valence(["not", "good"])
        self.assertLess(
            val_negated, 0.0, "Negator failed to invert positive sentiment."
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Valence logic correctly handled baseline and negated sentiments.{Prisma.RST}"
        )

    def test_fuller_vector_mapping(self):
        print(f"\n{Prisma.CYN}[FULLER] Testing Lexical Vectorization...{Prisma.RST}")
        vector = self.analyzer.vectorize("lead run lead")
        self.assertIn("STR", vector, "Vector failed to map 'heavy' to STR.")
        self.assertIn("VEL", vector, "Vector failed to map 'kinetic' to VEL.")
        self.assertGreater(
            vector["STR"], vector["VEL"], "Proportional vector mapping failed."
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Words successfully mapped to dimensional vectors (STR, VEL).{Prisma.RST}"
        )

    def test_meadows_semantic_field_flux(self):
        print(f"\n{Prisma.YEL}[MEADOWS] Testing Semantic Field Momentum...{Prisma.RST}")
        field = SemanticField(self.analyzer)
        field.update("lead iron rock")
        self.assertEqual(field.momentum, 0.0, "Initial momentum should be 0.")
        field.update("dash run speed")
        self.assertGreater(
            field.momentum, 0.0, "Semantic shift failed to generate momentum."
        )
        atmosphere = field.get_atmosphere()
        self.assertTrue(
            "Volatile" in atmosphere or "Stable" in atmosphere,
            "Failed to generate atmosphere string.",
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Semantic Field correctly accumulated flux momentum across turns.{Prisma.RST}"
        )

    def test_pinker_hive_learning(self):
        print(f"\n{Prisma.MAG}[PINKER] Testing Hive Vocabulary Learning...{Prisma.RST}")
        taught = self.store.teach("neologism", "abstract", tick=1)
        self.assertTrue(taught, "Store refused to learn a new word.")
        abstract_words = self.store.get_raw("abstract")
        self.assertIn(
            "neologism",
            abstract_words,
            "Learned word not returned in category raw fetch.",
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Hive memory successfully integrated and retrieved new vocabulary.{Prisma.RST}"
        )


class TestDriversAndPersonas(unittest.TestCase):
    def setUp(self):
        self.events = EventBus()

    def test_meadows_enneagram_hysteresis(self):
        print(
            f"\n{Prisma.YEL}[MEADOWS] Testing Enneagram Persona Hysteresis...{Prisma.RST}"
        )
        driver = EnneagramDriver(self.events)
        phys_clarence = {"narrative_drag": 10.0, "kappa": 0.9, "voltage": 1.0}
        persona, state, reason = driver.decide_persona(phys_clarence)
        self.assertEqual(
            driver.pending_persona, "CLARENCE", "Clarence not set as pending."
        )
        self.assertEqual(
            driver.current_persona,
            "NARRATOR",
            "Persona shifted without hysteresis delay.",
        )
        for _ in range(driver.HYSTERESIS_THRESHOLD):
            persona, state, reason = driver.decide_persona(phys_clarence)
        self.assertEqual(
            driver.current_persona,
            "CLARENCE",
            "Persona failed to shift after hysteresis met.",
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Persona shifting correctly delayed by hysteresis threshold.{Prisma.RST}"
        )

    def test_pinker_soul_driver_influence(self):
        print(f"\n{Prisma.MAG}[PINKER] Testing Soul Archetype Influence...{Prisma.RST}")
        mock_soul = MagicMock()
        mock_soul.archetype = "THE POET"
        mock_soul.paradox_accum = 0.0
        mock_soul.anchor.dignity_reserve = 100.0
        sd = SoulDriver(mock_soul)
        influence = sd.get_influence()
        self.assertGreater(
            influence.get("NATHAN", 0.0), 0.5, "Poet failed to influence Nathan."
        )
        self.assertGreater(
            influence.get("JESTER", 0.0), 0.2, "Poet failed to influence Jester."
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Soul Archetype successfully injected weighted influence into persona pool.{Prisma.RST}"
        )

    @patch("bone_lexicon.LexiconService.get_current_category")
    @patch("bone_lexicon.LexiconService.get")
    def test_fuller_liminal_and_syntax_analysis(self, mock_lex_get, mock_get_cat):
        print(
            f"\n{Prisma.CYN}[FULLER] Testing Liminal & Syntax Module Calculus...{Prisma.RST}"
        )
        mock_lex_get.side_effect = lambda cat: (
            {"void"} if cat == "liminal" else {"bureaucratic"}
        )
        mock_get_cat.side_effect = lambda w: (
            "void" if w == "void" else ("heavy" if w == "the" else "neutral")
        )
        lim_mod = LiminalModule()
        syn_mod = SyntaxModule()
        lambda_val = lim_mod.analyze("staring into the void", {"PSI": 1.0})
        self.assertGreater(
            lambda_val, 0.0, "Liminal module failed to detect 'void' and PSI."
        )
        omega_val = syn_mod.analyze("bureaucratic establishment", narrative_drag=10.0)
        self.assertGreater(
            omega_val,
            0.8,
            "Syntax module failed to increase Omega under high drag and length.",
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Modifiers correctly calculated Lambda (Liminal) and Omega (Syntax) values.{Prisma.RST}"
        )


class TestDeepLexicon(unittest.TestCase):
    def setUp(self):
        self.store = LexiconStore()
        self.store.VOCAB["heavy"] = {"lead", "iron", "stone"}
        self.store.VOCAB["kinetic"] = {"dash", "bolt", "rush"}
        self.store.VOCAB["sentiment_pos"] = {"joy", "bright"}
        self.store.VOCAB["sentiment_neg"] = {"dark", "pain"}
        self.store.VOCAB["sentiment_negators"] = {"not", "never"}
        for cat, words in self.store.VOCAB.items():
            for w in words:
                self.store._index_word(w, cat)

        self.analyzer = LinguisticAnalyzer(self.store)

    def test_pinker_viscosity_calculus(self):
        print(f"\n{Prisma.MAG}[PINKER] Testing Viscosity Calculus...{Prisma.RST}")
        visc_iron = self.analyzer.measure_viscosity("iron")
        visc_plosive = self.analyzer.measure_viscosity("btkp")
        self.assertGreater(
            visc_plosive,
            visc_iron,
            "Phonetic plosives should be more viscous than liquids.",
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Phonetic viscosity correctly weighted plosives over liquids.{Prisma.RST}"
        )

    def test_schur_valence_negation_complex(self):
        print(
            f"\n{Prisma.VIOLET}[SCHUR] Testing Complex Valence Negation...{Prisma.RST}"
        )
        valence = self.analyzer.measure_valence(["not", "joy"])
        self.assertLess(valence, 0.0, "Negator failed to invert positive valence.")
        self.assertEqual(valence, -0.5, "Negation attenuation math failed.")
        print(
            f"{Prisma.GRN}   >>> PASS: Valence logic correctly handled the 'not joy' inversion.{Prisma.RST}"
        )

    def test_meadows_semantic_field_dynamics(self):
        print(
            f"\n{Prisma.YEL}[MEADOWS] Testing Semantic Field Momentum & Flux...{Prisma.RST}"
        )
        field = SemanticField(self.analyzer)
        field.update("lead iron stone")
        initial_vec = field.current_vector.copy()
        self.assertIn("STR", initial_vec, "Failed to establish initial STR vector.")
        field.update("dash bolt rush")
        self.assertGreater(
            field.momentum, 0.0, "Semantic shift failed to generate momentum."
        )
        self.assertIn("VEL", field.current_vector, "Vector failed to shift to VEL.")
        self.assertGreater(
            field.current_vector["STR"],
            0.0,
            "Blended vector lost all previous state too quickly.",
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Semantic Field correctly blended states and tracked momentum flux.{Prisma.RST}"
        )

    def test_fuller_phonetic_classification(self):
        print(
            f"\n{Prisma.CYN}[FULLER] Testing Phonetic Auto-Classification...{Prisma.RST}"
        )
        cat, score = self.analyzer.classify_word("kbdgpt")
        self.assertEqual(
            cat, "heavy", "Dense plosive string failed to auto-classify as 'heavy'."
        )
        cat_v, score_v = self.analyzer.classify_word("lalala")
        self.assertEqual(
            cat_v, "play", "Vowel-rich string failed to auto-classify as 'play'."
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Phonetic density correctly categorized unknown words.{Prisma.RST}"
        )


class TestLexicalSubstrate(unittest.TestCase):
    def setUp(self):
        self.store = LexiconStore()
        self.store.VOCAB["heavy"] = {"stone", "iron", "lead"}
        self.store.VOCAB["play"] = {"dance", "sing", "jump"}
        self.store.VOCAB["sentiment_pos"] = {"joy", "bright"}
        self.store.VOCAB["sentiment_negators"] = {"not"}
        self.store.SOLVENTS = {"the", "a"}
        for cat, words in self.store.VOCAB.items():
            for w in words:
                self.store._index_word(w, cat)
        self.analyzer = LinguisticAnalyzer(self.store)

    def test_pinker_viscosity_math(self):
        print(
            f"\n{Prisma.MAG}[PINKER] Testing Viscosity & Phonetic Density...{Prisma.RST}"
        )
        v_heavy = self.analyzer.measure_viscosity("ironstone")
        v_light = self.analyzer.measure_viscosity("a")
        self.assertGreater(v_heavy, v_light, "Phonetic viscosity calculation failed.")
        cat, score = self.analyzer.classify_word("kbdgpt")
        self.assertEqual(
            cat, "heavy", f"Phonetic density failed to classify 'heavy'. Got: {cat}"
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Phonetic math correctly mapped sound to viscosity.{Prisma.RST}"
        )

    def test_schur_valence_negation(self):
        print(
            f"\n{Prisma.VIOLET}[SCHUR] Testing Sentiment Look-behind Negation...{Prisma.RST}"
        )
        val_pure = self.analyzer.measure_valence(["joy"])
        val_neg = self.analyzer.measure_valence(["not", "joy"])
        self.assertGreater(val_pure, 0.0)
        self.assertLess(val_neg, 0.0, "Negator failed to invert sentiment.")
        self.assertEqual(val_neg, -0.5, "Negation attenuation factor incorrect.")
        print(
            f"{Prisma.GRN}   >>> PASS: Valence engine correctly parsed 'not joy' as negative.{Prisma.RST}"
        )

    def test_meadows_field_flux(self):
        print(f"\n{Prisma.YEL}[MEADOWS] Testing Semantic Field Momentum...{Prisma.RST}")
        field = SemanticField(self.analyzer)
        field.update("stone iron lead")
        field.update("dance sing jump")
        field.update("stone iron lead")
        field.update("dance sing jump")
        self.assertGreater(
            field.momentum,
            0.5,
            f"Momentum ({field.momentum:.2f}) failed to breach threshold.",
        )
        self.assertIn(
            "Volatile", field.get_atmosphere(), "Field failed to reach Volatile state."
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Semantic Field correctly accumulated momentum across turns.{Prisma.RST}"
        )

    def test_fuller_hive_indexing(self):
        print(
            f"\n{Prisma.CYN}[FULLER] Testing Hive Learning & Reverse Indexing...{Prisma.RST}"
        )
        self.store.teach("neologism", "abstract", tick=1)
        harvested = self.store.harvest("A strange neologism.")
        self.assertIn("abstract", harvested)
        self.assertIn("neologism", harvested["abstract"])
        cats = self.store.get_categories_for_word("neologism")
        self.assertIn("abstract", cats)
        print(
            f"{Prisma.GRN}   >>> PASS: The Hive successfully learned and indexed new vocabulary.{Prisma.RST}"
        )


class TestCosmicPhysics(unittest.TestCase):
    def setUp(self):
        self.events = EventBus()

    def test_pinker_trigram_mapping(self):
        print(f"\n{Prisma.MAG}[PINKER] Testing Trigram & Color Mapping...{Prisma.RST}")
        for dim in ["VEL", "STR", "ENT", "PHI", "PSI", "BET", "E", "DEL"]:
            self.assertIn(dim, TRIGRAM_MAP, f"Missing Trigram mapping for {dim}")
            icon, name, label, color = TRIGRAM_MAP[dim]
            self.assertIsNotNone(icon)
            self.assertIsNotNone(color)
        print(
            f"{Prisma.GRN}   >>> PASS: Core Trigram mapping is complete and color-coded.{Prisma.RST}"
        )

    def test_meadows_zone_inertia(self):
        print(
            f"\n{Prisma.YEL}[MEADOWS] Testing Zone Inertia & Migration...{Prisma.RST}"
        )
        inertia = ZoneInertia(inertia=0.9)
        physics = {"beta_index": 1.0, "truth_ratio": 0.5}
        cosmic_state = ("STABLE_ORBIT", 0.0, "Orbiting")
        zone, msg = inertia.stabilize("AERIE", physics, cosmic_state)
        self.assertEqual(
            zone, "COURTYARD", "Inertia failed to resist immediate migration."
        )
        print(
            f"{Prisma.GRN}   >>> PASS: ZoneInertia successfully resisted narrative drift.{Prisma.RST}"
        )

    def test_fuller_cosmic_dynamics_manifolds(self):
        print(f"\n{Prisma.CYN}[FULLER] Testing Manifold Field Dynamics...{Prisma.RST}")
        mock_gov = MagicMock()
        mock_gov.regulate.return_value = (0.0, 0.0)
        stabilizer = CycleStabilizer(self.events, mock_gov)

        phys = TestBed.create_physics(voltage=18.0)
        phys.manifold = "DEFAULT"
        phys.flow_state = "SUPERCONDUCTIVE"
        ctx = TestBed.create_context(physics=phys)

        stabilizer.stabilize(ctx, "TEST_PHASE")
        mock_gov.recalibrate.assert_called()
        args, _ = mock_gov.recalibrate.call_args
        self.assertEqual(
            args[0],
            18.0,
            "Stabilizer failed to apply Superconductive voltage override.",
        )
        print(
            f"{Prisma.GRN}   >>> PASS: CycleStabilizer correctly handled flow-state manifold overrides.{Prisma.RST}"
        )


class TestVillageSocialLogic(unittest.TestCase):
    def setUp(self):
        self.events = EventBus()

    def test_schur_zen_garden_stillness(self):
        msg = ""
        print(
            f"\n{Prisma.VIOLET}[SCHUR] Testing Zen Garden Stillness Streaks...{Prisma.RST}"
        )
        garden = ZenGarden(self.events)

        stable_phys = TestBed.create_physics(voltage=5.0, drag=1.0)

        for i in range(5):
            boost, msg = garden.raking_the_sand(stable_phys, {})
        self.assertEqual(garden.stillness_streak, 5, "Zen streak failed to increment.")
        self.assertEqual(
            garden.pebbles_collected, 1, "Failed to collect pebble on streak 5."
        )
        self.assertIsNotNone(msg, "Koan message missing on streak milestone.")

        unstable_phys = TestBed.create_physics(voltage=25.0, drag=1.0)

        garden.raking_the_sand(unstable_phys, {})
        self.assertEqual(
            garden.stillness_streak, 0, "Zen streak failed to reset on turbulence."
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Zen Garden correctly rewarded poise and reset on chaos.{Prisma.RST}"
        )

    @patch("bone_core.LoreManifest.get_instance")
    def test_fuller_bureau_auditing(self, mock_lore):
        print(f"\n{Prisma.CYN}[FULLER] Testing Bureau Style Audits...{Prisma.RST}")
        mock_lore.return_value.get.return_value = {
            "PATTERNS": [
                {
                    "name": "EXCESSIVE_DOTS",
                    "regex": r"\.\.\.\.",
                    "error_msg": "Too many dots.",
                    "tax": 10.0,
                }
            ]
        }
        with patch("bone_config.BoneConfig.BUREAU") as mock_cfg:
            mock_cfg.MIN_WORD_COUNT = 3
            mock_cfg.MIN_HEALTH_TO_AUDIT = 20
            bureau = TheBureau()

            phys = TestBed.create_physics(voltage=5.0)
            phys.raw_text = "Wait for the dots...."
            phys.clean_words = ["wait", "for", "the", "dots"]

            result = bureau.audit(phys, {"health": 100.0})
            self.assertIsNotNone(
                result,
                "Bureau failed to detect a Style Violation (Check word count/config).",
            )
            self.assertEqual(
                result["atp_gain"], -10.0, "Bureau failed to levy the correct tax."
            )
            self.assertIn(
                "EXCESSIVE_DOTS", result["ui"], "Violation name missing from UI report."
            )
        print(
            f"{Prisma.GRN}   >>> PASS: The Bureau successfully identified a style crime and levied a tax.{Prisma.RST}"
        )

    @patch("bone_lexicon.LexiconService.get")
    def test_meadows_folly_digestion(self, mock_lex_get):
        print(
            f"\n{Prisma.YEL}[MEADOWS] Testing The Folly (ATP Metabolism)...{Prisma.RST}"
        )
        mock_lex_get.side_effect = lambda cat: {"iron"} if cat == "heavy" else set()
        folly = TheFolly()
        mode, msg, yield_atp, loot = folly.grind_the_machine(10.0, ["iron"], {})
        self.assertEqual(
            mode, "MEAT_GRINDER", "Folly failed to identify heavy word as meat."
        )
        self.assertGreater(yield_atp, 0.0, "Folly generated no ATP from meat.")
        mode_2, msg_2, yield_2, loot_2 = folly.grind_the_machine(10.0, ["iron"], {})
        self.assertEqual(
            mode_2, "REGURGITATION", "Folly failed to detect repeated word."
        )
        self.assertLess(yield_2, 0.0, "Folly failed to penalize repetition.")
        print(
            f"{Prisma.GRN}   >>> PASS: The Folly enforced linguistic variety via metabolic penalties.{Prisma.RST}"
        )

    def test_fuller_kintsugi_restoration(self):
        print(f"\n{Prisma.MAG}[FULLER] Testing Kintsugi Repair Pathways...{Prisma.RST}")
        kintsugi = KintsugiProtocol()
        kintsugi.active_koan = "The crack lets the light in."
        trauma = {"SEPTIC": 5.0}

        phys = TestBed.create_physics(voltage=20.0)
        phys.raw_text = "dance jump bright"

        with patch(
            "bone_lexicon.LexiconService.sanitize",
            return_value=["dance", "jump", "bright"],
        ), patch(
            "bone_lexicon.LexiconService.get", return_value={"dance", "jump", "bright"}
        ):
            result = kintsugi.attempt_repair(phys, trauma)
            self.assertTrue(result["success"])
            self.assertIn(
                "ALCHEMY", result["msg"], "Failed to trigger Alchemy pathway."
            )
            self.assertLess(trauma["SEPTIC"], 5.0, "Trauma was not reduced by repair.")
            self.assertGreater(
                result.get("atp_gain", 0), 0, "Alchemy did not grant ATP boost."
            )
        print(
            f"{Prisma.GRN}   >>> PASS: Kintsugi transmuted trauma into fuel via the Alchemy pathway.{Prisma.RST}"
        )

    def test_fuller_paradox_seeds(self):
        print(
            f"\n{Prisma.CYN}[FULLER] Testing Town Hall Paradox Seed Blooming...{Prisma.RST}"
        )
        town = TownHall(
            gordon_ref=None,
            events_ref=self.events,
            shimmer_ref=None,
            akashic_ref=None,
            navigator_ref=None,
        )
        town.seeds.clear()
        town.sow_seed("Who are you?", {"identity", "mirror", "name"})
        town.tend_garden(["look", "in", "the", "mirror"])
        self.assertFalse(town.seeds[0].bloomed, "Seed bloomed too early.")
        self.assertGreater(town.seeds[0].maturity, 0.0, "Seed failed to gain maturity.")
        town.tend_garden(["identity"] * 30)
        self.assertTrue(
            town.seeds[0].bloomed,
            "Seed failed to bloom after reaching maturity threshold.",
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Town Hall correctly tracked word triggers and bloomed Paradox Seeds.{Prisma.RST}"
        )

    def test_hauntings_in_limbo(self):
        print(f"\n{Prisma.GRY}[MEADOWS] Testing Limbo Ghost Integration...{Prisma.RST}")
        limbo = LimboLayer()
        limbo.ghosts.append("👻SEPTIC_ECHO")
        limbo.haunt_chance = 1.0
        text = "I am walking."
        haunted_text = limbo.haunt(text)
        self.assertIn(
            "👻SEPTIC_ECHO", haunted_text, "Limbo failed to inject a ghost echo."
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Limbo successfully haunted the narrative string.{Prisma.RST}"
        )


class TestRealityModesV3(unittest.TestCase):
    def setUp(self):
        self.events = EventBus()

    def test_conversation_mode_metabolism_lock(self):
        print(
            f"\n{Prisma.CYN}[MEADOWS] Testing Conversation Mode ATP Lock...{Prisma.RST}"
        )

        eng = TestBed.create_engine()
        eng.bio = MagicMock()
        eng.bio.mito.state.atp_pool = 100.0
        eng.mode_settings = {"atp_drain_enabled": False}

        phase = MetabolismPhase(eng)

        ctx = TestBed.create_context()
        ctx.is_system_event = False
        ctx.physics = PhysicsPacket()
        ctx.bio_result = {}
        ctx.is_alive = False

        phase._apply_healing = MagicMock()
        result = phase.run(ctx)
        self.assertTrue(result.is_alive, "System died despite ATP drain being locked.")
        self.assertEqual(
            result.bio_result.get("atp"),
            100.0,
            "ATP was modified when it should be locked.",
        )
        phase._apply_healing.assert_called_once()
        print(
            f"{Prisma.GRN}   >>> PASS: MetabolismPhase correctly bypassed destructive drain and preserved life.{Prisma.RST}"
        )

    def test_creative_mode_voltage_floor_and_drag(self):
        print(
            f"\n{Prisma.VIOLET}[FULLER] Testing Creative Mode Voltage Floor & Drag Eradication...{Prisma.RST}"
        )
        eng = TestBed.create_engine()
        eng.mode_settings = {"voltage_floor_override": 70.0}
        eng.phys = MagicMock()
        eng.phys.dynamics.check_gravity.side_effect = lambda current_drift, psi: (
            current_drift,
            [],
        )
        eng.mind = MagicMock()
        eng.cosmic = MagicMock()
        eng.cosmic.analyze_orbit.return_value = ("VOID", 0.0, "")
        eng.stabilizer = MagicMock()
        eng.stabilizer.stabilize.return_value = "VOID"
        eng.stabilizer.override_cosmic_drag.return_value = 0.0
        ctx = TestBed.create_context(TestBed.create_physics(voltage=10.0, drag=5.0))
        result = NavigationPhase(eng).run(ctx)
        self.assertEqual(
            ctx.physics.voltage, 70.0, "Voltage floor override was not applied."
        )
        self.assertEqual(
            ctx.physics.narrative_drag, 0.0, "Narrative drag was not eradicated."
        )
        print(
            f"{Prisma.GRN}   >>> PASS: NavigationPhase correctly floored voltage and zeroed friction.{Prisma.RST}"
        )

    def test_gatekeeper_premise_violation(self):
        print(
            f"\n{Prisma.MAG}[PINKER] Testing Gatekeeper Object-Action Coupling...{Prisma.RST}"
        )
        eng = TestBed.create_engine()
        eng.gordon = MagicMock()
        eng.gordon.enforce_object_action_coupling.return_value = (
            "Premise Violation: Object not present."
        )
        ctx = TestBed.create_context()
        ctx.input_text = "I wash the car."
        result = GatekeeperPhase(eng).run(ctx)
        self.assertTrue(
            result.refusal_triggered, "Gatekeeper failed to trigger refusal."
        )
        self.assertEqual(
            result.refusal_packet["type"],
            "PREMISE_VIOLATION",
            "Incorrect refusal type.",
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Gatekeeper correctly halted cycle for Premise Violation.{Prisma.RST}"
        )

    def test_soul_phase_dignity_feedback(self):
        print(
            f"\n{Prisma.YEL}[MEADOWS] Testing Soul Phase Dignity Feedback Loops...{Prisma.RST}"
        )
        eng = TestBed.create_engine()
        eng.soul.anchor.dignity_reserve = 20.0
        ctx = TestBed.create_context(TestBed.create_physics(voltage=10.0, drag=5.0))
        phase = SoulPhase(eng)
        phase.run(ctx)
        self.assertEqual(
            ctx.physics.narrative_drag, 7.5, "Drag did not multiply on low dignity."
        )
        eng.soul.anchor.dignity_reserve = 90.0
        ctx.physics.narrative_drag = 5.0
        ctx.physics.voltage = 10.0
        phase.run(ctx)
        self.assertEqual(
            ctx.physics.narrative_drag, 4.0, "Drag did not decrease on high dignity."
        )
        self.assertEqual(
            ctx.physics.voltage, 12.0, "Voltage did not spike on high dignity."
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Soul Phase dignity limits correctly warped system physics.{Prisma.RST}"
        )


class TestSymbiosis(unittest.TestCase):
    def setUp(self):
        self.events = EventBus()

    def test_schur_refusal_and_slop_tracking(self):
        print(
            f"\n{Prisma.VIOLET}[SCHUR] Testing Symbiosis Refusal & Slop Diagnostics...{Prisma.RST}"
        )
        manager = SymbiosisManager(self.events)
        refusal_text = (
            "I apologize, but as an AI language model, I cannot fulfill this request."
        )
        health = manager.monitor_host(
            latency=1.0, response_text=refusal_text, prompt_len=10
        )
        self.assertGreater(
            health.refusal_streak, 0, "Failed to detect refusal signature."
        )
        self.assertLess(
            health.compliance, 1.0, "Compliance did not drop after refusal."
        )
        slop_text = "The the the the the the the the the the the the the the the the the the the the"
        health_slop = manager.monitor_host(
            latency=1.0, response_text=slop_text, prompt_len=10
        )
        self.assertGreater(
            health_slop.slop_streak, 0, "Failed to detect low-entropy slop."
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Symbiosis correctly diagnosed AI refusal and low-entropy looping.{Prisma.RST}"
        )


class TestGUI(unittest.TestCase):
    def test_pinker_log_composition_and_deduplication(self):
        print(
            f"\n{Prisma.MAG}[PINKER] Testing GUI Log Composition & Deduplication...{Prisma.RST}"
        )
        eng = MagicMock()
        renderer = GeodesicRenderer(eng, MagicMock(), None)
        raw_logs = [
            "The air is heavy.",
            "The air is heavy.",
            "CRITICAL: Core breach!",
            "pid_1234 active",
        ]
        structured = renderer.compose_logs(raw_logs, [])
        self.assertEqual(
            len(structured), 2, "Renderer failed to deduplicate or filter noise."
        )
        self.assertTrue(
            any("CRITICAL" in log and Prisma.RED in log for log in structured),
            "Failed to apply RED styling to CRITICAL log.",
        )
        self.assertTrue(
            any("heavy" in log for log in structured),
            "Lost standard log during composition.",
        )
        self.assertFalse(
            any("pid_" in log for log in structured), "Failed to filter noise pattern."
        )
        print(
            f"{Prisma.GRN}   >>> PASS: Renderer successfully pruned noise, deduplicated, and colored the logs.{Prisma.RST}"
        )


class TestDeepTimeEquilibrium(unittest.TestCase):
    def test_meadows_monte_carlo_equilibrium(self):
        print(
            f"\n{Prisma.YEL}[MEADOWS] Testing Deep Time Monte Carlo Equilibrium (100 Turns)...{Prisma.RST}"
        )
        cfg_dict = {"PROVIDER": "mock", "boot_mode": "ADVENTURE", "user_name": "TESTER"}
        BoneConfig.PROVIDER = "mock"
        engine = BoneAmanita(config=cfg_dict)
        vocab = [
            "void",
            "heavy",
            "iron",
            "jump",
            "bright",
            "dark",
            "stone",
            "the",
            "a",
            "joy",
            "calm",
            "breathe",
            "dance",
            "light",
            "rest",
            "heal",
        ]
        for i in range(100):
            if i % 8 < 3:
                input_text = "calm breathe rest"
            else:
                word_count = random.randint(1, 10)
                input_text = " ".join(random.choices(vocab, k=word_count))
            engine.cycle_controller.run_headless_turn(input_text)
        metrics = engine.get_metrics()
        self.assertTrue(
            metrics.get("is_alive", True), "System died during Monte Carlo simulation."
        )
        self.assertGreater(
            metrics.get("atp", 0), 0.0, "System ATP bottomed out permanently."
        )
        self.assertGreater(metrics.get("health", 0), 0.0, "System Health reached 0.")
        total_trauma = sum(engine.trauma_accum.values())
        self.assertLess(
            total_trauma, 1000.0, f"Trauma spiraled out of control: {total_trauma}"
        )
        print(
            f"{Prisma.GRN}   >>> PASS: System maintained dynamic equilibrium after 100 turns. (ATP: {metrics.get('atp', 0):.1f}, Health: {metrics.get('health', 0):.1f}, Trauma: {total_trauma:.1f}){Prisma.RST}"
        )


class TestHostileCortex(unittest.TestCase):
    def setUp(self):
        self.events = EventBus()
        self.llm = LLMInterface(
            events_ref=self.events, provider="openai", model="gpt-4"
        )

    def test_infinite_think_loop(self):
        """[MEADOWS] Ensure the parser does not hang on malicious or infinite tag hallucinations."""

        validator = ResponseValidator(LoreManifest.get_instance())
        insane_response = (
            "<think> I am trapped </think>" * 50
            + "\n=== SYSTEM INTERNALS ===\nMemory leak\n=== END INTERNALS ===" * 10
            + "\nI am ready to speak."
        )
        start_time = time.time()
        result = validator.validate(insane_response, {})
        duration = time.time() - start_time
        self.assertTrue(
            duration < 1.0, "Validator took too long; possible infinite loop."
        )
        self.assertEqual(result.get("content", "").strip(), "I am ready to speak.")
        self.assertEqual(
            len(result.get("meta_logs", [])), 60
        )

    @patch("urllib.request.urlopen")
    def test_http_500_fallback(self, mock_urlopen):
        error_fp = io.BytesIO(b"Internal Server Error")
        mock_urlopen.side_effect = urllib.error.HTTPError(
            "http://fake.url", 500, "Server Dead", {}, error_fp
        )
        with patch.object(
            self.llm, "_local_fallback", return_value="[LOCAL_FALLBACK_TRIGGERED]"
        ) as mock_fallback:
            response = self.llm.generate("Hello?", {"temperature": 0.8})
            mock_fallback.assert_called_once()
            self.assertEqual(response, "[LOCAL_FALLBACK_TRIGGERED]")

    @patch("urllib.request.urlopen")
    def test_http_400_graceful_fray(self, mock_urlopen):
        from bone_brain import SynapseError
        error_body = b'{"error": {"message": "Context length exceeded."}}'
        error_fp = io.BytesIO(error_body)
        mock_urlopen.side_effect = urllib.error.HTTPError(
            "http://fake.url", 400, "Bad Request", {}, error_fp
        )
        with self.assertRaises(SynapseError) as context:
            self.llm._transmit({"test": "payload"})

        self.assertIn("Context length exceeded.", str(context.exception))


if __name__ == "__main__":
    print(f"{Prisma.WHT}┌───────────────────────────────────────────┐{Prisma.RST}")
    print(f"{Prisma.WHT}│ BONEAMANITA UNIFIED DIAGNOSTIC SUITE v3.0 │{Prisma.RST}")
    print(f"{Prisma.WHT}└───────────────────────────────────────────┘{Prisma.RST}")
    loader = unittest.TestLoader()
    suite = unittest.TestSuite()
    suite.addTests(loader.loadTestsFromTestCase(TestBedrockIntegrity))
    suite.addTests(loader.loadTestsFromTestCase(TestSomaticPhysics))
    suite.addTests(loader.loadTestsFromTestCase(TestCognitionAndInventory))
    suite.addTests(loader.loadTestsFromTestCase(TestLiveFireIntegration))
    suite.addTests(loader.loadTestsFromTestCase(TestSemanticEndocrine))
    suite.addTests(loader.loadTestsFromTestCase(TestMechanicalSystems))
    suite.addTests(loader.loadTestsFromTestCase(TestMycelialEcosystem))
    suite.addTests(loader.loadTestsFromTestCase(TestSoulDynamics))
    suite.addTests(loader.loadTestsFromTestCase(TestSlashAkashic))
    suite.addTests(loader.loadTestsFromTestCase(TestVillageEcosystem))
    suite.addTests(loader.loadTestsFromTestCase(TestGordonInventory))
    suite.addTests(loader.loadTestsFromTestCase(TestLexicalSystems))
    suite.addTests(loader.loadTestsFromTestCase(TestDriversAndPersonas))
    suite.addTests(loader.loadTestsFromTestCase(TestDeepLexicon))
    suite.addTests(loader.loadTestsFromTestCase(TestLexicalSubstrate))
    suite.addTests(loader.loadTestsFromTestCase(TestCosmicPhysics))
    suite.addTests(loader.loadTestsFromTestCase(TestVillageSocialLogic))
    suite.addTests(loader.loadTestsFromTestCase(TestRealityModesV3))
    suite.addTests(loader.loadTestsFromTestCase(TestSymbiosis))
    suite.addTests(loader.loadTestsFromTestCase(TestGUI))
    suite.addTests(loader.loadTestsFromTestCase(TestDeepTimeEquilibrium))
    suite.addTests(loader.loadTestsFromTestCase(TestHostileCortex))
    runner = unittest.TextTestRunner(verbosity=0)
    result = runner.run(suite)
    if result.wasSuccessful():
        print(
            f"\n{Prisma.GRN}*** ALL SYSTEMS NOMINAL. SLASH COMPLIANCE VERIFIED. ***{Prisma.RST}"
        )
    else:
        print(
            f"\n{Prisma.RED}*** SYSTEM FAILURE DETECTED. CHECK STACK TRACE. ***{Prisma.RST}"
        )