Delete bone_cycle.py

bone_cycle.py

@@ -1,1250 +0,0 @@
-import traceback, random, time, uuid
-from typing import Dict, Any, List
-from bone_core import ArchetypeArbiter, LoreManifest
-from bone_types import Prisma, CycleContext
-from bone_physics import (
-    TheGatekeeper,
-    apply_somatic_feedback,
-    TRIGRAM_MAP,
-    CycleStabilizer,
-)
-from bone_gui import SoulDashboard, CycleReporter
-from bone_machine import PanicRoom
-from bone_body import SynestheticCortex
-from bone_symbiosis import SymbiosisManager
-from bone_config import BoneConfig, BonePresets
-from bone_drivers import CongruenceValidator
-
-
-class SimulationPhase:
-    def __init__(self, engine_ref):
-        self.eng = engine_ref
-        self.name = "GENERIC_PHASE"
-
-    def run(self, ctx: CycleContext) -> CycleContext:
-        raise NotImplementedError
-
-
-class ObservationPhase(SimulationPhase):
-    def __init__(self, engine_ref):
-        super().__init__(engine_ref)
-        self.name = "OBSERVE"
-
-    def run(self, ctx: CycleContext):
-        if self.eng.gordon and "GORDON" not in self.eng.suppressed_agents:
-            loot_candidate = self.eng.gordon.parse_loot(ctx.input_text, "")
-            if loot_candidate:
-                acquire_msg = self.eng.gordon.acquire(loot_candidate)
-                ctx.log(acquire_msg)
-        gaze_result = self.eng.phys.observer.gaze(
-            ctx.input_text, self.eng.mind.mem.graph
-        )
-        input_phys = gaze_result["physics"]
-        transfer_keys = {
-            "clean_words",
-            "counts",
-            "vector",
-            "valence",
-            "entropy",
-            "beta_index",
-            "raw_text",
-            "antigens",
-            "psi",
-            "kappa",
-            "zone",
-            "flow_state",
-            "repetition",
-        }
-        for k in transfer_keys:
-            if hasattr(input_phys, k):
-                setattr(ctx.physics, k, getattr(input_phys, k))
-        if (obs_v := getattr(input_phys, "voltage", 0.0)) > 0:
-            ctx.physics.voltage += obs_v * 0.5
-        curr_d = max(0.1, ctx.physics.narrative_drag)
-        input_d = getattr(input_phys, "narrative_drag", 0.0)
-        ctx.physics.narrative_drag = (curr_d * 0.7) + (input_d * 0.3)
-        ctx.clean_words = gaze_result["clean_words"]
-        current_atp = self.eng.bio.mito.state.atp_pool
-        if current_atp < 15.0:
-            ctx.log(
-                f"{Prisma.OCHRE}🧠 INTENTION: Low Energy. Metabolism slowing down.{Prisma.RST}"
-            )
-        if hasattr(self.eng, "symbiosis"):
-            diag = self.eng.symbiosis.current_health.diagnosis
-            if diag != "STABLE":
-                ctx.log(f"{Prisma.OCHRE}⚕️ SYMBIONT DIAGNOSIS: {diag}{Prisma.RST}")
-        self.eng.phys.dynamics.commit(ctx.physics.voltage)
-        self.eng.tick_count += 1
-        return ctx
-
-
-class SanctuaryPhase(SimulationPhase):
-    def __init__(self, engine_ref, governor_ref):
-        super().__init__(engine_ref)
-        self.name = "SANCTUARY"
-        self.governor = governor_ref
-
-    def run(self, ctx: CycleContext):
-        in_safe_zone, distance = self.governor.assess(ctx.physics)
-        trauma_sum = (
-            sum(self.eng.trauma_accum.values())
-            if getattr(self.eng, "trauma_accum", None)
-            else 0.0
-        )
-        if in_safe_zone and trauma_sum < 25.0:
-            self._enter_sanctuary(ctx)
-            self._apply_restoration(ctx)
-            if random.random() < 0.3:
-                self._trigger_dream(ctx)
-        return ctx
-
-    @staticmethod
-    def _enter_sanctuary(ctx: CycleContext):
-        ctx.physics.zone = getattr(BonePresets.SANCTUARY, "ZONE", "SANCTUARY")
-        ctx.physics.zone_color = getattr(BonePresets.SANCTUARY, "COLOR_NAME", "GRN")
-        ctx.physics.flow_state = "LAMINAR"
-        if random.random() < 0.1:
-            color = getattr(BonePresets.SANCTUARY, "COLOR", Prisma.GRN)
-            ctx.log(f"{color}![☀️] SANCTUARY: Breathing space.{Prisma.RST}")
-
-    def _apply_restoration(self, ctx: CycleContext):
-        if self.eng.bio:
-            rest_logs = self.eng.bio.rest(factor=1.0)
-            for log in rest_logs:
-                ctx.log(log)
-        for key in list(self.eng.trauma_accum.keys()):
-            self.eng.trauma_accum[key] = max(0.0, self.eng.trauma_accum[key] - 0.1)
-
-    def _trigger_dream(self, ctx: CycleContext):
-        if not hasattr(self.eng, "mind") or not hasattr(self.eng.mind, "dreamer"):
-            return
-        if hasattr(self.eng.mind.mem, "replay_dreams"):
-            dream_log = self.eng.mind.mem.replay_dreams()
-            if dream_log:
-                ctx.log(f"{Prisma.VIOLET}{dream_log}{Prisma.RST}")
-        current_trauma_load = (
-            sum(self.eng.trauma_accum.values())
-            if hasattr(self.eng, "trauma_accum")
-            else 0.0
-        )
-        bio_packet = {
-            "chem": self.eng.bio.endo.get_state(),
-            "mito": {
-                "atp": self.eng.bio.mito.state.atp_pool,
-                "ros": self.eng.bio.mito.state.ros_buildup,
-            },
-            "physics": (
-                ctx.physics.to_dict()
-                if hasattr(ctx.physics, "to_dict")
-                else ctx.physics
-            ),
-            "trauma_vector": current_trauma_load,
-        }
-        soul_snapshot = (
-            self.eng.soul.to_dict()
-            if hasattr(self.eng, "soul") and hasattr(self.eng.soul, "to_dict")
-            else {}
-        )
-        dream_packet = self.eng.mind.dreamer.enter_rem_cycle(
-            soul_snapshot, bio_state=bio_packet
-        )
-        if isinstance(dream_packet, dict):
-            ctx.log(dream_packet.get("log", "The mind wanders..."))
-            ctx.last_dream = dream_packet
-        elif isinstance(dream_packet, tuple):
-            log_msg, effects = dream_packet
-            ctx.log(log_msg)
-            if effects:
-                if "adrenaline" in effects:
-                    self.eng.bio.endo.adrenaline += effects["adrenaline"]
-                if "voltage" in effects:
-                    ctx.physics.voltage += effects["voltage"]
-
-
-class MaintenancePhase(SimulationPhase):
-    def __init__(self, engine_ref):
-        super().__init__(engine_ref)
-        self.name = "MAINTENANCE"
-
-    def run(self, ctx: CycleContext):
-        if hasattr(self.eng, "town_hall"):
-            blooms = self.eng.town_hall.tend_garden(ctx.clean_words) or []
-            for bloom in blooms:
-                ctx.log(bloom)
-            if self.eng.tick_count % 5 == 0:
-                weather_report = self.eng.town_hall.consult_almanac(ctx.physics)
-                if weather_report:
-                    ctx.log(f"{Prisma.CYN}{weather_report}{Prisma.RST}")
-            is_census_due = self.eng.tick_count > 0 and self.eng.tick_count % 20 == 0
-            if is_census_due or "census" in ctx.clean_words:
-                report = self.eng.town_hall.conduct_census(
-                    ctx.physics, self.eng.host_stats
-                )
-                if report:
-                    ctx.log(f"{Prisma.CYN}📜 TOWN HALL: {report}{Prisma.RST}")
-            session_snapshot = {
-                "trauma_vector": self.eng.trauma_accum,
-                "meta": {"final_health": self.eng.health},
-            }
-            status, advice = self.eng.town_hall.diagnose_condition(
-                session_data=session_snapshot,
-                _host_health=self.eng.bio.biometrics if self.eng.bio else None,
-                soul=self.eng.soul,
-            )
-            if status != "BALANCED":
-                ctx.log(
-                    f"{Prisma.OCHRE}🩺 VITAL SIGNS: {status} - {advice}{Prisma.RST}"
-                )
-        if self.eng.mind and hasattr(self.eng.mind, "mem"):
-            if hasattr(self.eng.mind.mem, "run_ecosystem"):
-                eco_logs = self.eng.mind.mem.run_ecosystem(
-                    ctx.physics.to_dict(), self.eng.stamina, self.eng.tick_count
-                )
-                for log in eco_logs:
-                    ctx.log(log)
-        return ctx
-
-
-class GatekeeperPhase(SimulationPhase):
-    def __init__(self, engine_ref):
-        super().__init__(engine_ref)
-        self.name = "GATEKEEP"
-        self.gatekeeper = TheGatekeeper(self.eng.lex)
-
-    def run(self, ctx: CycleContext):
-        if ctx.is_system_event:
-            return ctx
-        if hasattr(self.eng, "soul") and hasattr(self.eng.soul, "anchor"):
-            anchor = self.eng.soul.anchor
-            if anchor.agency_lock:
-                passed = anchor.assess_humanity(ctx.input_text)
-                if not passed:
-                    dash_view = SoulDashboard(self.eng).render()
-                    ctx.refusal_triggered = True
-                    ctx.refusal_packet = {
-                        "ui": f"{dash_view}\n\n"
-                        f"{Prisma.RED}⛔ ACCESS DENIED: The machine is sulking.\n"
-                        f"    Status: LOCKED (Solve the riddle or prove you are alive).{Prisma.RST}",
-                        "logs": ["Command Rejected (Agency Lock)"],
-                        "metrics": self.eng.get_metrics(),
-                    }
-                    return ctx
-        if self.eng.gordon:
-            current_zone = getattr(ctx.physics, "zone", "UNKNOWN")
-            coupling_error = self.eng.gordon.enforce_object_action_coupling(
-                ctx.input_text, current_zone
-            )
-            if coupling_error:
-                ctx.refusal_triggered = True
-                ctx.refusal_packet = {
-                    "type": "PREMISE_VIOLATION",
-                    "ui": f"\n{coupling_error}",
-                    "logs": ["Premise Violation: Object-Action Coupling Failed"],
-                    "metrics": self.eng.get_metrics(),
-                }
-                return ctx
-        is_allowed, refusal_packet = self.gatekeeper.check_entry(ctx)
-        if not is_allowed:
-            ctx.refusal_triggered = True
-            ctx.refusal_packet = refusal_packet
-            return ctx
-        if self.eng.bureau:
-            current_bio = self.eng.get_metrics()
-            audit_result = self.eng.bureau.audit(
-                ctx.physics.to_dict(), current_bio, origin="USER"
-            )
-            if audit_result:
-                if audit_result.get("block", False):
-                    ctx.refusal_triggered = True
-                    ctx.refusal_packet = {
-                        "type": "BUREAU_BLOCK",
-                        "ui": audit_result.get("ui", "Bureaucratic Injunction."),
-                        "logs": ["Bureaucratic Block Triggered"],
-                        "metrics": (
-                            self.eng.get_metrics()
-                            if hasattr(self.eng, "get_metrics")
-                            else {}
-                        ),
-                    }
-                    return ctx
-                if self.eng.bio and self.eng.bio.mito:
-                    self.eng.bio.mito.adjust_atp(
-                        audit_result.get("atp_gain", 0.0), "Bureaucratic Fine (User)"
-                    )
-                if audit_result.get("log"):
-                    ctx.log(audit_result["log"])
-                if audit_result.get("ui"):
-                    ctx.bureau_ui = audit_result["ui"]
-                    ctx.is_bureaucratic = True
-        return ctx
-
-
-class MetabolismPhase(SimulationPhase):
-    def __init__(self, engine_ref):
-        super().__init__(engine_ref)
-        self.name = "METABOLISM"
-
-    def run(self, ctx: CycleContext):
-        if ctx.is_system_event:
-            return ctx
-        if not hasattr(self.eng, "bio") or not self.eng.bio:
-            return ctx
-        mode_settings = getattr(self.eng, "mode_settings", {})
-        if not mode_settings.get("atp_drain_enabled", True):
-            atp_level = (
-                self.eng.bio.mito.state.atp_pool
-                if self.eng.bio and self.eng.bio.mito
-                else 100.0
-            )
-            ctx.bio_result = {"is_alive": True, "logs": [], "atp": atp_level}
-            ctx.is_alive = True
-            self._apply_healing(ctx)
-            return ctx
-        physics = ctx.physics
-        if hasattr(self.eng, "host_stats"):
-            self._apply_economic_stimulus(ctx, self.eng.host_stats.efficiency_index)
-        gov_msg = self.eng.bio.governor.shift(
-            physics, self.eng.phys.dynamics.voltage_history, self.eng.tick_count
-        )
-        if gov_msg:
-            self.eng.events.log(gov_msg, "GOV")
-        physics.manifold = self.eng.bio.governor.mode
-        max_v = getattr(BoneConfig.PHYSICS, "VOLTAGE_MAX", 20.0)
-        bio_feedback = {
-            "INTEGRITY": getattr(physics, "truth_ratio", 1.0),
-            "STATIC": getattr(physics, "repetition", 0.0),
-            "FORCE": getattr(physics, "voltage", 0.0) / max_v,
-            "BETA": getattr(physics, "beta_index", 0.0),
-            "PSI": getattr(physics, "psi", 0.0),
-            "ENTROPY": getattr(physics, "entropy", 0.0),
-            "VALENCE": getattr(physics, "valence", 0.0),
-        }
-        metrics = self.eng.get_metrics()
-        ctx.bio_result = self.eng.soma.digest_cycle(
-            ctx.input_text,
-            physics,
-            bio_feedback,
-            metrics["health"],
-            metrics["stamina"],
-            self.eng.bio.governor.get_stress_modifier(self.eng.tick_count),
-            self.eng.tick_count,
-            circadian_bias=self._check_circadian_rhythm(),
-        )
-        if self.eng.bio.biometrics:
-            self.eng.health = self.eng.bio.biometrics.health
-            self.eng.stamina = self.eng.bio.biometrics.stamina
-        ctx.is_alive = ctx.bio_result["is_alive"]
-        for log in ctx.bio_result["logs"]:
-            if any(x in str(log) for x in ["CRITICAL", "TAX", "Poison", "NECROSIS"]):
-                ctx.log(log)
-        self._audit_hubris(ctx, physics)
-        self._apply_healing(ctx)
-        self._check_narcolepsy(ctx)
-        return ctx
-
-    def _apply_economic_stimulus(self, ctx: CycleContext, efficiency: float):
-        if efficiency >= 0.8:
-            return
-        tax_burn = min(1.5, (0.8 - efficiency) * 5.0)
-        if tax_burn > 0:
-            self.eng.bio.mito.state.atp_pool = max(
-                0.0, self.eng.bio.mito.state.atp_pool - tax_burn
-            )
-            ctx.log(
-                f"{Prisma.OCHRE}⚡ METABOLIC TAX: System strain burns {tax_burn:.1f} ATP.{Prisma.RST}"
-            )
-
-    def _check_narcolepsy(self, ctx: CycleContext):
-        atp = self.eng.bio.mito.state.atp_pool
-        starvation = getattr(BoneConfig.BIO, "ATP_STARVATION", 5.0)
-        trigger = (atp < (starvation * 0.5)) or (
-            self.eng.tick_count > 0 and self.eng.tick_count % 100 == 0
-        )
-        if trigger and hasattr(self.eng.mind, "dreamer"):
-            ctx.log(
-                f"\n{Prisma.VIOLET}[AUTO-SLEEP]: Forced reboot sequence.{Prisma.RST}"
-            )
-            soul_snap = self.eng.soul.to_dict() if hasattr(self.eng, "soul") else {}
-            self.eng.mind.dreamer.enter_rem_cycle(soul_snap, bio_state={"atp": atp})
-            self.eng.mind.dreamer.run_defragmentation(self.eng.mind.mem)
-            reboot_val = getattr(BoneConfig, "MAX_ATP", 100.0) * 0.33
-            self.eng.bio.mito.state.atp_pool = reboot_val
-            ctx.bio_result["atp"] = reboot_val
-            ctx.log(
-                f"{Prisma.GRN}   (System restored. ATP stabilized at {reboot_val:.1f}){Prisma.RST}"
-            )
-
-    def _check_circadian_rhythm(self):
-        if self.eng.tick_count % 10 == 0:
-            bias, msg = self.eng.bio.endo.calculate_circadian_bias()
-            if msg:
-                self.eng.events.log(f"{Prisma.CYN}🕒 {msg}{Prisma.RST}", "BIO")
-            return bias
-        return None
-
-    def _audit_hubris(self, ctx, physics):
-        hit, msg, evt = self.eng.phys.tension.audit_hubris(physics.to_dict())
-        if hit:
-            ctx.log(msg)
-            if evt == "FLOW_BOOST":
-                self.eng.bio.mito.state.atp_pool += 20.0
-            elif evt == "ICARUS_CRASH":
-                damage = 15.0
-                ctx.log(f"   {Prisma.RED}IMPACT TRAUMA: -{damage} HP.{Prisma.RST}")
-                if self.eng.bio.biometrics:
-                    self.eng.bio.biometrics.health = max(
-                        0.0, self.eng.bio.biometrics.health - damage
-                    )
-                self.eng.health -= damage
-
-    def _apply_healing(self, ctx):
-        qualia = self.eng.somatic.get_current_qualia(getattr(ctx, "last_impulse", None))
-        current_stamina = self.eng.stamina
-        if self.eng.bio.biometrics:
-            current_stamina = self.eng.bio.biometrics.stamina
-        cracked, koan = self.eng.kintsugi.check_integrity(current_stamina)
-        if cracked:
-            ctx.log(f"{Prisma.YEL}🏺 KINTSUGI ACTIVATED. KOAN: {koan}{Prisma.RST}")
-        if self.eng.kintsugi.active_koan:
-            repair = self.eng.kintsugi.attempt_repair(
-                ctx.physics, self.eng.trauma_accum, self.eng.soul, qualia
-            )
-            if repair and repair["success"]:
-                ctx.log(repair["msg"])
-                heal_amt = 20.0
-                if self.eng.bio.biometrics:
-                    self.eng.bio.biometrics.stamina = min(
-                        BoneConfig.MAX_STAMINA,
-                        self.eng.bio.biometrics.stamina + heal_amt,
-                    )
-                self.eng.stamina = min(
-                    BoneConfig.MAX_STAMINA, self.eng.stamina + heal_amt
-                )
-        if self.eng.therapy.check_progress(
-            ctx.physics, current_stamina, self.eng.trauma_accum, qualia
-        ):
-            ctx.log(f"{Prisma.GRN}❤️ THERAPY: Trauma processed. Health +5.{Prisma.RST}")
-            if self.eng.bio.biometrics:
-                self.eng.bio.biometrics.health = min(
-                    BoneConfig.MAX_HEALTH, self.eng.bio.biometrics.health + 5.0
-                )
-            self.eng.health = min(BoneConfig.MAX_HEALTH, self.eng.health + 5.0)
-
-
-class RealityFilterPhase(SimulationPhase):
-    def __init__(self, engine_ref):
-        super().__init__(engine_ref)
-        self.name = "REALITY_FILTER"
-        self.TRIGRAMS = TRIGRAM_MAP
-
-    def run(self, ctx: CycleContext):
-        reflection = self.eng.mind.mirror.get_reflection_modifiers()
-        ctx.physics.narrative_drag *= reflection["drag_mult"]
-        vector = ctx.physics.vector
-        if vector:
-            dom = max(vector, key=vector.get)
-            entry = self.TRIGRAMS.get(dom, self.TRIGRAMS["E"])
-            sym, name, _, color = entry
-            ctx.world_state["trigram"] = {"symbol": sym, "name": name, "color": color}
-            if random.random() < 0.05:
-                ctx.log(
-                    f"{color}I CHING: {sym} {name} is in the ascendant.{Prisma.RST}"
-                )
-        return ctx
-
-
-class NavigationPhase(SimulationPhase):
-    def __init__(self, engine_ref):
-        super().__init__(engine_ref)
-        self.name = "NAVIGATION"
-
-    def run(self, ctx: CycleContext):
-        physics = ctx.physics
-        mode_settings = getattr(self.eng, "mode_settings", {})
-        v_floor = mode_settings.get("voltage_floor_override")
-        if v_floor is not None:
-            physics.voltage = max(physics.voltage, v_floor)
-            if v_floor >= 50.0:
-                physics.narrative_drag = 0.0
-        new_drag, grav_logs = self.eng.phys.dynamics.check_gravity(
-            current_drift=physics.narrative_drag, psi=physics.psi
-        )
-        physics.narrative_drag = new_drag
-        for log in grav_logs:
-            ctx.log(log)
-        if self.eng.gordon:
-            phys_snapshot = physics.to_dict()
-            reflex_triggered, reflex_msg = self.eng.gordon.emergency_reflex(
-                phys_snapshot
-            )
-            if reflex_triggered:
-                for key, val in phys_snapshot.items():
-                    if hasattr(physics, key):
-                        current_val = getattr(physics, key)
-                        if current_val != val:
-                            if key in ["energy", "space", "matter"]:
-                                sub_obj = getattr(physics, key)
-                                if isinstance(val, dict) and sub_obj:
-                                    for sk, sv in val.items():
-                                        if hasattr(sub_obj, sk):
-                                            setattr(sub_obj, sk, sv)
-                            else:
-                                setattr(physics, key, val)
-                if reflex_msg:
-                    ctx.log(reflex_msg)
-                ctx.record_flux("NAVIGATION", "REFLEX", 1.0, 0.0, "ITEM_TRIGGERED")
-        phys_dict = physics.to_dict()
-        if self.eng.navigator:
-            current_loc, entry_msg = self.eng.navigator.locate(
-                packet=ctx.physics,
-            )
-            if entry_msg:
-                ctx.log(entry_msg)
-            env_logs = self.eng.navigator.apply_environment(physics)
-            for e_log in env_logs:
-                ctx.log(e_log)
-        if self.eng.gordon and self.eng.tinkerer:
-            inv_data = self.eng.gordon.get_inventory_data()
-            deltas = self.eng.tinkerer.calculate_passive_deltas(inv_data)
-            for delta in deltas:
-                if delta.field == "narrative_drag":
-                    if delta.operator == "ADD":
-                        physics.narrative_drag += delta.value
-                    elif delta.operator == "MULT":
-                        physics.narrative_drag *= delta.value
-                    ctx.log(
-                        f"{Prisma.GRY}🎒 GEAR: {delta.source} affects drag ({delta.operator} {delta.value}).{Prisma.RST}"
-                    )
-        orbit_state, drag_pen, orbit_msg = self.eng.cosmic.analyze_orbit(
-            self.eng.mind.mem, ctx.clean_words
-        )
-        if orbit_msg:
-            ctx.log(orbit_msg)
-        physics.narrative_drag += drag_pen
-        if orbit_state == "VOID_DRIFT":
-            physics.voltage = max(0.0, physics.voltage - 0.5)
-        elif orbit_state == "LAGRANGE_POINT":
-            physics.narrative_drag = max(0.1, physics.narrative_drag - 2.0)
-        elif orbit_state == "WATERSHED_FLOW":
-            physics.voltage += 0.5
-        raw_zone = getattr(physics, "zone", "COURTYARD")
-        stabilization_result = self.eng.stabilizer.stabilize(
-            proposed_zone=raw_zone,
-            physics=phys_dict,
-            cosmic_state=(orbit_state, drag_pen),
-        )
-        if isinstance(stabilization_result, tuple):
-            stabilized_zone = stabilization_result[0]
-            if len(stabilization_result) > 1 and stabilization_result[1]:
-                ctx.log(stabilization_result[1])
-        else:
-            stabilized_zone = stabilization_result
-        physics.zone = stabilized_zone
-        adjusted_drag = self.eng.stabilizer.override_cosmic_drag(
-            drag_pen, stabilized_zone
-        )
-        if adjusted_drag != drag_pen:
-            physics.narrative_drag -= drag_pen - adjusted_drag
-        ctx.world_state["orbit"] = orbit_state
-        return ctx
-
-
-class MachineryPhase(SimulationPhase):
-    def __init__(self, engine_ref):
-        super().__init__(engine_ref)
-        self.name = "MACHINERY"
-
-    def run(self, ctx: CycleContext):
-        if ctx.is_system_event:
-            return ctx
-        phys_dict = ctx.physics.to_dict()
-        if hasattr(self.eng, "critics") and (
-            review := self.eng.critics.audit_performance(phys_dict, self.eng.tick_count)
-        ):
-            ctx.log(review)
-            ctx.physics.narrative_drag += -1.0 if "🌟" in review else 1.0
-        boost, z_msg = self.eng.zen.raking_the_sand(phys_dict, ctx.bio_result)
-        if z_msg:
-            ctx.log(z_msg)
-        if boost > 0:
-            self.eng.bio.mito.state.membrane_potential = min(
-                2.0, self.eng.bio.mito.state.efficiency_mod + (boost * 0.1)
-            )
-        if self.eng.gordon and self.eng.gordon.inventory:
-            self._process_crafting(ctx, phys_dict)
-        if t_msg := self.eng.phys.forge.transmute(phys_dict):
-            ctx.log(t_msg)
-        _, f_msg, new_item = self.eng.phys.forge.hammer_alloy(phys_dict)
-        if f_msg:
-            ctx.log(f_msg)
-        if new_item and self.eng.gordon:
-            ctx.log(self.eng.gordon.acquire(new_item))
-        _, _, t_msg, t_crit = self.eng.phys.theremin.listen(
-            phys_dict, self.eng.bio.governor.mode
-        )
-        if t_msg:
-            ctx.log(t_msg)
-        if t_crit == "AIRSTRIKE":
-            self._handle_theremin_discharge(ctx)
-        self.eng.phys.pulse.update(
-            getattr(ctx.physics, "repetition", 0.0), ctx.physics.voltage
-        )
-        c_state, c_val, c_msg = self.eng.phys.crucible.audit_fire(phys_dict)
-        if c_msg:
-            ctx.log(c_msg)
-        if c_state == "MELTDOWN":
-            damage = c_val
-            if self.eng.bio.biometrics:
-                self.eng.bio.biometrics.health = max(
-                    0.0, self.eng.bio.biometrics.health - damage
-                )
-            self.eng.health = max(0.0, self.eng.health - damage)
-
-        for k, v in phys_dict.items():
-            if hasattr(ctx.physics, k) and not callable(getattr(ctx.physics, k)):
-                try:
-                    if k in ["energy", "space", "matter"]:
-                        sub_obj = getattr(ctx.physics, k)
-                        if isinstance(v, dict) and sub_obj:
-                            for sk, sv in v.items():
-                                if hasattr(sub_obj, sk):
-                                    setattr(sub_obj, sk, sv)
-                    else:
-                        setattr(ctx.physics, k, v)
-                except AttributeError:
-                    pass
-        return ctx
-
-    def _process_crafting(self, ctx, phys_dict):
-        is_craft, craft_msg, old_item, new_item = self.eng.phys.forge.attempt_crafting(
-            phys_dict, self.eng.gordon.inventory
-        )
-        if is_craft:
-            ctx.log(craft_msg)
-            vec = ctx.physics.vector
-            catalyst_cat = max(vec, key=vec.get) if vec else "void"
-            self.eng.events.publish(
-                "FORGE_SUCCESS",
-                {"ingredient": old_item, "catalyst": catalyst_cat, "result": new_item},
-            )
-            if old_item in self.eng.gordon.inventory:
-                self.eng.gordon.inventory.remove(old_item)
-            ctx.log(self.eng.gordon.acquire(new_item))
-
-    def _handle_theremin_discharge(self, ctx):
-        max_hp = getattr(BoneConfig, "MAX_HEALTH", 100.0)
-        damage = max_hp * 0.25
-        if self.eng.bio.biometrics:
-            self.eng.bio.biometrics.health = max(
-                0.0, self.eng.bio.biometrics.health - damage
-            )
-        self.eng.health = max(0.0, self.eng.health - damage)
-        ctx.log(
-            f"{Prisma.RED}*** CRITICAL THEREMIN DISCHARGE *** -{damage:.1f} HP{Prisma.RST}"
-        )
-        if hasattr(self.eng.events, "publish"):
-            self.eng.events.publish(
-                "AIRSTRIKE", {"damage": damage, "source": "THEREMIN"}
-            )
-
-
-class IntrusionPhase(SimulationPhase):
-    def __init__(self, engine_ref):
-        super().__init__(engine_ref)
-        self.name = "INTRUSION"
-
-    def run(self, ctx: CycleContext):
-        phys_data = ctx.physics.to_dict()
-        p_active, p_log = self.eng.bio.parasite.infect(phys_data, self.eng.stamina)
-        if p_active:
-            ctx.log(p_log)
-        if self.eng.limbo.ghosts:
-            if ctx.logs:
-                ctx.logs[-1] = self.eng.limbo.haunt(ctx.logs[-1])
-            else:
-                ctx.log(self.eng.limbo.haunt("The air is heavy."))
-
-        drag = getattr(ctx.physics, "narrative_drag", 0.0)
-        kappa = getattr(ctx.physics, "kappa", 1.0)
-
-        if (drag > 4.0 or kappa < 0.3) and ctx.clean_words:
-            start_node = random.choice(ctx.clean_words)
-            loop_path = self.eng.mind.tracer.inject(start_node)
-            if loop_path:
-                rewire_msg = self.eng.mind.tracer.psilocybin_rewire(loop_path)
-                if rewire_msg:
-                    ctx.log(f"{Prisma.CYN}🦠 IMMUNE SYSTEM: {rewire_msg}{Prisma.RST}")
-                    self.eng.bio.endo.dopamine += 0.2
-                    ctx.physics.narrative_drag = max(0.0, drag - 2.0)
-        trauma_sum = (
-            sum(self.eng.trauma_accum.values())
-            if getattr(self.eng, "trauma_accum", None)
-            else 0.0
-        )
-        is_bored = self.eng.phys.pulse.is_bored()
-        if (trauma_sum > 10.0 or is_bored) and random.random() < 0.2:
-            dream_text, relief = self.eng.mind.dreamer.hallucinate(
-                ctx.physics.vector, trauma_level=trauma_sum
-            )
-            prefix = "💭 NIGHTMARE" if trauma_sum > 10.0 else "💭 DAYDREAM"
-            ctx.log(f"{Prisma.VIOLET}{prefix}: {dream_text}{Prisma.RST}")
-            if relief > 0:
-                keys = list(self.eng.trauma_accum.keys())
-                if keys:
-                    target = random.choice(keys)
-                    self.eng.trauma_accum[target] = max(
-                        0.0, self.eng.trauma_accum[target] - relief
-                    )
-                    ctx.log(
-                        f"   {Prisma.GRY}(Psychic pressure released: -{relief:.1f} {target}){Prisma.RST}"
-                    )
-            if is_bored:
-                self.eng.phys.pulse.boredom_level = 0.0
-        current_psi = getattr(ctx.physics, "psi", 0.0)
-        if current_psi > 0.6 and random.random() < current_psi:
-            p_msg = f"{Prisma.VIOLET}👁️ PAREIDOLIA: The patterns are watching back (PSI {current_psi:.2f}).{Prisma.RST}"
-            ctx.log(p_msg)
-            ctx.physics.psi = min(1.0, current_psi + 0.1)
-            if self.eng.bio and self.eng.bio.biometrics:
-                self.eng.bio.biometrics.stamina = max(
-                    0.0, self.eng.bio.biometrics.stamina - 5.0
-                )
-                ctx.log(
-                    f"{Prisma.GRY}   (The hallucination drains 5.0 Stamina){Prisma.RST}"
-                )
-        return ctx
-
-
-class SoulPhase(SimulationPhase):
-    def __init__(self, engine_ref):
-        super().__init__(engine_ref)
-        self.name = "SOUL"
-
-    def run(self, ctx: CycleContext):
-        if ctx.is_system_event:
-            return ctx
-        if not hasattr(self.eng, "soul") or not self.eng.soul:
-            return ctx
-        dignity = self.eng.soul.anchor.dignity_reserve
-        if dignity < 30.0:
-            ctx.physics.narrative_drag *= 1.5
-            ctx.log(
-                f"{Prisma.GRY}⚓ DIGNITY CRITICAL: The narrative feels heavy. (Drag x1.5){Prisma.RST}"
-            )
-        elif dignity > 80.0:
-            ctx.physics.voltage += 2.0
-            ctx.physics.narrative_drag *= 0.8
-            ctx.log(
-                f"{Prisma.MAG}✨ DIGNITY HIGH: The soul is sovereign. (Flow Optimized){Prisma.RST}"
-            )
-        lesson = self.eng.soul.crystallize_memory(
-            ctx.physics.to_dict(), ctx.bio_result, self.eng.tick_count
-        )
-        if lesson:
-            ctx.log(
-                f"{Prisma.VIOLET}   (The lesson '{lesson}' echoes in the chamber.){Prisma.RST}"
-            )
-        if not self.eng.soul.current_obsession:
-            self.eng.soul.find_obsession(self.eng.lex)
-        self.eng.soul.pursue_obsession(ctx.physics.to_dict())
-        if hasattr(self.eng, "oroboros") and self.eng.oroboros.myths:
-            for myth in self.eng.oroboros.myths:
-                if myth.trigger in ctx.clean_words:
-                    ctx.log(
-                        f"{Prisma.YEL}📜 ANCIENT MYTH INVOKED: {myth.title}{Prisma.RST}"
-                    )
-                    ctx.log(f'   "{myth.lesson}"')
-                    old_volts = ctx.physics.voltage
-                    ctx.physics.voltage += 5.0
-                    ctx.record_flux(
-                        "SOUL", "VOLTAGE", old_volts, ctx.physics.voltage, "MYTH_BUFF"
-                    )
-                    if self.eng.bio.biometrics:
-                        self.eng.bio.biometrics.stamina = min(
-                            100.0, self.eng.bio.biometrics.stamina + 5.0
-                        )
-        if self.eng.gordon and self.eng.tinkerer:
-            if self.eng.gordon.inventory:
-                self.eng.tinkerer.audit_tool_use(ctx.physics, self.eng.gordon.inventory)
-        council_mandates = self._consult_council(self.eng.soul.traits)
-        if council_mandates:
-            ctx.council_mandates = (
-                getattr(ctx, "council_mandates", []) + council_mandates
-            )
-            for mandate in council_mandates:
-                ctx.log(mandate["log"])
-                self._execute_mandate(ctx, mandate)
-        council_advice, adjustments, mandates = self.eng.council.convene(
-            ctx.input_text, ctx.physics.to_dict(), ctx.bio_result
-        )
-        if mandates:
-            if not hasattr(ctx, "council_mandates"):
-                ctx.council_mandates = []
-            ctx.council_mandates.extend(mandates)
-        for advice in council_advice:
-            ctx.log(advice)
-        for mandate in mandates:
-            action = mandate.get("action")
-            if action == "FORCE_MODE":
-                target = mandate["value"]
-                self.eng.bio.governor.set_override(target)
-                ctx.log(
-                    f"{Prisma.RED}⚖️ COUNCIL ORDER: Emergency Shift to {target}.{Prisma.RST}"
-                )
-            elif action == "CIRCUIT_BREAKER":
-                ctx.physics.voltage = 0.0
-                ctx.physics.narrative_drag = 10.0
-                ctx.log(
-                    f"{Prisma.RED}⚖️ COUNCIL ORDER: Circuit Breaker Tripped. Voltage dump.{Prisma.RST}"
-                )
-        if adjustments:
-            for param, delta in adjustments.items():
-                old_val = getattr(ctx.physics, param, 0.0)
-                new_val = old_val + delta
-                setattr(ctx.physics, param, new_val)
-                ctx.record_flux(
-                    "SIMULATION", param, old_val, new_val, "COUNCIL_MANDATE"
-                )
-        return ctx
-
-    @staticmethod
-    def _consult_council(traits: Any) -> List[Dict]:
-        t_map = (
-            traits.to_dict()
-            if hasattr(traits, "to_dict")
-            else (traits.__dict__ if hasattr(traits, "__dict__") else traits)
-        )
-        get_t = lambda k: t_map.get(k, t_map.get(k.lower(), 0.0))
-        rules = [
-            (
-                "CYNICISM",
-                0.8,
-                "LOCKDOWN",
-                "The Cynic holds the gavel. 'Stop doing things.'",
-                {"narrative_drag": 5.0, "voltage": -5.0},
-                Prisma.OCHRE,
-            ),
-            (
-                "HOPE",
-                0.8,
-                "STIMULUS",
-                "The Optimist filibustered. 'We can build it!'",
-                {"voltage": 5.0, "narrative_drag": -2.0},
-                Prisma.MAG,
-            ),
-            (
-                "DISCIPLINE",
-                0.8,
-                "STANDARDIZE",
-                "The Engineer demands efficiency.",
-                {"kappa": -0.5, "beta_index": 1.0},
-                Prisma.CYN,
-            ),
-        ]
-        mandates = []
-        for trait, thresh, m_type, msg, eff, col in rules:
-            if get_t(trait) > thresh:
-                mandates.append(
-                    {
-                        "type": m_type,
-                        "log": f"{col}⚖️ COUNCIL: {msg}{Prisma.RST}",
-                        "effect": eff,
-                    }
-                )
-        return mandates
-
-    @staticmethod
-    def _execute_mandate(ctx: CycleContext, mandate: Dict):
-        effects = mandate.get("effect", {})
-        for key, delta in effects.items():
-            current = getattr(ctx.physics, key, 0.0)
-            setattr(ctx.physics, key, max(0.0, current + delta))
-
-
-class ArbitrationPhase(SimulationPhase):
-    def __init__(self, engine_ref):
-        super().__init__(engine_ref)
-        self.name = "ARBITRATION"
-        if not hasattr(self.eng, "arbiter"):
-            self.eng.arbiter = ArchetypeArbiter()
-
-    def run(self, ctx: CycleContext):
-        phys_lens, _, _ = self.eng.drivers.enneagram.decide_persona(
-            ctx.physics, soul_ref=self.eng.soul
-        )
-        soul_arch = self.eng.soul.archetype
-        mandates = getattr(ctx, "council_mandates", [])
-        current_trigram = ctx.world_state.get("trigram", None)
-        final_lens, source, opinion = self.eng.arbiter.arbitrate(
-            physics_lens=phys_lens,
-            soul_archetype=soul_arch,
-            council_mandates=mandates,
-            trigram=current_trigram,
-        )
-        ctx.active_lens = final_lens
-        self.eng.events.publish("LENS_INTERACTION", {"lenses": [phys_lens, soul_arch]})
-        if source != "PHYSICS_VECTOR":
-            ctx.log(f"{Prisma.MAG}⚖️ {opinion}{Prisma.RST}")
-        self.eng.drivers.current_focus = final_lens
-        return ctx
-
-
-class CognitionPhase(SimulationPhase):
-    def __init__(self, engine_ref):
-        super().__init__(engine_ref)
-        self.name = "COGNITION"
-
-    def run(self, ctx: CycleContext):
-        if ctx.validator and ctx.input_text:
-            phi = ctx.validator.calculate_resonance(ctx.input_text, ctx)
-            if phi > 0.8:
-                drag_relief = (phi - 0.5) * 2.0
-                ctx.physics.narrative_drag = max(
-                    0.0, ctx.physics.narrative_drag - drag_relief
-                )
-                if self.eng.bio and self.eng.bio.mito:
-                    refund = 5.0 * phi
-                    self.eng.bio.mito.adjust_atp(refund, "Harmonic Resonance")
-                ctx.log(
-                    f"{Prisma.CYN}✨ HARMONIC RESONANCE (Φ={phi:.2f}): The narrative flows effortlessly.{Prisma.RST}"
-                )
-        if hasattr(self.eng, "consultant"):
-            self.eng.consultant.update_coordinates(
-                ctx.input_text, ctx.bio_result, ctx.physics
-            )
-            if (
-                "LIMINAL" in self.eng.consultant.state.active_modules
-                and self.eng.bio
-                and self.eng.bio.mito
-            ):
-                lambda_val = self.eng.consultant.state.L
-                if lambda_val > 0.1:
-                    lambda_tax = (lambda_val**2) * 10.0
-                    self.eng.bio.mito.adjust_atp(-lambda_tax, f"Λ² Liminal Tax")
-                    if lambda_tax > 2.0:
-                        ctx.log(
-                            f"{Prisma.VIOLET}🌌 DARK MATTER: Liminal navigation burns {lambda_tax:.1f} ATP.{Prisma.RST}"
-                        )
-        if hasattr(self.eng.mind.mem, "check_for_resurrection"):
-            flashback_msg = self.eng.mind.mem.check_for_resurrection(
-                ctx.clean_words, ctx.physics.voltage
-            )
-            if flashback_msg:
-                ctx.log(f"{Prisma.MAG}{flashback_msg}{Prisma.RST}")
-                shock_cost = 5.0
-                if self.eng.bio.biometrics:
-                    self.eng.bio.biometrics.stamina = max(
-                        0.0, self.eng.bio.biometrics.stamina - shock_cost
-                    )
-                self.eng.stamina = max(0.0, self.eng.stamina - shock_cost)
-        self.eng.mind.mem.encode(ctx.clean_words, ctx.physics.to_dict(), "GEODESIC")
-        if ctx.is_alive and ctx.clean_words:
-            max_h = getattr(BoneConfig, "MAX_HEALTH", 100.0)
-            current_h = max(0.0, self.eng.health)
-            if self.eng.bio.biometrics:
-                current_h = max(0.0, self.eng.bio.biometrics.health)
-            desperation = 1.0 - (current_h / max_h)
-            learn_mod = getattr(BoneConfig, "PRIORITY_LEARNING_RATE", 1.0)
-            bury_msg, new_wells = self.eng.mind.mem.bury(
-                ctx.clean_words,
-                self.eng.tick_count,
-                resonance=ctx.physics.voltage,
-                desperation_level=desperation,
-                learning_mod=learn_mod,
-            )
-            if bury_msg:
-                prefix = (
-                    f"{Prisma.YEL}⚠️ MEMORY:{Prisma.RST}"
-                    if "SATURATION" in bury_msg
-                    else f"{Prisma.RED}🍖 DONNER PROTOCOL:{Prisma.RST}"
-                )
-                ctx.log(f"{prefix} {bury_msg}")
-            if new_wells:
-                ctx.log(f"{Prisma.CYN}🌌 GRAVITY WELL FORMED: {new_wells}{Prisma.RST}")
-
-        inventory_data = self.eng.gordon.inventory if self.eng.gordon else []
-
-        ctx.mind_state = self.eng.noetic.think(
-            physics_packet=ctx.physics.to_dict(),
-            _bio=ctx.bio_result,
-            _inventory=inventory_data,
-            voltage_history=self.eng.phys.dynamics.voltage_history,
-            _tick_count=self.eng.tick_count,
-            soul_ref=self.eng.soul,
-        )
-
-        thought = ctx.mind_state.get("context_msg", ctx.mind_state.get("thought"))
-        if thought:
-            ctx.log(thought)
-        return ctx
-
-
-class SensationPhase(SimulationPhase):
-    def __init__(self, engine_ref):
-        super().__init__(engine_ref)
-        self.name = "SENSATION"
-        if hasattr(self.eng, "somatic"):
-            self.synesthesia = self.eng.somatic
-        else:
-            self.synesthesia = SynestheticCortex(self.eng.bio)
-            self.eng.somatic = self.synesthesia
-
-    def run(self, ctx: CycleContext):
-        phys_data = ctx.physics.to_dict()
-        current_latency = 0.0
-        if hasattr(self.eng, "host_stats"):
-            current_latency = self.eng.host_stats.latency
-        impulse = self.synesthesia.perceive(
-            phys_data, traits=self.eng.soul.traits, latency=current_latency
-        )
-        ctx.last_impulse = impulse
-        qualia = self.synesthesia.get_current_qualia(impulse)
-        ctx.physics = apply_somatic_feedback(ctx.physics, qualia)
-        self.synesthesia.apply_impulse(impulse)
-        if impulse.stamina_impact != 0:
-            max_s = getattr(BoneConfig, "MAX_STAMINA", 100.0)
-            if self.eng.bio.biometrics:
-                self.eng.bio.biometrics.stamina = max(
-                    0.0,
-                    min(
-                        max_s, self.eng.bio.biometrics.stamina + impulse.stamina_impact
-                    ),
-                )
-            self.eng.stamina = max(
-                0.0, min(max_s, self.eng.stamina + impulse.stamina_impact)
-            )
-        return ctx
-
-
-class StabilizationPhase(SimulationPhase):
-    def __init__(self, engine_ref, stabilizer_ref):
-        super().__init__(engine_ref)
-        self.name = "STABILIZATION"
-        self.stabilizer = stabilizer_ref
-
-    def run(self, ctx: CycleContext):
-        self.stabilizer.stabilize(ctx, self.name)
-        return ctx
-
-
-class PhaseExecutor:
-    def execute_phases(self, simulator, ctx):
-        for phase in simulator.pipeline:
-            if getattr(ctx, "refusal_triggered", False):
-                break
-            if not simulator.check_circuit_breaker(phase.name):
-                continue
-            snapshot_before = ctx.physics.snapshot()
-            try:
-                phase.run(ctx)
-            except Exception as e:
-                simulator.handle_phase_crash(ctx, phase.name, e)
-                self._audit_flux(ctx, phase.name, snapshot_before, ctx.physics)
-                break
-            self._audit_flux(ctx, phase.name, snapshot_before, ctx.physics)
-        return ctx
-
-    @staticmethod
-    def _audit_flux(ctx, phase, before, after):
-        def _safe_get(obj, key):
-            try:
-                if isinstance(obj, dict):
-                    return obj.get(key, 0.0)
-                return getattr(obj, key, 0.0)
-            except Exception:
-                return 0.0
-
-        b_v = _safe_get(before, "voltage")
-        a_v = _safe_get(after, "voltage")
-        b_d = _safe_get(before, "narrative_drag")
-        a_d = _safe_get(after, "narrative_drag")
-        if abs(b_v - a_v) > 0.01:
-            ctx.record_flux(phase, "voltage", b_v, a_v, "PHASE_DELTA")
-        if abs(b_d - a_d) > 0.01:
-            ctx.record_flux(phase, "drag", b_d, a_d, "PHASE_DELTA")
-
-
-class CycleSimulator:
-    def __init__(self, engine_ref):
-        self.eng = engine_ref
-        self.shared_governor = self.eng.bio.governor
-        self.stabilizer = CycleStabilizer(self.eng.events, self.shared_governor)
-        self.executor = PhaseExecutor()
-        self.pipeline: List[SimulationPhase] = [
-            ObservationPhase(engine_ref),
-            MaintenancePhase(engine_ref),
-            SensationPhase(engine_ref),
-            GatekeeperPhase(engine_ref),
-            SanctuaryPhase(engine_ref, self.shared_governor),
-            MetabolismPhase(engine_ref),
-            NavigationPhase(engine_ref),
-            MachineryPhase(engine_ref),
-            RealityFilterPhase(engine_ref),
-            IntrusionPhase(engine_ref),
-            SoulPhase(engine_ref),
-            ArbitrationPhase(engine_ref),
-            CognitionPhase(engine_ref),
-            StabilizationPhase(engine_ref, self.stabilizer),
-        ]
-
-    def run_simulation(self, ctx: CycleContext) -> CycleContext:
-        ctx = self.executor.execute_phases(self, ctx)
-        return ctx
-
-    def check_circuit_breaker(self, phase_name: str) -> bool:
-        health = self.eng.system_health
-        if phase_name == "OBSERVE" and not health.physics_online:
-            return False
-        if phase_name == "METABOLISM" and not health.bio_online:
-            return False
-        if phase_name == "COGNITION" and not health.mind_online:
-            return False
-        return True
-
-    def handle_phase_crash(self, ctx, phase_name, error):
-        print(f"\n{Prisma.RED}!!! CRITICAL {phase_name} CRASH !!!{Prisma.RST}")
-        traceback.print_exc()
-        narrative = LoreManifest.get_instance().get("narrative_data") or {}
-        cathedral_logs = narrative.get("CATHEDRAL_COLLAPSE_LOGS", ["System Failure."])
-        eulogy = random.choice(cathedral_logs)
-        ctx.log(f'{Prisma.RED}🏛️ CATHEDRAL COLLAPSE: "{eulogy}"{Prisma.RST}')
-        component_map = {"OBSERVE": "PHYSICS", "METABOLISM": "BIO", "COGNITION": "MIND"}
-        comp = component_map.get(phase_name, "SIMULATION")
-        self.eng.system_health.report_failure(comp, error)
-        if comp == "PHYSICS":
-            ctx.physics = PanicRoom.get_safe_physics()
-        elif comp == "BIO":
-            ctx.bio_result = PanicRoom.get_safe_bio()
-            ctx.is_alive = True
-        elif comp == "MIND":
-            ctx.mind_state = PanicRoom.get_safe_mind()
-        ctx.log(
-            f"{Prisma.RED}⚠ {phase_name} FAILURE: Switching to Panic Protocol.{Prisma.RST}"
-        )
-
-
-class GeodesicOrchestrator:
-    def __init__(self, engine_ref):
-        self.eng = engine_ref
-        self.simulator = CycleSimulator(engine_ref)
-        self.reporter = CycleReporter(engine_ref)
-        if hasattr(self.eng, "symbiosis"):
-            self.symbiosis = self.eng.symbiosis
-        else:
-            self.symbiosis = SymbiosisManager(self.eng.events)
-
-    def _execute_core_cycle(
-        self, user_message: str, is_system: bool = False
-    ) -> CycleContext:
-        cycle_id = str(uuid.uuid4())[:8]
-        try:
-            ctx = CycleContext(input_text=user_message, is_system_event=is_system)
-            ctx.trace_id = cycle_id
-            if (
-                self.eng.phys
-                and hasattr(self.eng.phys, "observer")
-                and self.eng.phys.observer.last_physics_packet
-            ):
-                ctx.physics = self.eng.phys.observer.last_physics_packet.snapshot()
-            elif not ctx.physics:
-                ctx.physics = PanicRoom.get_safe_physics()
-                self.eng.events.log(
-                    "⚠️ PHYSICS BYPASS: Running on Panic Protocol.", "SYS"
-                )
-            ctx.validator = CongruenceValidator()
-            ctx.reality_stack = getattr(self.eng, "reality_stack", None)
-            ctx.user_name = self.eng.user_name
-            ctx.council_mandates = []
-            ctx.timestamp = time.time()
-            self.eng.events.flush()
-            ctx = self.simulator.run_simulation(ctx)
-            if self.eng.phys and hasattr(self.eng.phys, "observer"):
-                self.eng.phys.observer.last_physics_packet = ctx.physics.snapshot()
-            return ctx
-        except Exception as e:
-            self.eng.events.log(f"CYCLE CRASH: {e}", "CRIT")
-            ctx = CycleContext(input_text=user_message)
-            ctx.is_alive = False
-            ctx.crash_error = e
-            return ctx
-
-    def run_turn(self, user_message: str, is_system: bool = False) -> Dict[str, Any]:
-        ctx = self._execute_core_cycle(user_message, is_system)
-        if not ctx.is_alive:
-            if hasattr(ctx, "crash_error"):
-                return self._generate_crash_report(ctx.crash_error)
-            return self.eng.trigger_death(ctx.physics)
-
-        if getattr(ctx, "refusal_triggered", False) and getattr(
-            ctx, "refusal_packet", None
-        ):
-            return ctx.refusal_packet
-
-        snapshot = self.reporter.render_snapshot(ctx)
-        self._hydrate_snapshot_metadata(snapshot, ctx)
-        latency = time.time() - ctx.timestamp
-        if "ui" in snapshot:
-            self.symbiosis.monitor_host(latency, snapshot["ui"], len(user_message))
-        return snapshot
-
-    def run_headless_turn(
-        self, user_message: str, latency: float = 0.0
-    ) -> Dict[str, Any]:
-        ctx = self._execute_core_cycle(user_message)
-        if not ctx.is_alive:
-            if hasattr(ctx, "crash_error"):
-                return self._generate_crash_report(ctx.crash_error)
-            return self.eng.trigger_death(ctx.physics)
-
-        if getattr(ctx, "refusal_triggered", False) and getattr(
-            ctx, "refusal_packet", None
-        ):
-            return ctx.refusal_packet
-
-        snapshot = {"type": "HEADLESS", "logs": ctx.logs}
-        self._hydrate_snapshot_metadata(snapshot, ctx)
-        self.symbiosis.monitor_host(latency, "HEADLESS_MODE", len(user_message))
-        return snapshot
-
-    def _hydrate_snapshot_metadata(self, snapshot: Dict, ctx: CycleContext):
-        def _safe_dict(obj):
-            if hasattr(obj, "to_dict"):
-                return obj.to_dict()
-            if isinstance(obj, dict):
-                return obj
-            return {}
-
-        snapshot.update(
-            {
-                "trace_id": getattr(ctx, "trace_id", "UNKNOWN"),
-                "is_alive": True,
-                "physics": _safe_dict(ctx.physics),
-                "bio": _safe_dict(ctx.bio_result),
-                "mind": _safe_dict(ctx.mind_state),
-                "world": _safe_dict(ctx.world_state),
-                "soul": _safe_dict(getattr(self.eng, "soul", {})),
-                "council_mandates": getattr(ctx, "council_mandates", []),
-                "dream": getattr(ctx, "last_dream", None),
-            }
-        )
-
-    @staticmethod
-    def _generate_crash_report(e: Exception) -> Dict[str, Any]:
-        full_trace = "".join(traceback.format_exception(type(e), e, e.__traceback__))
-        safe_phys = PanicRoom.get_safe_physics()
-        safe_bio = PanicRoom.get_safe_bio()
-        ui_report = (
-            f"\n{Prisma.RED}*** REALITY FRACTURE: {e} ***{Prisma.RST}\n"
-            f"{Prisma.GRY}{full_trace}{Prisma.RST}\n"
-            f"{Prisma.OCHRE}[System stabilized in Safe Mode]{Prisma.RST}"
-        )
-        return {
-            "type": "CRASH",
-            "ui": ui_report,
-            "physics": safe_phys.to_dict(),
-            "bio": safe_bio,
-            "mind": PanicRoom.get_safe_mind(),
-            "world": {"orbit": ["VOID"], "loci_description": "System Failure"},
-            "logs": ["CRITICAL FAILURE", "SAFE MODE ACTIVE"],
-            "is_alive": True,
-        }