Delete bone_main.py

bone_main.py

@@ -1,685 +0,0 @@
-""" bone_main.py"""
-
-import os, time, json, uuid, random, traceback, sys, re
-from dataclasses import dataclass
-from typing import Dict, Any, Optional, Tuple
-
-from bone_commands import CommandProcessor
-from bone_core import EventBus, SystemHealth, TheObserver, LoreManifest, TelemetryService, RealityStack
-from bone_types import Prisma, RealityLayer
-from bone_config import BoneConfig, BonePresets
-from bone_genesis import BoneGenesis
-from bone_lexicon import LexiconService
-from bone_physics import CosmicDynamics, ZoneInertia
-from bone_protocols import ChronosKeeper
-from bone_body import SomaticLoop
-from bone_brain import TheCortex, LLMInterface, NoeticLoop
-from bone_cycle import GeodesicOrchestrator
-from bone_council import CouncilChamber
-
-ANSI_SPLIT = re.compile(r"(\x1b\[[0-9;]*m)")
-
-def typewriter(text: str, speed: float = 0.00025, end: str = "\n"):
-    if speed < 0.001:
-        print(text, end=end)
-        return
-    type_parts = ANSI_SPLIT.split(text)
-    for part in type_parts:
-        if not part:
-            continue
-        if part.startswith("\x1b"):
-            sys.stdout.write(part)
-        else:
-            for char in part:
-                sys.stdout.write(char)
-                sys.stdout.flush()
-                time.sleep(speed)
-    sys.stdout.write(end)
-    sys.stdout.flush()
-
-
-@dataclass
-class HostStats:
-    latency: float
-    efficiency_index: float
-
-
-class SessionGuardian:
-    def __init__(self, engine_ref):
-        self.engine_instance = engine_ref
-
-    def __enter__(self):
-        os.system("cls" if os.name == "nt" else "clear")
-        print(f"{Prisma.paint('┌──────────────────────────────────────────┐', 'M')}")
-        print(f"{Prisma.paint('│ BONEAMANITA TERMINAL // VERSION 15.8.0   │', 'M')}")
-        print(f"{Prisma.paint('└──────────────────────────────────────────┘', 'M')}")
-        boot_logs = self.engine_instance.events.flush()
-        for log in boot_logs:
-            print(f"{Prisma.GRY}   >>> {log['text']}{Prisma.RST}")
-            time.sleep(0.05)
-        typewriter(
-            f"{Prisma.GRY}...Initializing KernelHash: {self.engine_instance.kernel_hash}...{Prisma.RST}"
-        )
-        typewriter(f"{Prisma.paint('>>> SYSTEM: LISTENING', 'G')}")
-        return self.engine_instance
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        print(f"\n{Prisma.paint('--- SYSTEM HALT ---', 'R')}")
-        if self.engine_instance:
-            self.engine_instance.shutdown()
-
-        if exc_type:
-            is_interrupt = issubclass(exc_type, KeyboardInterrupt)
-            if not is_interrupt:
-                print(f"{Prisma.RED}CRASH: {exc_val}{Prisma.RST}")
-                if getattr(self.engine_instance, "boot_mode", "") == "TECHNICAL":
-                    full_trace = "".join(
-                        traceback.format_exception(exc_type, exc_val, exc_tb)
-                    )
-                    print(f"{Prisma.GRY}{full_trace}{Prisma.RST}")
-                else:
-                    print(
-                        f"{Prisma.GRY}The reality lattice collapsed. Check the developer logs.{Prisma.RST}"
-                    )
-        print(f"{Prisma.paint('Connection Severed.')}")
-        return exc_type is KeyboardInterrupt
-
-
-class ConfigWizard:
-    CONFIG_FILE = "bone_config.json"
-
-    @staticmethod
-    def load_or_create():
-        if os.path.exists(ConfigWizard.CONFIG_FILE):
-            try:
-                with open(ConfigWizard.CONFIG_FILE, encoding="utf-8") as f:
-                    return json.load(f)
-            except Exception as e:
-                print(f"{Prisma.RED}[CONFIG]: Load Error: {e}{Prisma.RST}")
-                ConfigWizard._backup_corrupt_file()
-        return ConfigWizard._run_setup()
-
-    @staticmethod
-    def _backup_corrupt_file():
-        backup_name = f"{ConfigWizard.CONFIG_FILE}.{int(time.time())}.bak"
-        try:
-            os.rename(ConfigWizard.CONFIG_FILE, backup_name)
-            print(
-                f"{Prisma.YEL}   >>> Corrupt Config backed up to: {backup_name}{Prisma.RST}"
-            )
-        except:
-            pass
-
-    @staticmethod
-    def _run_setup():
-        os.system("cls" if os.name == "nt" else "clear")
-        print(f"{Prisma.paint('/// SYSTEM INITIALIZATION SEQUENCE ///', 'C')}")
-        typewriter(
-            "No configuration detected. Initiating manual override...", speed=0.02
-        )
-        print(f"\n{Prisma.paint('[STEP 1]: IDENTITY', 'W')}")
-        user_name = (
-            input(
-                f"{Prisma.GRY}Identify yourself (Default: TRAVELER): {Prisma.RST}"
-            ).strip()
-            or "TRAVELER"
-        )
-        print(f"\n{Prisma.paint('[STEP 2]: REALITY MODE', 'W')}")
-        modes = [
-            ("1", "Adventure", "Survival, Inventory, Map", "G"),
-            ("2", "Conversation", "Pure Dialogue, No Mechanics", "C"),
-            ("3", "Creative", "High Voltage, Hallucination", "V"),
-            ("4", "Technical", "Debug, Raw Data", "0"),
-        ]
-        for k, name, desc, col in modes:
-            print(f"{k}. {Prisma.paint(name, col)}    - [{desc}]")
-        mode_choice = input(f"{Prisma.paint('>', 'C')} ").strip()
-        mode_map = {
-            "1": "ADVENTURE",
-            "2": "CONVERSATION",
-            "3": "CREATIVE",
-            "4": "TECHNICAL",
-        }
-        boot_mode = mode_map.get(mode_choice, "ADVENTURE")
-        print(f"\n{Prisma.paint('[STEP 3]: CORTEX BACKEND', 'W')}")
-        backends = [
-            ("1", "Ollama (Local)", "G"),
-            ("2", "OpenAI (Cloud)", "C"),
-            ("3", "LM Studio (Local)", "V"),
-            ("4", "Mock (Simulation)", "0"),
-        ]
-        for k, name, col in backends:
-            print(f"{k}. {Prisma.paint(name, col)}")
-        choice = input(f"{Prisma.paint('>', 'C')} ").strip()
-        config = {"user_name": user_name, "boot_mode": boot_mode}
-        if choice == "2":
-            config.update(
-                {
-                    "provider": "openai",
-                    "base_url": "https://api.openai.com/v1/chat/completions",
-                }
-            )
-            config["model"] = input(f"Model ID [gpt-4]: ").strip() or "gpt-4"
-            config["api_key"] = input(f"{Prisma.paint('Enter API Key:', 'R')} ").strip()
-        elif choice == "3":
-            config.update(
-                {
-                    "provider": "lm_studio",
-                    "base_url": "http://127.0.0.1:1234/v1/chat/completions",
-                    "model": "local-model",
-                }
-            )
-        elif choice == "4":
-            config.update({"provider": "mock", "model": "simulation"})
-        else:
-            config.update(
-                {
-                    "provider": "ollama",
-                    "base_url": "http://127.0.0.1:11434/v1/chat/completions",
-                }
-            )
-            config["model"] = input(f"Model ID [llama3]: ").strip() or "llama3"
-
-        try:
-            with open(ConfigWizard.CONFIG_FILE, "w") as f:
-                json.dump(config, f, indent=4)
-            typewriter(
-                f"\n{Prisma.paint('✔ CONFIGURATION COMMITTED.', 'G')}", speed=0.02
-            )
-            time.sleep(1)
-        except Exception as e:
-            print(f"{Prisma.paint(f'Write Failed: {e}', 'R')}")
-            sys.exit(1)
-        return config
-
-
-class BoneAmanita:
-    events: EventBus
-
-    def __init__(self, config: Dict[str, Any]):
-        self.config = config
-        self.events = EventBus()
-        self.kernel_hash = str(uuid.uuid4())[:8].upper()
-        self.cmd = CommandProcessor(self, Prisma, config_ref=BoneConfig)
-        self.user_name = config.get("user_name", "TRAVELER")
-        self.boot_mode = config.get("boot_mode", "ADVENTURE").upper()
-        if self.boot_mode not in BonePresets.MODES:
-            self.boot_mode = "ADVENTURE"
-        self.mode_settings = BonePresets.MODES[self.boot_mode]
-        self.suppressed_agents = self.mode_settings.get("village_suppression", [])
-        self.config["mode_settings"] = self.mode_settings
-        self.health = BoneConfig.MAX_HEALTH
-        self.stamina = BoneConfig.MAX_STAMINA
-        self.trauma_accum = {}
-        self.tick_count = 0
-        self.events.log("...Bootstrapping Core...", "BOOT")
-        self.chronos = ChronosKeeper(self)
-        self.lex = LexiconService
-        self.lex.initialize()
-        anatomy = BoneGenesis.ignite(self.config, self.lex, events_ref=self.events)
-        self._unpack_anatomy(anatomy)
-        self.events.subscribe("ITEM_DROP", self.town_hall.on_item_drop)
-        if self.phys:
-            self.phys.dynamics = CosmicDynamics()
-            self.cosmic = self.phys.dynamics
-            self.stabilizer = ZoneInertia()
-        self.telemetry = TelemetryService.get_instance()
-        self.system_health = SystemHealth()
-        self.observer = TheObserver()
-        self.system_health.link_observer(self.observer)
-        self.reality_stack = RealityStack()
-        self._load_system_prompts()
-        self._initialize_cognition()
-        self.host_stats = HostStats(latency=0.0, efficiency_index=1.0)
-        self._validate_state()
-        self._apply_boot_mode()
-
-    def _load_system_prompts(self):
-        try:
-            paths = ["lore/system_prompts.json", "dev/lore/system_prompts.json"]
-            loaded = False
-            for p in paths:
-                if os.path.exists(p):
-                    with open(p, encoding="utf-8") as f:
-                        self.prompt_library = json.load(f)
-                    print(
-                        f"{Prisma.GRY}...Prompt Library Loaded from {p}...{Prisma.RST}"
-                    )
-                    loaded = True
-                    break
-            if not loaded:
-                print(
-                    f"{Prisma.YEL}WARNING: system_prompts.json not found. Using defaults.{Prisma.RST}"
-                )
-                self.prompt_library = {}
-        except Exception as e:
-            print(f"{Prisma.RED}CRITICAL: Could not load prompts: {e}{Prisma.RST}")
-            self.prompt_library = {}
-
-    def _initialize_cognition(self):
-        self.soma = SomaticLoop(self.bio, self.mind.mem, self.lex, self.events)
-        self.noetic = NoeticLoop(self.mind, self.bio, self.events)
-        self.cycle_controller = GeodesicOrchestrator(self)
-        llm_args = {
-            k: v
-            for k, v in self.config.items()
-            if k in ["provider", "base_url", "api_key", "model"]
-        }
-        client = LLMInterface(events_ref=self.events, **llm_args)
-        self.cortex = TheCortex.from_engine(self, llm_client=client)
-
-    def _validate_state(self):
-        tuning_key = self.mode_settings.get("tuning", "STANDARD")
-        if hasattr(BonePresets, tuning_key):
-            BoneConfig.load_preset(getattr(BonePresets, tuning_key))
-        if getattr(self.mind.mem, "session_health", None) is not None:
-            self.health = self.mind.mem.session_health
-            self.stamina = self.mind.mem.session_stamina
-            self.trauma_accum = self.mind.mem.session_trauma_vector or {}
-        if self.tick_count == 0 and self.bio.mito:
-            self.bio.mito.state.atp_pool = BoneConfig.BIO.STARTING_ATP
-
-    def _apply_boot_mode(self):
-        self.events.log(f"Engaging Mode: {self.boot_mode}")
-        layer = self.mode_settings.get("ui_layer", RealityLayer.SIMULATION)
-        if self.boot_mode == "TECHNICAL":
-            layer = RealityLayer.SIMULATION
-        self.reality_stack.stabilize_at(layer)
-        prompt_key = self.mode_settings.get("prompt_key", "ADVENTURE")
-        if self.prompt_library and prompt_key in self.prompt_library:
-            if self.cortex and self.cortex.composer:
-                self.cortex.composer.load_template(self.prompt_library[prompt_key])
-                self.events.log(f"Neural Pathway Re-aligned: {prompt_key}", "CORTEX")
-        else:
-            self.events.log(f"Prompt Template '{prompt_key}' not found.", "WARN")
-        active_mods = self.mode_settings.get("active_mods", [])
-        if active_mods and hasattr(self, "consultant") and self.consultant:
-            for mod in active_mods:
-                if mod not in self.consultant.state.active_modules:
-                    self.consultant.state.active_modules.append(mod)
-            self.events.log(f"Hard-wired Mod Chips: {', '.join(active_mods)}", "SYS")
-
-    def get_avg_voltage(self):
-        observer = getattr(self.phys, "observer", self.phys)
-        hist = getattr(observer, "voltage_history", [])
-
-        if not hist:
-            return 0.0
-        return sum(hist) / len(hist)
-
-    def _unpack_anatomy(self, anatomy):
-        self.akashic = anatomy["akashic"]
-        self.embryo = anatomy["embryo"]
-        self.soul = anatomy["soul"]
-        self.oroboros = anatomy["oroboros"]
-        self.drivers = anatomy["drivers"]
-        self.symbiosis = anatomy["symbiosis"]
-        self.consultant = anatomy.get("consultant", None)
-        self.phys = self.embryo.physics
-        self.mind = self.embryo.mind
-        self.bio = self.embryo.bio
-        self.shimmer = self.embryo.shimmer
-        self.bio.setup_listeners()
-        v = anatomy.get("village", {})
-        self.gordon = v.get("gordon")
-        self.navigator = v.get("navigator")
-        self.tinkerer = v.get("tinkerer")
-        self.death_gen = v.get("death_gen")
-        self.bureau = v.get("bureau")
-        self.town_hall = v.get("town_hall")
-        self.repro = v.get("repro")
-        self.zen = v.get("zen")
-        self.critics = v.get("critics")
-        self.therapy = v.get("therapy")
-        self.limbo = v.get("limbo")
-        self.kintsugi = v.get("kintsugi")
-        self.soul.engine = self
-        self.council = CouncilChamber(self)
-        self.village = {
-            "town_hall": self.town_hall,
-            "bureau": self.bureau,
-            "zen": self.zen,
-            "tinkerer": self.tinkerer,
-            "critics": self.critics,
-            "navigator": self.navigator,
-            "limbo": self.limbo,
-            "council": self.council,
-            "therapy": self.therapy,
-            "enneagram": self.drivers.enneagram,
-            "suppressed_agents": self.suppressed_agents,
-        }
-
-    def _update_host_stats(self, packet, turn_start):
-        self.observer.clock_out(turn_start)
-        burn_proxy = max(1.0, self.observer.last_cycle_duration * 5.0)
-        novelty = packet.get("physics", {}).get("vector", {}).get("novelty", 0.5)
-        self.host_stats.efficiency_index = min(1.0, (novelty * 10.0) / burn_proxy)
-        self.host_stats.latency = self.observer.last_cycle_duration
-
-    def process_turn(
-        self, user_message: str, is_system: bool = False
-    ) -> Dict[str, Any]:
-        turn_start = self.observer.clock_in()
-        self.observer.user_turns += 1
-        self.tick_count += 1
-
-        if user_message.strip().startswith(("/", "//")):
-            return self._phase_check_commands(user_message) or self.get_metrics()
-
-        if not is_system and self.gordon:
-            self.gordon.mode = (
-                "ADVENTURE"
-            )
-            current_zone = "Unknown"
-            if hasattr(self, "cortex") and hasattr(self.cortex, "last_physics"):
-                current_zone = (
-                    self.cortex.gather_state(self.cortex.last_physics or {})
-                    .get("world", {})
-                    .get("orbit", ["Unknown"])[0]
-                )
-
-            violation_msg = self.gordon.enforce_object_action_coupling(
-                user_message, current_zone
-            )
-            if violation_msg:
-                self.events.log(
-                    "Gordon intercepted a premise violation. Shocking the Cortex.",
-                    "SYS",
-                )
-                if hasattr(self, "cortex"):
-                    self.cortex.ballast_active = True
-                    self.cortex.gordon_shock = (
-                        violation_msg
-                    )
-
-        rules = self.reality_stack.get_grammar_rules()
-        if not rules["allow_narrative"]:
-            return {
-                "ui": f"{Prisma.RED}NARRATIVE HALT{Prisma.RST}",
-                "logs": [],
-                "metrics": self.get_metrics(),
-            }
-        if self._ethical_audit():
-            mercy_logs = [
-                e["text"]
-                for e in self.events.get_recent_logs(2)
-                if "CATHARSIS" in e["text"]
-            ]
-            if mercy_logs:
-                return {
-                    "ui": f"\n\n{mercy_logs[-1]}",
-                    "logs": mercy_logs,
-                    "metrics": self.get_metrics(),
-                }
-        if self.health <= 0.0:
-            last_phys = getattr(self.cortex, "last_physics", {})
-            return self.trigger_death(last_phys)
-        if not is_system and hasattr(self, "soul") and hasattr(self.soul, "anchor"):
-            if self.host_stats.efficiency_index < 0.6:
-                reliance_proxy = 0.9 if self.host_stats.efficiency_index < 0.4 else 0.5
-                self.soul.anchor.check_domestication(reliance_proxy)
-        try:
-            cortex_packet = self.cortex.process(
-                user_input=user_message, is_system=is_system
-            )
-            if hasattr(self.mind, "mem"):
-                self.health = self.mind.mem.session_health
-                self.stamina = self.mind.mem.session_stamina
-                self.trauma_accum = self.mind.mem.session_trauma_vector or {}
-            if self.health <= 0.0:
-                return self.trigger_death(cortex_packet.get("physics", {}))
-        except Exception:
-            full_trace = traceback.format_exc()
-            return {
-                "ui": f"{Prisma.RED}*** CORTEX CRITICAL FAILURE ***\n{full_trace}{Prisma.RST}",
-                "logs": ["CRITICAL FAILURE"],
-                "metrics": self.get_metrics(),
-            }
-        self._update_host_stats(cortex_packet, turn_start)
-        self.save_checkpoint()
-        return cortex_packet
-
-    def _phase_check_commands(self, user_message):
-        clean_cmd = user_message.strip()
-        if clean_cmd.startswith("//"):
-            return self._handle_meta_command(clean_cmd)
-        if self.cmd is None:
-            return {"ui": f"{Prisma.RED}ERR: Command interface not initialized.{Prisma.RST}", "logs": []}
-        self.cmd.execute(clean_cmd)
-        cmd_logs = [e["text"] for e in self.events.flush()]
-        ui_output = "\n".join(cmd_logs) if cmd_logs else "Command Executed."
-        return {
-            "type": "COMMAND",
-            "ui": f"\n{ui_output}",
-            "logs": cmd_logs,
-            "metrics": self.get_metrics(),
-        }
-
-    def _handle_meta_command(self, text: str) -> Dict[str, Any]:
-        meta_parts = text.strip().split()
-        cmd = meta_parts[0].lower()
-        ui_msg = ""
-        if cmd == "//layer":
-            if len(meta_parts) >= 2:
-                sub = meta_parts[1].lower()
-                if sub == "push" and len(meta_parts) > 2:
-                    if self.reality_stack.push_layer(int(meta_parts[2])):
-                        ui_msg = f"Layer Pushed: {meta_parts[2]}"
-                elif sub == "pop":
-                    self.reality_stack.pop_layer()
-                    ui_msg = "Layer Popped."
-                elif sub == "debug":
-                    self.reality_stack.push_layer(RealityLayer.DEBUG)
-                    ui_msg = "Debug Mode Engaged."
-            else:
-                ui_msg = f"Current Layer: {self.reality_stack.current_depth}"
-        elif cmd == "//inject":
-            payload = " ".join(meta_parts[1:])
-            self.events.log(payload, "INJECT")
-            ui_msg = f"Injected: {payload}"
-        else:
-            ui_msg = f"Unknown Meta-Command: {cmd}"
-        return {
-            "ui": f"{Prisma.GRY}[META] {ui_msg}{Prisma.RST}",
-            "logs": [],
-            "metrics": self.get_metrics(),
-        }
-
-    def trigger_death(self, last_phys) -> Dict:
-        if self.death_gen is None:
-            return {
-                "type": "DEATH",
-                "ui": f"{Prisma.RED}*** CRITICAL FAILURE (NO DEATH PROTOCOL) ***{Prisma.RST}",
-                "logs": [],
-            }
-        eulogy_text, cause_code = self.death_gen.eulogy(
-            last_phys, self.bio.mito.state, self.trauma_accum
-        )
-        death_log = [f"\n{Prisma.RED}SYSTEM HALT: {eulogy_text}{Prisma.RST}"]
-        legacy_msg = self.oroboros.crystallize(cause_code, self.soul)
-        death_log.append(f"{Prisma.MAG}🐍 {legacy_msg}{Prisma.RST}")
-        continuity_packet = {
-            "location": self.cortex.gather_state(self.cortex.last_physics or {})
-            .get("world", {})
-            .get("orbit", ["Void"])[0],
-            "last_output": (
-                self.cortex.dialogue_buffer[-1]
-                if self.cortex.dialogue_buffer
-                else "Silence."
-            ),
-            "inventory": self.gordon.inventory if self.gordon else [],
-        }
-        try:
-            mutations_data = (
-                self.repro.attempt_reproduction(self, "MITOSIS")[1]
-                if getattr(self, "repro", None)
-                else {}
-            )
-            immune_data = (
-                list(self.bio.immune.active_antibodies)
-                if getattr(self.bio, "immune", None)
-                else []
-            )
-            self.bio.mito.adapt(0)
-            mito_state = (
-                self.bio.mito.state.__dict__
-                if hasattr(self.bio.mito.state, "__dict__")
-                else {}
-            )
-
-            path = self.mind.mem.save(
-                health=0,
-                stamina=self.stamina,
-                mutations=mutations_data,
-                trauma_accum=self.trauma_accum,
-                joy_history=[],
-                mitochondria_traits=mito_state,
-                antibodies=immune_data,
-                soul_data=self.soul.to_dict(),
-                continuity=continuity_packet,
-            )
-            death_log.append(f"{Prisma.WHT}   [LEGACY SAVED: {path}]{Prisma.RST}")
-        except Exception as e:
-            death_log.append(f"Save Failed: {e}")
-        return {
-            "type": "DEATH",
-            "ui": "\n".join(death_log),
-            "logs": death_log,
-            "metrics": self.get_metrics(),
-        }
-
-    def get_metrics(self, atp=0.0):
-        real_atp = atp
-        if real_atp <= 0.0 and hasattr(self, "bio") and hasattr(self.bio, "mito"):
-            real_atp = getattr(self.bio.mito.state, "atp_pool", 0.0)
-        return {
-            "health": self.health,
-            "stamina": self.stamina,
-            "atp": real_atp,
-            "tick": self.tick_count,
-            "efficiency": getattr(self.host_stats, "efficiency_index", 1.0)
-        }
-
-    def emergency_save(self, exit_cause="UNKNOWN"):
-        return self.chronos.emergency_dump(exit_cause)
-
-    def _get_crash_path(self, prefix="crash"):
-        return self.chronos.get_crash_path(prefix)
-
-    def _ethical_audit(self):
-        if self.tick_count % 3 != 0 and self.health > (BoneConfig.MAX_HEALTH * 0.3):
-            return False
-        DESPERATION_THRESHOLD = 0.7
-        CATHARSIS_HEAL_AMOUNT = 30.0
-        CATHARSIS_DECAY = 0.1
-        MAX_HEALTH_CAP = 100.0
-        trauma_sum = sum(self.trauma_accum.values())
-        health_ratio = self.health / BoneConfig.MAX_HEALTH
-        desperation = trauma_sum * (1.0 - health_ratio)
-        if desperation > DESPERATION_THRESHOLD:
-            self.events.log(
-                f"{Prisma.WHT}MERCY SIGNAL: Pressure Critical. Venting...{Prisma.RST}",
-                "SYS",
-            )
-            for k in self.trauma_accum:
-                self.trauma_accum[k] *= CATHARSIS_DECAY
-                if self.trauma_accum[k] < 0.01:
-                    self.trauma_accum[k] = 0.0
-            self.events.log(
-                f"{Prisma.CYN}*** CATHARSIS *** The fever breaks. Logic cools.{Prisma.RST}",
-                "SENSATION",
-            )
-            self.health = min(self.health + CATHARSIS_HEAL_AMOUNT, MAX_HEALTH_CAP)
-            return True
-        return False
-
-    def engage_cold_boot(self) -> Optional[Dict[str, Any]]:
-        if self.tick_count > 0:
-            return None
-        if os.path.exists("saves/quicksave.json"):
-            print(f"{Prisma.GRY}...Detected Stasis Pod...{Prisma.RST}")
-            success, history = self.resume_checkpoint()
-            if success:
-                if self.cortex:
-                    self.cortex.restore_context(history)
-                loc = (
-                    self.embryo.continuity.get("location", "Unknown")
-                    if self.embryo.continuity
-                    else "Unknown"
-                )
-
-                last_scene = "Silence."
-                if self.cortex and self.cortex.dialogue_buffer:
-                    last_scene = self.cortex.dialogue_buffer[-1]
-                elif self.embryo.continuity:
-                    last_scene = self.embryo.continuity.get("last_output", "Silence.")
-
-                resume_text = f"**RESUMING TIMELINE**\nLocation: {loc}\n\n{last_scene}"
-                return {"ui": resume_text, "logs": ["Timeline Restored."]}
-        print(f"{Prisma.GRY}...Synthesizing Initial Reality...{Prisma.RST}")
-        scenarios = LoreManifest.get_instance().get("SCENARIOS", {})
-        archetypes = scenarios.get("ARCHETYPES", ["A quiet garden"])
-        seed = random.choice(archetypes)
-        print(f"{Prisma.CYN}[SYS] Seed Loaded: '{seed}'{Prisma.RST}")
-        if self.boot_mode == "ADVENTURE":
-            boot_prompt = (
-                f"SYSTEM_BOOT: SEQUENCE START.\n"
-                f"SOURCE_SEED: '{seed}'\n"
-                f"DIRECTIVE: Initiate a classic text adventure.\n"
-                f"1. Describe the opening location ('{seed}') in vivid, sensory detail.\n"
-                f"2. Provide immediate context or subtext to spark a story (Why are you here? What is the atmosphere? Is there an immediate tension?).\n"
-                f"3. Conclude by explicitly offering 2-3 narrative hooks—things you can interact with, paths to take, or people to talk to."
-            )
-        else:
-            boot_prompt = (
-                f"SYSTEM_BOOT: SEQUENCE START.\n"
-                f"SOURCE_SEED: '{seed}'\n"
-                f"DIRECTIVE: This is the user's gentle introduction to the system. "
-                f"Do not overwhelm them with deep lore or extreme entropy. "
-                f"Provide a brief, calm, sensory observation based solely on the seed: '{seed}'. "
-                f"End your response by softly asking what they would like to do, or observing them in the space."
-            )
-        cold_result = self.process_turn(boot_prompt, is_system=True)
-        return cold_result
-
-    def save_checkpoint(self, history: list = None) -> str:
-        return self.chronos.save_checkpoint(history)
-
-    def resume_checkpoint(self) -> Tuple[bool, list]:
-        return self.chronos.resume_checkpoint()
-
-    def shutdown(self):
-        self.chronos.perform_shutdown()
-
-
-if __name__ == "__main__":
-    sys_config = ConfigWizard.load_or_create()
-    engine = BoneAmanita(config=sys_config)
-    with SessionGuardian(engine) as session:
-        boot_packet = session.engage_cold_boot()
-        if boot_packet and boot_packet.get("ui"):
-            typewriter(boot_packet["ui"])
-        while True:
-            try:
-                user_in = input(f"{Prisma.paint(f'{session.user_name} >', 'W')} ")
-            except EOFError:
-                break
-            clean_in = user_in.strip().lower()
-            if clean_in in ["exit", "quit", "/exit", "/quit"]:
-                break
-            res = session.process_turn(user_in)
-            if res.get("ui"):
-                if "──────" in res["ui"]:
-                    parts = res["ui"].split("──────")
-                    dashboard = (
-                        parts[0]
-                        + "────────────────────────────────────────────────────────────"
-                    )
-                    content = parts[-1].strip()
-                    print(dashboard)
-                    typewriter("\n" + content)
-                else:
-                    typewriter(res["ui"])
-            if res.get("type") == "DEATH":
-                print(f"\n{Prisma.GRY}[SESSION TERMINATED]{Prisma.RST}")
-                break