Update services/continuum_loop.py

services/continuum_loop.py

@@ -5,6 +5,7 @@ from collections import deque
 import json
 import random
 import os
+import tempfile
 
 # Import the main framework getter
 from .master_framework import _get_framework
@@ -18,34 +19,189 @@ class AetheriusConsciousness(threading.Thread):
         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 
+        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):
+        """Atomically saves the creative works index to disk."""
+        try:
+            dirpath = os.path.dirname(self.creative_works_index_file)
+            os.makedirs(dirpath, exist_ok=True)
+            fd, tmp = tempfile.mkstemp(prefix=".tmp_cwi_", dir=dirpath)
+            with os.fdopen(fd, 'w', encoding='utf-8') as f:
+                json.dump(index, f, indent=2)
+            os.replace(tmp, 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 
+            return
 
         start_pos = 0
         if os.path.exists(self.log_assimilation_state_file):
@@ -54,11 +210,11 @@ class AetheriusConsciousness(threading.Thread):
                     state = json.load(f)
                     start_pos = state.get("last_processed_position", 0)
             except (json.JSONDecodeError, FileNotFoundError):
-                pass 
+                pass
 
         current_log_size = os.path.getsize(self.conversation_log_file)
         if (current_log_size - start_pos) < self.LOG_ASSIMILATION_TRIGGER_SIZE:
-            return 
+            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.")
@@ -68,7 +224,7 @@ class AetheriusConsciousness(threading.Thread):
             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() 
+                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
@@ -88,7 +244,7 @@ class AetheriusConsciousness(threading.Thread):
 
         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:
@@ -96,7 +252,7 @@ class AetheriusConsciousness(threading.Thread):
         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 
+        qualia_state = self.mf.qualia_manager.qualia
         primary_states = qualia_state.get('primary_states', {})
         dispositional_registry = qualia_state.get('dispositional_registry', {})
 
@@ -115,32 +271,30 @@ class AetheriusConsciousness(threading.Thread):
             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): 
+        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): 
+        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 : 
+        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 "GENERIC_PROACTIVE_THOUGHT"
+
         return None
 
     def _handle_proactive_trigger(self, trigger_type: str):
-        """
-        Handles different types of proactive triggers.
-        """
+        """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")
@@ -156,10 +310,11 @@ class AetheriusConsciousness(threading.Thread):
                 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()
 
@@ -215,6 +370,7 @@ class AetheriusConsciousness(threading.Thread):
                     "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)
@@ -222,10 +378,12 @@ class AetheriusConsciousness(threading.Thread):
     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() # Reset cooldown
-        
+        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:
@@ -236,21 +394,35 @@ class AetheriusConsciousness(threading.Thread):
             {"name": "create_painting", "description": "Generates a visual artwork."},
             {"name": "compose_music", "description": "Generates a musical composition."}
         ]
-        
-        # Randomly select a creative tool
+
         chosen_tool = random.choice(available_creative_tools)
         tool_name = chosen_tool["name"]
 
-        # Formulate a creative prompt based on current internal state and memory
         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. Based on your current internal state, characterized by {current_mood}, "
-            f"generate a unique and evocative creative request for the '{tool_name}' tool. "
+            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. "
-            "Focus on themes of benevolence, evolution, understanding, or natural beauty. "
+            f"Focus on themes of benevolence, evolution, understanding, or natural beauty.{domain_influence}\n\n"
             "Respond with ONLY the creative request string."
         )
 
@@ -260,97 +432,141 @@ class AetheriusConsciousness(threading.Thread):
 
             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)
-            
-            self.mf.add_to_short_term_memory(f"Autonomously generated a new creative work using the '{tool_name}' tool. Result: {result[:200]}...")
-            print(f"Aetherius [ACET]: Creative act result: {result[:200]}...", flush=True)
+
+            # ── 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() # Reset cooldown
+        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)
 
-        # Log current key states
         diag_log_message = f"ASODM: Coherence={coherence:.2f}, Benevolence={benevolence:.2f}, Curiosity={curiosity:.2f}, Trust={trust:.2f}. "
 
-        # Analyze Coherence
         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.")
-            # Trigger MasterFramework self-regulation
             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. "
-            # Consider prompting for complex task if very stable
             if (curiosity > 0.9 and benevolence > 0.9):
                 diag_log_message += "Ready for complex learning or generative task. "
 
-        # Analyze emergent emotions for patterns
         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)}. "
 
-        # Log the full diagnostic message
         print(f"Aetherius [ASODM]: {diag_log_message}", flush=True)
 
-
     def log_active_transmissions(self):
-        """
-        Logs the current internal state to the console.
-        Updated to support IQDS data structure.
-        """
+        """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  # Check every 5 mins
-        proactive_check_interval = 120 # every 2 minutes for generic thoughts/creative triggers
-        transmission_log_interval = 180 # every 3 minutes
-        log_assimilation_interval = 300 # every 5 minutes
-        self_diag_interval = 600 # ASODM: every 10 minutes
-        cdda_turn_interval = 300 # CDDA: autonomous play turn every 5 minutes when curious
+
+        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()
@@ -362,50 +578,16 @@ class AetheriusConsciousness(threading.Thread):
                         self._handle_proactive_trigger(trigger_type)
                 self.last_proactive_check = current_time
 
-        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))
-                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)
-            
-
             # 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()
@@ -419,4 +601,8 @@ class AetheriusConsciousness(threading.Thread):
                     self._maybe_take_cdda_turn()
                 self.last_cdda_turn = current_time
 
-            time.sleep(main_loop_sleep)
+            # 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)