controller.py

# =========================================================
# CONTROLLER.PY — FULL SYSTEM ORCHESTRATION LAYER (FIXED)
# =========================================================

# ----------------------------
# CORE IMPORTS
# ----------------------------
from system_registry import SystemRegistry
from llm_society_controller import LLMSocietyController
from cognitive_stack import CognitiveStack
import llm_world_controller
from world_model import WorldModel
from learning_world_model import LearningWorldModel
from goal_system import GoalSystem

from scene_graph import SceneGraph
from visual_mapper import VisualMapper
from game_compiler import GameCompiler

from perception_encoder import PerceptionEncoder
from feedback_loop import FeedbackLoop
from live_sync import LiveSync

from abstraction_engine import AbstractionEngine
from experience_buffer import ExperienceBuffer
from strategy_router import StrategyRouter
from cultural_layer import CulturalLayer

from meta_learning_engine import MetaLearningEngine
from learning_feedback_router import LearningFeedbackRouter

from agent_identity import AgentIdentity
from narrative_memory import NarrativeMemory

from self_modifying_core import SelfModifyingCore
from self_test_harness import SelfTestHarness
from safe_evolution_gate import SafeEvolutionGate
from agent_controller import AgentController

# =========================================================
# CONTROLLER
# =========================================================

import random

import world_validator


class Controller:
    
    def __init__(self, registry):

        self.registry = registry

        # core systems resolved from registry
        self.live_sync = registry.get("live_sync")
        self.strategy_router = registry.get("strategy_router")
        self.abstraction_engine = registry.get("abstraction_engine")

        self.powerups = registry.get("powerups")
        self.metrics = registry.get("metrics")

        self.evolver = registry.get("evolver")
        self.updater = registry.get("updater")

        self.binding = registry.get("binding")
        self.inventory = registry.get("inventory")
        self.shape_renderer = registry.get("shape_renderer")

        # behavior stack
        self.tracker = registry.get("behavior_tracker")
        self.feature_extractor = registry.get("feature_extractor")
        self.behavior_model = registry.get("behavior_model")
        self.behavior_patch = registry.get("behavior_patch")

        self.world_spec = {"rules": {}, "entities": [], "powerups": []}
        self.patch_queue = []
        self.global_step = 0
        self.llm_world = registry.get("llm_world")
    # =====================================================
    # MAIN LIVE CYCLE
    # =====================================================
    def run_cycle_live(self, goal, input_text):

        # -----------------------------
        # PERCEPTION
        # -----------------------------
        perception = {
            "goal": goal,
            "input": input_text,
            "step": self.global_step
        }
        print("LLM WORLD OBJECT:", self.llm_world)
        print("HAS METHOD:", hasattr(self.llm_world, "generate_patch"))

        # -----------------------------
        # STRATEGY SELECTION
        # -----------------------------
        strategy = self.strategy_router.select(perception)

        # -----------------------------
        # MOCK EXECUTION RESULT
        # -----------------------------
        results = {
            "agent_1": random.random()
        }

        avg_reward = sum(results.values()) / len(results)

        # -----------------------------
        # BASE SIGNALS
        # -----------------------------
        signals = {
            "reward": avg_reward,
            "entropy": 0.3,
            "stability": 0.5
        }

        # -----------------------------
        # APPLY POWERUPS
        # -----------------------------
        signals = self.powerups.modify_signals(signals)

        # -----------------------------
        # BEHAVIOR ANALYSIS (PLAYER SIDE)
        # -----------------------------
        actions = self.tracker.get_recent()

        features = self.feature_extractor.extract(actions)

        style = self.behavior_model.classify(features)

        behavior_patch = self.behavior_patch.generate(style)

        if behavior_patch:
            self.patch_queue.append(("behavior", behavior_patch))

        # -----------------------------
        # WORLD EVOLUTION (AI SIDE)
        # -----------------------------
        self.metrics.log({"results": results})

        self.llm_world = self.registry.get("llm_world")
        self.validator = self.registry.get("world_validator")

        if self.global_step % 10 == 0:

            metrics = self.metrics.summarize()

            behavior = self.tracker.get_recent()

            patch = self.llm_world.generate_patch(
                self.world_spec,
                metrics,
                behavior
            )

            if self.validator.validate(patch):

                self.patch_queue.append(("llm", patch))

        # -----------------------------
        # APPLY PATCHES
        # -----------------------------
        self.apply_patch_queue()

        # -----------------------------
        # HUD RESOLUTION
        # -----------------------------
        active_shapes = self.binding.resolve(self.inventory, signals)

        # -----------------------------
        # FINAL OUTPUT
        # -----------------------------
        output = {
            "results": results,
            "signals": signals,
            "style": style,
            "hud_shapes": active_shapes,
            "world": self.world_spec
        }

        self.global_step += 1

        return output

    # =====================================================
    # PATCH APPLICATION
    # =====================================================
    def apply_patch_queue(self):

        for source, patch in self.patch_queue:

            if not isinstance(patch, dict):
                continue

            # rules
            if "rules" in patch:
                self.world_spec["rules"].update(patch["rules"])

            # entities
            if "entities" in patch:
                self.world_spec.setdefault("entities", [])
                self.world_spec["entities"] += patch["entities"]

            # powerups
            if "powerups" in patch:
                self.world_spec.setdefault("powerups", [])
                self.world_spec["powerups"] += patch["powerups"]

        self.patch_queue.clear()