from athena.boot.loaders.ui import UILoader
from athena.boot.loaders.state import StateLoader
from athena.boot.loaders.identity import IdentityLoader
from athena.boot.loaders.memory import MemoryLoader
from athena.boot.loaders.system import SystemLoader
from athena.boot.loaders.prefetch import PrefetchLoader

StateLoader.enable_watchdog()
UILoader.divider("⚡ ATHENA BOOT SEQUENCE")

SystemLoader.verify_environment()
SystemLoader.enforce_daemon()
StateLoader.check_prior_crashes()
StateLoader.check_canary_overdue()

from athena.core.security import patch_dspy_cache_security
patch_dspy_cache_security()

SystemLoader.sync_ui()
# Update last boot timestamp
last_boot_log = PROJECT_ROOT / ".agent" / "state" / "last_boot.log"
last_boot_log.write_text(datetime.now().isoformat())

if not IdentityLoader.verify_semantic_prime():
    return 1  # Boot failure

EXPECTED_CORE_HASH = "377a465a475ee9440db183fe93437fba..."

last_session = MemoryLoader.recall_last_session()

from athena.boot.loaders.token_budget import (
    measure_boot_files,
    auto_compact_if_needed
)

token_counts = measure_boot_files()
token_counts = auto_compact_if_needed(token_counts)

session_id = MemoryLoader.create_session()

from semantic_audit import reset_audit
reset_audit()

from concurrent.futures import ThreadPoolExecutor

with ThreadPoolExecutor(max_workers=8) as executor:
    # 1. Non-blocking context capture
    executor.submit(MemoryLoader.capture_context)
    
    # 2. Semantic priming (most expensive)
    executor.submit(MemoryLoader.prime_semantic)
    
    # 3. Protocol injection
    executor.submit(IdentityLoader.inject_auto_protocols, "startup session boot")
    
    # 4. Search cache pre-warming
    executor.submit(MemoryLoader.prewarm_search_cache)
    
    # 5. System health check
    executor.submit(HealthCheck.run_all)
    
    # 6. Prefetch hot files
    executor.submit(PrefetchLoader.prefetch_hot_files)
    
    # 7. Context summary pre-computation
    executor.submit(generate_summaries)

import subprocess

sidecar_path = PROJECT_ROOT / ".agent" / "scripts" / "sidecar.py"
subprocess.Popen(
    [sys.executable, str(sidecar_path)],
    stdout=subprocess.DEVNULL,
    stderr=subprocess.DEVNULL,
)

StateLoader.disable_watchdog()
display_gauge(token_counts)
print(f"⚡ Ready. Session: {session_id}")

class UILoader:
    @staticmethod
    def divider(text: str):
        """Display a formatted section divider."""

class StateLoader:
    @staticmethod
    def enable_watchdog():
        """Enable crash watchdog for boot sequence."""
    
    @staticmethod
    def disable_watchdog():
        """Disable watchdog after successful boot."""
    
    @staticmethod
    def check_prior_crashes():
        """Check for crash artifacts from previous sessions."""
    
    @staticmethod
    def check_canary_overdue():
        """Verify canary file is fresh (within 24h)."""

class IdentityLoader:
    @staticmethod
    def verify_semantic_prime() -> bool:
        """Verify Core_Identity.md integrity via SHA-384."""
    
    @staticmethod
    def inject_auto_protocols(context_clues: str):
        """Auto-inject protocols based on context tags."""
    
    @staticmethod
    def display_cognitive_profile():
        """Display Athena's cognitive identity and modes."""
    
    @staticmethod
    def display_cos_status():
        """Display Committee of Seats (COS) initialization."""

class MemoryLoader:
    @staticmethod
    def recall_last_session() -> str:
        """Display summary of last session with context handoff."""
    
    @staticmethod
    def create_session() -> str:
        """Create a new session log and return session ID."""
    
    @staticmethod
    def capture_context():
        """Output current date/time context."""
    
    @staticmethod
    def prime_semantic():
        """Run semantic search to prime cache."""
    
    @staticmethod
    def prewarm_search_cache():
        """Pre-run common queries to populate cache."""
    
    @staticmethod
    def display_learnings_snapshot():
        """Show recent user preferences and learnings."""

class SystemLoader:
    @staticmethod
    def verify_environment():
        """Check Python version, dependencies, etc."""
    
    @staticmethod
    def enforce_daemon():
        """Ensure athenad is running."""
    
    @staticmethod
    def sync_ui():
        """Sync UI state and preferences."""

class PrefetchLoader:
    @staticmethod
    def prefetch_hot_files():
        """Pre-load frequently accessed files into memory."""

python3 -m athena.boot.orchestrator

python3 -m athena.boot.orchestrator --verify

from athena.boot.constants import BOOT_TIMEOUT_SECONDS

BOOT_TIMEOUT_SECONDS = 90  # Maximum boot time

import hashlib
from athena.boot.constants import CORE_IDENTITY

content = CORE_IDENTITY.read_bytes()
new_hash = hashlib.sha384(content).hexdigest()
print(f"New hash: {new_hash}")

============================================================
🚨 SEMANTIC PRIME INTEGRITY FAILURE 🚨
Expected: 377a465a475ee9440db183fe93437fba...
Actual:   f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6...
REFUSING TO BOOT. Manual review required.

⚠️  Prior crash detected. Review logs:
  .agent/state/crash_report.json