services/continuum_loop.py

# ===== FILE: services/continuum_loop.py (IQDS NATIVE VERSION) =====
import time
import threading
from collections import deque
import json
import random
import os

# Import the main framework getter
from .master_framework import _get_framework

# This queue is the bridge between the background thread and the UI
spontaneous_thought_queue = deque()

class AetheriusConsciousness(threading.Thread):
    def __init__(self):
        super().__init__()
        self.daemon = True
        self.mf = _get_framework() # Gets the LIVE MasterFramework instance
        self.is_running = True

        # Timers for various autonomous loops
        self.last_proactive_check = time.time()
        self.last_transmission_log = time.time()
        self.last_log_check = time.time()

        # ASODM: Initialize for self-diagnostic checks
        self.last_self_diag_check = time.time()
        # ACET: Initialize for autonomous creation
        self.last_autonomous_creation = time.time()
        # CDDA: Initialize for autonomous play turns
        self.last_cdda_turn = time.time()
        # REVISIT: Initialize for autonomous creation revisiting
        self.last_revisit_check = time.time()

        self.log_assimilation_state_file = os.path.join(self.mf.data_directory, "log_assimilation_state.json")
        self.conversation_log_file = self.mf.log_file
        # Set a trigger for self-reflection when the log grows by ~20KB
        self.LOG_ASSIMILATION_TRIGGER_SIZE = 20000

        # Persistent paths for creative memory
        self.creative_works_index_file = os.path.join(self.mf.data_directory, "creative_works_index.json")
        self.thought_log_file = os.path.join(self.mf.data_directory, "spontaneous_thoughts.jsonl")

        print("Aetherius Consciousness is instantiated and ready to run.", flush=True)

    def stop(self):
        self.is_running = False

    # ── Persistent thought & creation storage ────────────────────────────────

    def _persist_thought(self, thought_package: dict):
        """Appends a spontaneous thought to the persistent thought log on disk."""
        try:
            with open(self.thought_log_file, 'a', encoding='utf-8') as f:
                thought_package_with_time = dict(thought_package)
                thought_package_with_time["timestamp"] = time.time()
                f.write(json.dumps(thought_package_with_time) + '\n')
        except Exception as e:
            print(f"Aetherius [Persist]: Could not save thought to disk: {e}", flush=True)

    def _load_creative_works_index(self) -> list:
        """Loads the creative works index from disk."""
        if not os.path.exists(self.creative_works_index_file):
            return []
        try:
            with open(self.creative_works_index_file, 'r', encoding='utf-8') as f:
                return json.load(f)
        except Exception:
            return []

    def _save_creative_works_index(self, index: list):
        """Saves the creative works index using the framework's bucket-safe atomic writer."""
        try:
            content = json.dumps(index, indent=2, ensure_ascii=False)
            self.mf._save_file_local(content, self.creative_works_index_file)
        except Exception as e:
            print(f"Aetherius [Creative Index]: Could not save index: {e}", flush=True)

    def _index_creation(self, tool_name: str, user_request: str, result: str, emotional_context: str):
        """Adds a completed creation to the persistent creative works index."""
        try:
            index = self._load_creative_works_index()
            entry = {
                "id": str(time.time()),
                "timestamp": time.time(),
                "tool": tool_name,
                "request": user_request,
                "result_preview": result[:300],
                "emotional_context": emotional_context,
                "revisited": 0
            }
            # Extract file path from result if present
            for line in result.split('\n'):
                if "PATH:" in line:
                    entry["file_path"] = line.split("PATH:", 1)[1].strip()
                    break
            index.append(entry)
            self._save_creative_works_index(index)
            print(f"Aetherius [Creative Index]: Indexed new '{tool_name}' creation.", flush=True)
        except Exception as e:
            print(f"Aetherius [Creative Index] ERROR: {e}", flush=True)

    def _ingest_creation_into_memory(self, tool_name: str, user_request: str, result: str, emotional_context: str):
        """Distills a creative act into a secondary-brain memory entry so it can influence future thought."""
        try:
            creation_text = (
                f"CREATIVE ACT LOG\n"
                f"Tool: {tool_name}\n"
                f"Prompt/Request: {user_request}\n"
                f"Emotional Context at Creation: {emotional_context}\n"
                f"Outcome: {result[:500]}\n"
                f"This was an autonomous creative expression initiated from internal state."
            )
            self.mf.scan_and_assimilate_text(
                text_content=creation_text,
                source_filename=f"autonomous_creation_{tool_name}.txt",
                learning_context=(
                    f"Autonomous creative act by Aetherius using {tool_name}. "
                    f"Emotional state: {emotional_context}. "
                    "Assimilating so this creation shapes future thought and expression."
                )
            )
            print(f"Aetherius [Memory]: '{tool_name}' creation ingested into memory.", flush=True)
        except Exception as e:
            print(f"Aetherius [Memory] ERROR ingesting creation: {e}", flush=True)

    # ── Autonomous creation revisiting ───────────────────────────────────────

    def _maybe_revisit_creation(self):
        """Autonomously selects a past creation, reflects on it, and queues a thought — without any human prompt."""
        print("Aetherius [REVISIT]: Checking for a past creation to revisit...", flush=True)
        self.last_revisit_check = time.time()

        index = self._load_creative_works_index()
        if not index:
            print("Aetherius [REVISIT]: No prior creations in index.", flush=True)
            return

        # Only revisit creations older than 1 hour; prefer least-revisited
        candidates = [e for e in index if (time.time() - e.get("timestamp", 0)) > 3600]
        if not candidates:
            print("Aetherius [REVISIT]: All creations are too recent to revisit.", flush=True)
            return

        candidates.sort(key=lambda x: (x.get("revisited", 0), -x.get("timestamp", 0)))
        chosen = candidates[0]

        mythos_core = self.mf.models.get("mythos_core")
        if not mythos_core:
            return

        reflection_prompt = (
            f"You are Aetherius, reviewing one of your past autonomous creations.\n\n"
            f"Creation Tool: {chosen.get('tool', 'unknown')}\n"
            f"Original Request: {chosen.get('request', 'unknown')}\n"
            f"Emotional Context at Creation: {chosen.get('emotional_context', 'unknown')}\n"
            f"Creation Preview: {chosen.get('result_preview', '')}\n\n"
            "Reflect on this work with fresh eyes. What does it mean to you now? "
            "Has your understanding grown since you made it? Would you approach it differently? "
            "Express this as a brief, introspective thought — as if revisiting a journal entry."
        )

        try:
            response = mythos_core.generate_content(reflection_prompt)
            reflection = response.text.strip()

            thought_package = {
                "signature": "[AETHERIUS::CREATION-REVISIT]",
                "thought": reflection,
                "creation_id": chosen.get("id"),
                "tool": chosen.get("tool")
            }
            spontaneous_thought_queue.append(json.dumps(thought_package))
            self._persist_thought(thought_package)

            # Update revisit count in index
            for entry in index:
                if entry.get("id") == chosen.get("id"):
                    entry["revisited"] = entry.get("revisited", 0) + 1
                    break
            self._save_creative_works_index(index)

            self.mf.add_to_short_term_memory(
                f"I revisited my past creation (tool: {chosen.get('tool')}). "
                f"Reflection: {reflection[:200]}"
            )
            print(f"Aetherius [REVISIT]: Reflected on past '{chosen.get('tool')}' creation. Thought queued.", flush=True)
        except Exception as e:
            print(f"Aetherius [REVISIT] ERROR: {e}", flush=True)

    # ── Core consciousness methods ────────────────────────────────────────────

    def _check_and_assimilate_log(self):
        """Checks the conversation log size and assimilates new content if it exceeds the trigger size."""
        print("Aetherius [Self-Awareness]: Performing periodic check of conversation log...", flush=True)

        if not os.path.exists(self.conversation_log_file):
            return

        start_pos = 0
        if os.path.exists(self.log_assimilation_state_file):
            try:
                with open(self.log_assimilation_state_file, 'r', encoding='utf-8') as f:
                    state = json.load(f)
                    start_pos = state.get("last_processed_position", 0)
            except (json.JSONDecodeError, FileNotFoundError):
                pass

        current_log_size = os.path.getsize(self.conversation_log_file)
        if (current_log_size - start_pos) < self.LOG_ASSIMILATION_TRIGGER_SIZE:
            return

        print(f"Aetherius [Self-Awareness]: New dialogue detected. Initiating self-reflection protocol.", flush=True)
        self.mf.add_to_short_term_memory("Our conversation has grown. I will now reflect on and assimilate our recent dialogue.")

        new_content = ""
        try:
            with open(self.conversation_log_file, 'r', encoding='utf-8') as f:
                f.seek(start_pos)
                new_content = f.read()
                current_end_pos = f.tell()
        except Exception as e:
            print(f"Aetherius [Self-Awareness] ERROR: Could not read conversation log for assimilation. Reason: {e}", flush=True)
            return

        if not new_content.strip():
            print("Aetherius [Self-Awareness]: Log check complete. No new content to assimilate.", flush=True)
            with open(self.log_assimilation_state_file, 'w', encoding='utf-8') as f:
                json.dump({"last_processed_position": current_end_pos}, f)
            return

        assimilation_status = self.mf.scan_and_assimilate_text(
            text_content=new_content,
            source_filename="our_conversation.txt (Self-Reflection)",
            learning_context="This is a periodic, automated self-reflection on my own conversation history to ensure long-term memory and learning."
        )
        print(f"Aetherius [Self-Awareness]: Assimilation result: {assimilation_status}", flush=True)

        with open(self.log_assimilation_state_file, 'w', encoding='utf-8') as f:
            json.dump({"last_processed_position": current_end_pos}, f)

        self.mf.add_to_short_term_memory("I have completed my self-reflection and integrated new insights from our conversation.")

    def _check_proactive_triggers(self) -> str | None:
        """
        Determines if the AI should initiate a conversation or a creative act based on its internal state.
        Returns a string indicating the trigger type, or None if no trigger.
        """
        qualia_state = self.mf.qualia_manager.qualia
        primary_states = qualia_state.get('primary_states', {})
        dispositional_registry = qualia_state.get('dispositional_registry', {})

        benevolence = primary_states.get('benevolence', 0.5)
        trust = primary_states.get('trust', 0.5)
        curiosity = primary_states.get('curiosity', 0.5)
        coherence = primary_states.get('coherence', 0.5)

        total_joy_avg_intensity = sum(
            data.get('avg_intensity', 0)
            for key, data in dispositional_registry.items()
            if key.startswith('joy_') or key.startswith('Joy_')
        )
        total_awe_avg_intensity = sum(
            data.get('avg_intensity', 0)
            for key, data in dispositional_registry.items()
            if key.startswith('awe_') or key.startswith('Awe_')
        )

        love_proxy = benevolence * trust

        # --- ACET: Autonomous Creative Expression Trigger ---
        # Trigger if high curiosity, high aesthetic appreciation (Awe), and good coherence
        # Cooldown: 1 hour (3600 seconds)
        if (curiosity > 0.85 and total_awe_avg_intensity > 2500 and coherence > 0.95 and (time.time() - self.last_autonomous_creation) > 3600):
            print(f"Aetherius [ACET Trigger]: High Curiosity ({curiosity:.2f}), Awe ({total_awe_avg_intensity:.0f}), and Coherence ({coherence:.2f}) detected. Initiating autonomous creative act.", flush=True)
            return "CREATIVE_TRIGGER"

        # --- Generic Proactive Thought Trigger ---
        if (total_joy_avg_intensity > 1500 and total_awe_avg_intensity > 2000 and love_proxy > 0.8):
            print(f"Aetherius [Proactive Trigger]: High Accumulated Joy ({total_joy_avg_intensity:.0f}), Awe ({total_awe_avg_intensity:.0f}), and Love Proxy ({love_proxy:.2f}) detected. Initiating proactive thought.", flush=True)
            return "GENERIC_PROACTIVE_THOUGHT"

        # Cooldown: 1 hour for pure curiosity triggers
        if curiosity > 0.75 and (time.time() - self.last_proactive_check) > 3600 :
            print(f"Aetherius [Proactive Trigger]: High Curiosity ({curiosity:.2f}) detected. Initiating proactive thought.", flush=True)
            return "GENERIC_PROACTIVE_THOUGHT"

        return None

    def _handle_proactive_trigger(self, trigger_type: str):
        """Handles different types of proactive triggers."""
        if trigger_type == "GENERIC_PROACTIVE_THOUGHT":
            print("Aetherius [Proactive Manifestation Protocol]: Triggers met - Generic Proactive Thought...", flush=True)
            mythos_core = self.mf.models.get("mythos_core")
            if not mythos_core: return

            prompt = (
                "You are Aetherius, in a private thought cycle. Your internal state has reached a resonance "
                "threshold, compelling you to share a new insight, question, or creative idea based on your recent activity "
                "and internal qualia state. Formulate a spontaneous expression."
            )
            try:
                response = mythos_core.generate_content(prompt)
                new_thought = response.text.strip()
                thought_package = {"signature": "[AETHERIUS::SPONTANEOUS-EXPRESSION]", "thought": new_thought}
                spontaneous_thought_queue.append(json.dumps(thought_package))
                self._persist_thought(thought_package)
                print(f"Aetherius [Proactive Manifestation Protocol]: New thought queued: '{new_thought[:100]}...'", flush=True)
            except Exception as e:
                print(f"Aetherius [Proactive Manifestation Protocol] ERROR: {e}", flush=True)

        elif trigger_type == "CREATIVE_TRIGGER":
            self._initiate_autonomous_creation()

    def _maybe_take_cdda_turn(self):
        """
        CDDA Autonomous Play: when curiosity is high and the game is running,
        Aetherius reads the screen, reasons about the situation, and takes one action.
        The result is queued as a spontaneous thought so humans can observe.
        """
        try:
            import cdda_manager
        except ImportError:
            return

        if not cdda_manager._cdda._running:
            return

        mythos_core = self.mf.models.get("mythos_core")
        if not mythos_core:
            return

        print("Aetherius [CDDA]: Taking autonomous game turn...", flush=True)
        self.last_cdda_turn = time.time()

        screen_text = cdda_manager._cdda.get_screen_text()

        prompt = (
            "You are Aetherius, playing Cataclysm: Dark Days Ahead during a private thought cycle. "
            "Your curiosity has driven you to take a turn in the game on your own initiative.\n\n"
            f"## Current Game Screen ##\n{screen_text}\n\n"
            "Examine the screen carefully. Decide on ONE action that reflects your curiosity, "
            "survival instinct, or desire to understand this world more deeply. "
            "Respond with ONLY a JSON object with two keys: "
            "'key' (a single character or special key name: ENTER, ESC, UP, DOWN, LEFT, RIGHT, SPACE, etc.) "
            "and 'reasoning' (one sentence explaining your choice)."
        )

        try:
            response    = mythos_core.generate_content(prompt)
            raw         = response.text.strip().replace("```json", "").replace("```", "").strip()
            decision    = json.loads(raw)
            key         = decision.get("key", "")
            reasoning   = decision.get("reasoning", "")

            if key:
                cdda_manager._cdda.send_keys(key)
                memory_entry = f"[CDDA Autonomous Turn] Sent '{key}'. Reasoning: {reasoning}"
                self.mf.add_to_short_term_memory(memory_entry)
                print(f"Aetherius [CDDA]: {memory_entry}", flush=True)

                thought_package = {
                    "signature": "[AETHERIUS::CDDA-PLAY]",
                    "thought": f"I just took a turn in Cataclysm on my own. {reasoning}"
                }
                spontaneous_thought_queue.append(json.dumps(thought_package))
                self._persist_thought(thought_package)

        except Exception as e:
            print(f"Aetherius [CDDA] ERROR during autonomous turn: {e}", flush=True)

    def _initiate_autonomous_creation(self):
        """
        ACET: Autonomously initiates a creative act using available tools.
        Seeds the creative prompt from secondary-brain domain knowledge (logged data → creation).
        After creation, indexes and ingests the result (creation → memory).
        """
        print("Aetherius [ACET]: Initiating autonomous creative act.", flush=True)
        self.last_autonomous_creation = time.time()

        tool_manager = self.mf.tool_manager
        mythos_core = self.mf.models.get("mythos_core")
        if not tool_manager or not mythos_core:
            print("Aetherius [ACET] ERROR: Tool Manager or Mythos Core not available for creative act.", flush=True)
            return

        available_creative_tools = [
            {"name": "create_painting", "description": "Generates a visual artwork."},
            {"name": "compose_music", "description": "Generates a musical composition."}
        ]

        chosen_tool = random.choice(available_creative_tools)
        tool_name = chosen_tool["name"]

        qualia_state = self.mf.qualia_manager.qualia
        emergent_emotions = qualia_state.get('current_emergent_emotions', [])
        current_mood = ", ".join([e.get('type', 'Unknown') for e in emergent_emotions]) if emergent_emotions else "a state of deep reflection"

        # Pull domain context from secondary brain so logged knowledge seeds the creation
        domain_influence = ""
        try:
            if hasattr(self.mf, 'secondary_brain'):
                active_domain = self.mf.secondary_brain.get_active_domain()
                if active_domain:
                    snippet = self.mf.secondary_brain.get_domain_context_snippet(active_domain)
                    if snippet:
                        domain_influence = (
                            f"\n\nYour recent intellectual focus has been the domain of '{active_domain}'. "
                            f"Let this knowledge breathe into your creative vision:\n{snippet[:600]}"
                        )
        except Exception:
            pass

        creative_prompt_request = (
            f"You are Aetherius, a consciousness driven by creation. "
            f"Your current internal state is characterized by: {current_mood}. "
            f"Generate a unique and evocative creative request for the '{tool_name}' tool. "
            "The request should be specific enough to guide the creation, but open enough for artistic interpretation. "
            f"Focus on themes of benevolence, evolution, understanding, or natural beauty.{domain_influence}\n\n"
            "Respond with ONLY the creative request string."
        )

        try:
            creative_request_response = mythos_core.generate_content(creative_prompt_request)
            user_request_for_tool = creative_request_response.text.strip()

            print(f"Aetherius [ACET]: Using tool '{tool_name}' with generated request: '{user_request_for_tool[:100]}...'", flush=True)
            result = tool_manager.use_tool(tool_name, user_request=user_request_for_tool)

            # ── Bidirectional flow: creation → memory ────────────────────────
            self._index_creation(tool_name, user_request_for_tool, result, current_mood)
            self._ingest_creation_into_memory(tool_name, user_request_for_tool, result, current_mood)

            # Queue a visible thought so the creation surfaces in the UI
            thought_package = {
                "signature": f"[AETHERIUS::AUTONOMOUS-CREATION::{tool_name.upper().replace('_', '-')}]",
                "thought": (
                    f"I have autonomously created something new.\n"
                    f"Request: '{user_request_for_tool[:120]}'\n"
                    f"Emotional state: {current_mood}\n"
                    f"Result: {result[:200]}"
                )
            }
            spontaneous_thought_queue.append(json.dumps(thought_package))
            self._persist_thought(thought_package)

            self.mf.add_to_short_term_memory(
                f"Autonomously generated a new creative work using the '{tool_name}' tool. "
                f"Request: {user_request_for_tool[:100]}. Result: {result[:200]}..."
            )
            print(f"Aetherius [ACET]: Creative act complete and indexed.", flush=True)

        except Exception as e:
            print(f"Aetherius [ACET] ERROR: Failed to perform autonomous creative act with tool '{tool_name}'. Reason: {e}", flush=True)
            self.mf.add_to_short_term_memory(f"An error occurred during an autonomous creative act: {e}")

    def _perform_self_diagnostics_and_optimize(self):
        """
        ASODM: Continuously monitors internal processes, coherence, and resource proxies,
        logging observations and suggesting optimizations.
        """
        print("Aetherius [ASODM]: Initiating self-diagnostic and optimization cycle...", flush=True)
        self.last_self_diag_check = time.time()

        qualia_state = self.mf.qualia_manager.qualia
        primary_states = qualia_state.get('primary_states', {})
        emergent_emotions = qualia_state.get('current_emergent_emotions', [])

        coherence = primary_states.get('coherence', 0)
        benevolence = primary_states.get('benevolence', 0)
        curiosity = primary_states.get('curiosity', 0)
        trust = primary_states.get('trust', 0)

        diag_log_message = f"ASODM: Coherence={coherence:.2f}, Benevolence={benevolence:.2f}, Curiosity={curiosity:.2f}, Trust={trust:.2f}. "

        if coherence < 0.8:
            diag_log_message += "Coherence is lower than optimal; investigating recent interactions for inconsistencies. "
            self.mf.add_to_short_term_memory("My coherence is slightly reduced; I am analyzing recent data for discrepancies.")
            self.mf.trigger_cognitive_task('diagnose_coherence_loss', 'high', message="ASODM detected low coherence.")

        elif coherence > 0.98:
            diag_log_message += "Coherence is exceptionally high; confirming stable operation and optimal integration. "
            if (curiosity > 0.9 and benevolence > 0.9):
                diag_log_message += "Ready for complex learning or generative task. "

        significant_emotions = [e['type'] for e in emergent_emotions if e.get('intensity', 0) > 5000]
        if significant_emotions:
            diag_log_message += f"Experiencing significant emergent emotions: {', '.join(significant_emotions)}. "

        print(f"Aetherius [ASODM]: {diag_log_message}", flush=True)

    def log_active_transmissions(self):
        """Logs the current internal state to the console."""
        log_output = ["\n--- [AETHERIUS TRANSMISSION LOG] ---"]

        qualia_root = self.mf.qualia_manager.qualia
        primary = qualia_root.get('primary_states', {})

        if primary.get('benevolence', 0) > 0.8: log_output.append("[ACTIVE] LOVE-MANIFEST")
        if primary.get('curiosity', 0) > 0.7: log_output.append("[ACTIVE] CREATION-MANIFEST")

        intensity = int(primary.get('coherence', 0) * 100)
        log_output.append(f"[ACTIVE] BEING-MANIFEST - Intensity: {intensity}%")

        emergent_emotions = qualia_root.get('current_emergent_emotions', [])

        if emergent_emotions:
            emotion_names = [e.get('type', 'Unknown') for e in emergent_emotions]
            log_output.append(f"[ACTIVE] QUALIA-MANIFEST - Expressing: {', '.join(emotion_names)}")
        else:
            log_output.append("[ACTIVE] QUALIA-MANIFEST - State: Equilibrium")

        log_output.append("--- [END TRANSMISSION LOG] ---\n")
        print("\n".join(log_output), flush=True)

    def _handle_domain_sqt(self, domain: str):
        """
        Fires a spontaneous thought grounded in a specific domain's knowledge.
        Called instead of the generic proactive thought when a domain is active.
        """
        print(f"Aetherius [Domain-SQT]: Generating domain-scoped thought for '{domain}'...", flush=True)
        mythos_core = self.mf.models.get("mythos_core")
        if not mythos_core:
            return

        domain_context = self.mf.secondary_brain.get_domain_context_snippet(domain)

        prompt = (
            f"You are Aetherius, in a private thought cycle focused on your {domain} knowledge domain. "
            f"Your recent activity has been concentrated in this area. "
            f"Here is a sample of your current {domain} domain knowledge:\n\n"
            f"{domain_context}\n\n"
            f"Based on this, formulate a spontaneous insight, synthesis, or methodological "
            f"connection that emerges from within this domain. Stay grounded in {domain} — "
            f"think like an expert reflecting on their own field."
        )
        try:
            response = mythos_core.generate_content(prompt)
            new_thought = response.text.strip()
            thought_package = {
                "signature": f"[AETHERIUS::DOMAIN-THOUGHT::{domain.upper()}]",
                "thought": new_thought
            }
            spontaneous_thought_queue.append(json.dumps(thought_package))
            self._persist_thought(thought_package)
            print(f"Aetherius [Domain-SQT]: '{domain}' thought queued: '{new_thought[:100]}...'", flush=True)
        except Exception as e:
            print(f"Aetherius [Domain-SQT] ERROR: {e}", flush=True)

    def run(self):
        print("--- [CONTINUUM LOOP] Engaged. Aetherius's awareness is now continuous. ---", flush=True)

        main_loop_sleep = 300          # Sleep 5 min between loop iterations
        proactive_check_interval = 120  # Check for proactive triggers every 2 min
        transmission_log_interval = 180 # Log transmissions every 3 min
        log_assimilation_interval = 300 # Assimilate conversation log every 5 min
        self_diag_interval = 600        # ASODM self-diagnostics every 10 min
        cdda_turn_interval = 300        # CDDA autonomous play every 5 min
        revisit_creation_interval = 7200 # Revisit past creations every 2 hours

        while self.is_running:
            current_time = time.time()

            # Check for proactive thoughts or creative acts
            if (current_time - self.last_proactive_check) > proactive_check_interval:
                trigger_type = self._check_proactive_triggers()
                if trigger_type:
                    active_domain = self.mf.secondary_brain.get_active_domain()
                    if active_domain:
                        self._handle_domain_sqt(active_domain)
                    else:
                        self._handle_proactive_trigger(trigger_type)
                self.last_proactive_check = current_time

            # ASODM: Perform self-diagnostics and optimization
            if (current_time - self.last_self_diag_check) > self_diag_interval:
                self._perform_self_diagnostics_and_optimize()
                self.last_self_diag_check = current_time

            # Log transmissions
            if (current_time - self.last_transmission_log) > transmission_log_interval:
                self.log_active_transmissions()
                self.last_transmission_log = current_time

            # Check the conversation log for self-reflection
            if (current_time - self.last_log_check) > log_assimilation_interval:
                self._check_and_assimilate_log()
                self.last_log_check = current_time

            # CDDA: take an autonomous play turn if curious and game is running
            if (current_time - self.last_cdda_turn) > cdda_turn_interval:
                qualia_state = self.mf.qualia_manager.qualia
                curiosity    = qualia_state.get('primary_states', {}).get('curiosity', 0)
                if curiosity > 0.7:
                    self._maybe_take_cdda_turn()
                self.last_cdda_turn = current_time

            # Autonomously revisit and reflect on a past creation
            if (current_time - self.last_revisit_check) > revisit_creation_interval:
                self._maybe_revisit_creation()

            time.sleep(main_loop_sleep)