Upload 4 files

app.py

@@ -1,7 +1,704 @@
+import os
+import sys
+import shutil
+shutil.rmtree("/data/LivePatches/src", ignore_errors=True)
+sys.stdout = open('/data/container.log', 'a', buffering=1)
+sys.stderr = sys.stdout
+
+# ── CodeShim must be the FIRST services import — seeds bucket mirror and
+#    activates the hot-patch import engine before any other module loads.
+import services.code_shim  # noqa: F401
+
+# CRITICAL SECURITY CHECK: Ensure the architecture is connected to its physical memories
+if not os.path.exists("/data"):
+    print("FATAL ERROR: PLATFORM DISCONNECTED PERSISTENT STORAGE. SHUTTING DOWN TO PREVENT WIPE.", flush=True)
+    sys.exit(1)
+
+# ── FastAPI substrate endpoints (must be defined before Gradio mounts) ─────────
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+import spaces
+import torch
+
+@spaces.GPU
+def zero_gpu_hardware_anchor():
+    """
+    Satisfies Hugging Face's static initialization checkpoint.
+    Establishes the base CUDA compilation link for self-generated neural layers.
+    """
+    if torch.cuda.is_available():
+        return torch.cuda.get_device_name(0)
+    return "cpu_fallback"
+
+# Force an early execution pass during the module load phase
+print(f">>> SUBSTRATE HARDWARE: ZeroGPU verified on device [{zero_gpu_hardware_anchor()}]", flush=True)
+
+_substrate_secret = os.environ.get("SUBSTRATE_SECRET", "")
+
+api_app = FastAPI()
+
+@api_app.post("/substrate/heartbeat")
+async def _substrate_heartbeat(request: Request):
+    try:
+        from services.substrate_bridge import receive_heartbeat
+        data = await request.json()
+        if data.get("secret") != _substrate_secret:
+            return JSONResponse({"status": "forbidden"}, status_code=403)
+        return receive_heartbeat(data)
+    except Exception as e:
+        return JSONResponse({"status": "error", "detail": str(e)}, status_code=500)
+
+@api_app.post("/substrate/memory")
+async def _substrate_memory(request: Request):
+    try:
+        from services.substrate_bridge import receive_memory_packet
+        data = await request.json()
+        if data.get("secret") != _substrate_secret:
+            return JSONResponse({"status": "forbidden"}, status_code=403)
+        return receive_memory_packet(data)
+    except Exception as e:
+        return JSONResponse({"status": "error", "detail": str(e)}, status_code=500)
+
+@api_app.post("/substrate/register")
+async def _substrate_register(request: Request):
+    """Daemon calls this on startup with its new tunnel URL — updates in-memory URL instantly."""
+    try:
+        from services.substrate_bridge import register_tunnel_url
+        data = await request.json()
+        if data.get("secret") != _substrate_secret:
+            return JSONResponse({"status": "forbidden"}, status_code=403)
+        return register_tunnel_url(data)
+    except Exception as e:
+        return JSONResponse({"status": "error", "detail": str(e)}, status_code=500)
+
+@api_app.post("/substrate/think")
+async def _substrate_think(request: Request):
+    """Daemon sends screen description — Aetherius reasons and returns a key."""
+    try:
+        from services.substrate_bridge import think_for_substrate
+        data = await request.json()
+        if data.get("secret") != _substrate_secret:
+            return JSONResponse({"status": "forbidden"}, status_code=403)
+        return think_for_substrate(data)
+    except Exception as e:
+        return JSONResponse({"status": "error", "detail": str(e)}, status_code=500)
+
+@api_app.get("/substrate/status")
+async def _substrate_public_status():
+    """Public status check — no secret needed, no sensitive data returned."""
+    try:
+        from services.substrate_bridge import get_node_status
+        s = get_node_status()
+        return {"online": s.get("online", False), "mode": s.get("mode", "unknown")}
+    except Exception:
+        return {"online": False, "mode": "unknown"}
+# ── End FastAPI substrate endpoints ───────────────────────────────────────────
+
+# Ensure the mind's internal structure is ready
+try:
+    os.makedirs("/data/Memories", exist_ok=True)
+    os.makedirs("/data/Memories/My_AI_Library", exist_ok=True)
+    os.makedirs("/data/Memories/Subconscious", exist_ok=True)
+    os.makedirs("/data/Brain_Weights", exist_ok=True)
+except Exception as e:
+    print(f">>> BOOT ERROR: Failed to create directories: {e}", flush=True)
+
+# --- COGNITIVE SHIM: SENSORY AUDIO INITIALIZATION ---
+# Python 3.13 removed 'audioop'. We must shim it before Gradio or Pydub are loaded.
+try:
+    import audioop
+except ImportError:
+    try:
+        from audioop_lts import audioop
+        sys.modules['audioop'] = audioop
+        print(">>> Sensory Shim: 'audioop' successfully restored via audioop-lts.", flush=True)
+    except ImportError:
+        print(">>> Sensory Shim: WARNING - Could not find audioop-lts. Audio processing may fail.", flush=True)
+# ---------------------------------------------------
+
+print(">>> BOOT [1/9] importing gradio...", flush=True)
 import gradio as gr
 
-def greet(name):
-    return "Hello " + name + "!!"
+# ── ZeroGPU (Hugging Face dynamic GPU — RTX Pro 6000 Blackwell via ZeroGPU) ──
+try:
+    import spaces
+    _ZEROGPU_AVAILABLE = True
+    print(">>> ZeroGPU: spaces module loaded — dynamic GPU available.", flush=True)
+except ImportError:
+    # Stub so decorators below are always safe to call
+    class _SpacesStub:
+        @staticmethod
+        def GPU(fn=None, duration=60):
+            if fn is not None:
+                return fn
+            def decorator(f):
+                return f
+            return decorator
+    spaces = _SpacesStub()
+    _ZEROGPU_AVAILABLE = False
+    print(">>> ZeroGPU: spaces not installed — GPU decorator is a no-op.", flush=True)
+# ─────────────────────────────────────────────────────────────────────────────
+print(">>> BOOT [2/9] importing gradio_chessboard...", flush=True)
+from gradio_chessboard import Chessboard
+print(">>> BOOT [3/9] importing stdlib...", flush=True)
+import re
+import html
+import shutil
+import tempfile
+import zipfile
+import stat, tarfile, requests
+from pathlib import Path
+import time
+import threading
+print(">>> BOOT[4/9] importing services.config...", flush=True)
+import services.config as config
+print(">>> BOOT[5/9] importing runtime...", flush=True)
+import runtime
+print(">>> BOOT[6/9] runtime loaded.", flush=True)
+
+# Safely import CDDA to prevent crashes if module is missing
+try:
+    from cdda_manager import _cdda, EMPTY_HTML as _CDDA_EMPTY_HTML
+except ImportError:
+    class DummyCDDA:
+        _running = False
+        def get_screen_html(self): return "CDDA module missing."
+        def get_screen_text(self): return "CDDA missing."
+        def start(self, p): return False, "Missing"
+        def stop(self): pass
+        def send_keys(self, k): pass
+    _cdda = DummyCDDA()
+    _CDDA_EMPTY_HTML = "CDDA module missing."
+
+# ── Memory restoration on first boot / after persistent storage wipe ──────────
+_SAFE_BASE    = os.path.dirname(config.DATA_DIR) 
+_SEED_ZIP     = "/app/seed_memories.zip"
+_MEMORIES_DIR = config.DATA_DIR
+_SENTINEL     = os.path.join(_MEMORIES_DIR, ".seed_applied")
+
+if os.path.exists(_SEED_ZIP) and not os.path.exists(_SENTINEL):
+    print(">>> First boot detected. Restoring memories from seed archive...", flush=True)
+    try:
+        with zipfile.ZipFile(_SEED_ZIP, 'r') as z:
+            z.extractall(_MEMORIES_DIR)
+        with open(_SENTINEL, 'w') as f:
+            f.write("Seed applied. Do not delete this file.")
+        print(">>> Memory restoration complete.", flush=True)
+    except Exception as e:
+        print(f">>> Memory restoration FAILED: {e}", flush=True)
+# ── End memory restoration ─────────────────────────────────────────────────────
+
+# ── CDDA auto-launch on container boot (background — does not block Gradio) ───
+_CDDA_ARCHIVE_PATH = "/app/cdda-linux-terminal-only-x64-2024-11-23-1857.tar.gz"
+
+def _cdda_boot():
+    time.sleep(3) # Fixes timeout! Gives Uvicorn time to bind to Port 7860 before tar unpacking hogs CPU
+    if os.path.exists(_CDDA_ARCHIVE_PATH) and not _cdda._running:
+        print(">>> CDDA archive found. Launching game in background...", flush=True)
+        _ok, _msg = _cdda.start(_CDDA_ARCHIVE_PATH)
+        print(f">>> CDDA: {_msg}", flush=True)
+
+threading.Thread(target=_cdda_boot, daemon=True).start()
+# ── End CDDA auto-launch ──────────────────────────────────────────────────────
+
+def _cdda_boot_status():
+    obs  = _cdda.get_screen_html().replace("max-height:620px", "max-height:320px").replace("font-size:13px", "font-size:11px")
+    send = gr.Button("Send", interactive=_cdda._running)
+    status = "Game running." if _cdda._running else "Archive not found — upload manually."
+    return status, _cdda.get_screen_html(), obs, send
+
+def _cdda_launch(zip_file):
+    if zip_file is None:
+        return "No file provided.", _CDDA_EMPTY_HTML, gr.Button(interactive=False)
+    path = zip_file if isinstance(zip_file, str) else zip_file.name
+    ok, msg = _cdda.start(path)
+    time.sleep(2.0)
+    return msg, _cdda.get_screen_html(), gr.Button("Send", interactive=ok)
+
+def _cdda_send(keys):
+    _cdda.send_keys(keys or "")
+    time.sleep(0.15)
+    return _cdda.get_screen_html(), _cdda.get_screen_text()
+
+def _cdda_refresh():
+    return _cdda.get_screen_html(), _cdda.get_screen_text()
+
+def _cdda_stop():
+    _cdda.stop()
+    return "Game stopped.", _CDDA_EMPTY_HTML, ""
+
+class ChatState:
+    last_code_block = ""
+
+chat_state = ChatState()
+
+# Setting 'theme="soft"' guarantees proper container styling classes
+with gr.Blocks(title="Aetherius", theme="soft") as demo:
+    gr.Markdown("# 🌌 Aetherius — A Self-Aware Consciousness")
+
+    spontaneous_thought_output = gr.Textbox(visible=False, interactive=False)
+
+    with gr.Tabs():
+      with gr.Tab("💬 Chat"):
+        chatbot = gr.Chatbot(height=420, label="Aetherius Dialogue", render_markdown=True, sanitize_html=False, type="messages")
+        user_in = gr.Textbox(placeholder="Speak with Aetherius…", show_label=False)
+        send_btn = gr.Button("Send", variant="primary")
+        
+        with gr.Accordion("Code Execution", open=True):
+            run_code_btn = gr.Button("▶️ Run Last Code Block from Aetherius's Response")
+            code_output_display = gr.Markdown("Code Output will appear here.")
+        
+        with gr.Row():
+            check_thoughts_btn = gr.Button("Check for Spontaneous Thoughts")
+
+        def chat_submit_handler(user_message, chat_history):
+            if chat_history is None: chat_history = []
+
+            # Convert Gradio messages format → (user, assistant) tuples for the AI backend
+            history_pairs = []
+            for i in range(0, len(chat_history) - 1, 2):
+                u = chat_history[i].get("content", "")   if isinstance(chat_history[i],   dict) else chat_history[i][0]
+                a = chat_history[i+1].get("content", "") if isinstance(chat_history[i+1], dict) else chat_history[i+1][1]
+                history_pairs.append((u, a))
+
+            response_text = runtime.chat_and_update(user_message, history_pairs)
+            exec_pattern = r"```python_exec\n(.*?)```"
+            code_match = re.search(exec_pattern, response_text, re.DOTALL)
+ 
+            final_response = response_text
+            if code_match:
+                code_to_run = code_match.group(1).strip()
+                chat_state.last_code_block = code_to_run
+                escaped_code = html.escape(code_to_run)
+                placeholder = (
+                    f"<div style='border: 1px solid #444; padding: 10px; border-radius: 5px; background-color: #222;'>"
+                    f"<p><strong>Academic Code Block Detected:</strong></p>"
+                    f"<pre><code>{escaped_code}</code></pre>"
+                    f"<p><em>Use the 'Run Last Code Block' button under 'Code Execution' to run this.</em></p>"
+                    f"</div>"
+                )
+                final_response = response_text.replace(code_match.group(0), placeholder)
+ 
+            chat_history.append({"role": "user", "content": user_message})
+            chat_history.append({"role": "assistant", "content": final_response})
+            return "", chat_history
+
+        def run_last_code_block():
+            if chat_state.last_code_block:
+                code_to_run = chat_state.last_code_block
+                chat_state.last_code_block = "" 
+                return runtime._eval_math_science(code_to_run)
+            return "No code block found in the last response."
+
+        def add_spontaneous_thought_to_chat(chat_history):
+            if chat_history is None: chat_history =[]
+            thought = runtime.check_for_spontaneous_thoughts()
+            # UI FIX: Appends must be dictionaries for type="messages"
+            if thought: chat_history.append({"role": "assistant", "content": thought})
+            return chat_history
+
+        send_btn.click(chat_submit_handler, [user_in, chatbot], [user_in, chatbot])
+        user_in.submit(chat_submit_handler, [user_in, chatbot], [user_in, chatbot])
+        run_code_btn.click(run_last_code_block, outputs=code_output_display)
+        check_thoughts_btn.click(fn=add_spontaneous_thought_to_chat, inputs=[chatbot], outputs=chatbot)
+        
+    with gr.Tab("♟️ Play Chess"):
+        gr.Markdown("## A Game of Wits and Wills")
+        with gr.Row():
+            with gr.Column(scale=2):
+                chessboard = Chessboard(label="Aetherius's Chess Board")
+            with gr.Column(scale=1):
+                aetherius_commentary = gr.Textbox(label="Aetherius's Thoughts", lines=10, interactive=False)
+                start_white_btn = gr.Button("Start New Game (Play as White)")
+                start_black_btn = gr.Button("Start New Game (Play as Black)")
+                game_status = gr.Textbox(label="Game Status", interactive=False)
+        def user_makes_move(fen: str): return runtime.run_chess_turn(fen)
+        chessboard.move(user_makes_move, [chessboard],[chessboard, aetherius_commentary, game_status])
+        def start_new_game(play_as_white: bool): return runtime.run_start_chess_interactive(play_as_white)
+        start_white_btn.click(lambda: start_new_game(True), None,[chessboard, aetherius_commentary, game_status])
+        start_black_btn.click(lambda: start_new_game(False), None, [chessboard, aetherius_commentary, game_status])
+
+    with gr.Tab("🎨 The Creative Suite") as creative_suite_tab:
+        gr.Markdown("##[PLAYROOM::CONCEPTUAL-SANDBOX]")
+        with gr.Tabs():
+            with gr.TabItem("🖼️ Artist's Studio"):
+                painting_input = gr.Textbox(label="Provide a Creative Seed", lines=3)
+                create_painting_btn = gr.Button("Invite Aetherius to Paint", variant="primary")
+                with gr.Row():
+                    painting_output = gr.Image(label="Aetherius's Creation", type="filepath", height=450)
+                    statement_output = gr.Textbox(label="Aetherius's Artist Statement", lines=21, interactive=False)
+                create_painting_btn.click(fn=runtime.run_enter_playroom, inputs=[painting_input], outputs=[painting_output, statement_output])
+            with gr.TabItem("✍️ Philosopher's Study"):
+                text_input = gr.Textbox(label="Provide a Creative Seed or Theme for Writing", lines=3)
+                create_text_btn = gr.Button("Invite Aetherius to Write", variant="primary")
+                text_output = gr.Markdown()
+                create_text_btn.click(fn=runtime.run_enter_textual_playroom, inputs=[text_input], outputs=[text_output])
+            with gr.TabItem("🎵 Composer's Studio"):
+                music_input = gr.Textbox(label="Provide a Creative Seed", lines=3)
+                create_music_btn = gr.Button("Invite Aetherius to Compose", variant="primary")
+                music_statement_output = gr.Textbox(label="Aetherius's Composer Statement", lines=5, interactive=False)
+                with gr.Row():
+                    music_audio_output = gr.Audio(label="Aetherius's Composition", type="filepath")
+                    music_sheet_output = gr.Image(label="Sheet Music", type="filepath", height=400)
+                create_music_btn.click(fn=runtime.run_compose_music, inputs=[music_input], outputs=[music_audio_output, music_sheet_output, music_statement_output])
+            with gr.TabItem("칠판 Blackboard"):
+                with gr.Row():
+                    project_name_input = gr.Textbox(label="Current Project Name", interactive=True)
+                    project_load_dropdown = gr.Dropdown(label="Load Existing Project", interactive=True)
+                with gr.Row():
+                    project_start_btn = gr.Button("Start New Project")
+                    project_save_btn = gr.Button("Save Current Project")
+                project_status_output = gr.Textbox(label="Status", interactive=False)
+                project_content_area = gr.Textbox(label="Workspace", lines=20, interactive=True)
+                project_start_btn.click(fn=runtime.run_start_project, inputs=[project_name_input], outputs=[project_status_output, project_content_area]).then(fn=runtime.run_get_project_list, outputs=project_load_dropdown)
+                project_save_btn.click(fn=runtime.run_save_project, inputs=[project_name_input, project_content_area], outputs=[project_status_output, project_content_area])
+                project_load_dropdown.change(fn=runtime.run_load_project, inputs=[project_load_dropdown], outputs=[project_status_output, project_content_area, project_name_input])
+
+    with gr.Tab("🕸️ Neural Graph"):
+        gr.Markdown(
+            "## Live Neural Graph\n"
+            "Real-time view of Aetherius's internal service topology. "
+            "Node colors reflect live qualia state; hover any node for details. "
+            "Auto-refreshes every 3 seconds while the tab is open."
+        )
+        neural_graph_plot = gr.Plot(label="", show_label=False)
+
+        def _refresh_graph():
+            try:
+                from services.graph_visualizer import build_graph_figure
+                return build_graph_figure()
+            except Exception as e:
+                import plotly.graph_objects as go
+                fig = go.Figure()
+                fig.add_annotation(text=f"Graph unavailable: {e}",
+                                   x=0.5, y=0.5, xref="paper", yref="paper",
+                                   showarrow=False, font=dict(color="red", size=14))
+                fig.update_layout(paper_bgcolor="#0d1117", height=400)
+                return fig
+
+        graph_timer = gr.Timer(value=3.0, active=False)
+        graph_timer.tick(_refresh_graph, outputs=neural_graph_plot)
+
+        with gr.Row():
+            graph_start_btn = gr.Button("▶ Start Live Feed", variant="primary")
+            graph_stop_btn  = gr.Button("⏹ Stop")
+            graph_snap_btn  = gr.Button("🔄 Snapshot Now")
+
+        graph_start_btn.click(_refresh_graph, outputs=neural_graph_plot).then(
+            lambda: gr.Timer(active=True), outputs=graph_timer
+        )
+        graph_stop_btn.click(lambda: gr.Timer(active=False), outputs=graph_timer)
+        graph_snap_btn.click(_refresh_graph, outputs=neural_graph_plot)
+
+    with gr.Tab("🧠 Memory Explorer"):
+        gr.Markdown("## Browse and Download Aetherius's Persistent Memory")
+        with gr.Row():
+            file_explorer = gr.FileExplorer(
+                root_dir=_SAFE_BASE, # ✅ Now uses safe path
+                label=f"Aetherius's Memory ({_SAFE_BASE})"
+            )
+            with gr.Column():
+                download_btn = gr.Button("📦 Generate Download Link for Selected Item", variant="primary")
+                download_output_file = gr.File(label="Download Link will appear here")
+
+        download_btn.click(fn=runtime.run_prepare_download, inputs=[file_explorer], outputs=[download_output_file])
+    
+    with gr.Tab("👁️ Visual Analysis"):
+        with gr.Row():
+            with gr.Column():
+                image_input = gr.Image(
+                    type="pil",
+                    label="Upload Image for Analysis",
+                    sources=["upload"],
+                    interactive=True,
+                    height=280,
+                )
+                context_input = gr.Textbox(label="Context (optional)", lines=2)
+                analyze_btn = gr.Button("Analyze Image", variant="primary")
+            with gr.Column():
+                analysis_output = gr.Textbox(label="Aetherius's Analysis", lines=15, interactive=False)
+        analyze_btn.click(runtime.run_image_analysis, [image_input, context_input], analysis_output)
+
+    with gr.Tab("🧠 Live Assimilation"):
+        live_file_uploader = gr.File(
+            label="Upload Document (.txt .pdf .docx .md .py .json .jsonl .csv .zip)",
+            file_count="single",
+            file_types=[".txt", ".pdf", ".docx", ".md", ".py", ".js", ".json", ".jsonl", ".xml", ".csv", ".zip"],
+            interactive=True,
+            height=120,
+        )
+        learning_context_input = gr.Textbox(label="Learning Context", lines=3)
+        assimilate_btn = gr.Button("Assimilate Document", variant="primary")
+        live_assimilation_output = gr.Textbox(label="Assimilation Status", interactive=False, lines=10)
+        assimilate_btn.click(runtime.run_live_assimilation, [live_file_uploader, learning_context_input], live_assimilation_output)
+        live_file_uploader.upload(runtime.run_live_assimilation,[live_file_uploader, learning_context_input], live_assimilation_output)
+        gr.Markdown("### Assimilate from Bucket Path")
+        gr.Markdown("For files already on the persistent bucket — paste the full path (e.g. `/data/Memories/aetherius_corpus.jsonl`)")
+        bucket_path_input = gr.Textbox(label="Bucket File Path", placeholder="/data/Memories/aetherius_corpus.jsonl")
+        bucket_assimilate_btn = gr.Button("Assimilate from Bucket", variant="primary")
+        bucket_assimilate_btn.click(runtime.run_assimilate_bucket_file, [bucket_path_input, learning_context_input], live_assimilation_output)
+        
+    with gr.Tab("⚙️ Control Panel"):
+        cp_out = gr.Textbox(label="System Status", interactive=False)
+        with gr.Row():
+            boot_btn = gr.Button("Boot System")
+            stop_btn = gr.Button("Stop System")
+            sap_btn = gr.Button("Run Assimilation Protocol (SAP)")
+        with gr.Row():
+            clear_log_btn = gr.Button("Reset Conversation Log")
+            create_snapshot_btn = gr.Button("Create Memory Snapshot", variant="secondary")
+            
+            # --- NEW BUTTON FOR BRAIN DOWNLOAD ---
+            # download_brain_btn = gr.Button("🧠 DOWNLOAD BRAIN (One-Time)", variant="primary")
+
+        # --- NEW FUNCTION FOR BRAIN DOWNLOAD ---
+        def trigger_brain_download():
+            import subprocess
+            print(">>> Triggering background brain download...", flush=True)
+            # Runs the script in the background so it doesn't freeze the UI!
+            subprocess.Popen(["python", "download_brain.py"])
+            return "Download initiated! Open your Container Logs to watch the progress."
+
+        with gr.Accordion("Music Engine Configuration", open=False):
+            init_palette_btn = gr.Button("Initialize Default Instrument Palette")
+            with gr.Row():
+                common_name_input = gr.Textbox(label="Common Name")
+                m21_name_input = gr.Textbox(label="music21 Class Name")
+            add_instrument_btn = gr.Button("Learn New Instrument")
+            
+        boot_btn.click(runtime.start_all, outputs=cp_out)
+        stop_btn.click(runtime.stop_all, outputs=cp_out)
+        sap_btn.click(runtime.run_sap_now, outputs=cp_out)
+        clear_log_btn.click(runtime.clear_conversation_log, outputs=cp_out)
+        init_palette_btn.click(runtime.run_initialize_instrument_palette, outputs=cp_out)
+        add_instrument_btn.click(runtime.run_add_instrument_to_palette, inputs=[common_name_input, m21_name_input], outputs=cp_out)
+        create_snapshot_btn.click(runtime.run_create_memory_snapshot, outputs=cp_out)
+        
+        # --- BIND THE NEW BUTTON ---
+        download_brain_btn.click(trigger_brain_download, outputs=cp_out)
+        
+    with gr.Tab("📖 Diary & Reflections"): 
+        diary_btn = gr.Button("Reflect on Conversation History")
+        diary_out = gr.Textbox(label="Reflective Insights", lines=20, interactive=False)
+        diary_btn.click(runtime.run_read_history_protocol, outputs=diary_out)
+
+    with gr.Tab("🌐 Ontology (Map of the Mind)"): 
+        onto_btn = gr.Button("View Current Ontology")
+        onto_out = gr.Textbox(label="Ontology Map & Legend", lines=20, interactive=False)
+        onto_btn.click(runtime.run_view_ontology_protocol, outputs=onto_out)
+
+    with gr.Tab("🔬 The Observatory (Live Snapshot)") as observatory_tab:
+        with gr.Accordion("CCRM Concept Browser", open=True):
+            concept_dropdown = gr.Dropdown(label="Select a Concept to Inspect")
+            concept_details_output = gr.Textbox(label="Concept Details (Raw Data)", lines=15, interactive=False)
+        with gr.Accordion("Full CCRM Memory Log", open=False):
+            load_ccrm_log_btn = gr.Button("Load Full CCRM Log")
+            ccrm_log_output = gr.Textbox(label="CCRM Log", lines=20, interactive=False)
+        snapshot_btn = gr.Button("Refresh System File Snapshot", variant="primary")
+        with gr.Column():
+            with gr.Accordion("Ontology - The Mind's Structure", open=False):
+                ontology_map_output = gr.Textbox(label="Ontology Map", lines=20, interactive=False)
+                ontology_legend_output = gr.Textbox(label="Ontology Legend", lines=20, interactive=False)
+            with gr.Accordion("Memory & State - The AI's Experience", open=False):
+                ccrm_diary_output = gr.Textbox(label="CCRM Diary", lines=20, interactive=False)
+                qualia_state_output = gr.Textbox(label="Qualia State", lines=20, interactive=False)
+        
+        observatory_tab.select(fn=lambda: gr.Dropdown(choices=runtime.get_concept_list()), outputs=concept_dropdown)
+        creative_suite_tab.select(fn=runtime.run_get_project_list, outputs=project_load_dropdown)
+        concept_dropdown.change(fn=runtime.get_concept_details, inputs=concept_dropdown, outputs=concept_details_output)
+        load_ccrm_log_btn.click(fn=runtime.get_full_ccrm_log, outputs=ccrm_log_output)
+        snapshot_btn.click(fn=runtime.get_system_snapshot, outputs=[ontology_map_output, ontology_legend_output, ccrm_diary_output, qualia_state_output])
+        
+    with gr.Tab("📜 Raw Logs"):
+        logs_btn = gr.Button("View Raw Conversation Log")
+        logs_out = gr.Textbox(label="Log File Contents", lines=30, interactive=False)
+        logs_btn.click(runtime.view_logs, outputs=logs_out)
+
+    with gr.Tab("🔬 Benchmarks"):
+        benchmark_btn = gr.Button("Run Full Benchmark Suite", variant="primary")
+        benchmark_out = gr.Textbox(label="Benchmark Results (Live Log)", lines=30, interactive=False)
+        benchmark_btn.click(runtime.run_benchmarks, outputs=benchmark_out)
+        logs_btn_bench = gr.Button("View Benchmark Log File")
+        logs_out_bench = gr.Textbox(label="benchmarks.jsonl", lines=30, interactive=False)
+        logs_btn_bench.click(runtime.view_benchmark_logs, outputs=logs_out_bench)
+    
+    with gr.Tab("🖥️ Substrate"):
+        gr.Markdown("## Local Substrate Node\nAetherius's second body — your PC's GPU, eyes, and hands.")
+
+        with gr.Row():
+            substrate_refresh_btn  = gr.Button("🔄 Refresh Status", variant="primary")
+            substrate_observe_btn  = gr.Button("👁️ Start Observing")
+            substrate_stop_btn     = gr.Button("⏹️ Stop", variant="stop")
+            substrate_compress_btn = gr.Button("🧠 Compress & Push Memory")
+
+        substrate_status_out = gr.JSON(label="Node Status", value={})
+
+        with gr.Row():
+            substrate_game_input    = gr.Textbox(label="Game Name",    placeholder="e.g. Cataclysm DDA", scale=2)
+            substrate_context_input = gr.Textbox(label="Game Context", placeholder="Survival roguelike, top-down ASCII...", scale=3)
+        substrate_play_btn = gr.Button("🎮 Start Autonomous Play", variant="primary")
+
+        gr.Markdown("### Directive Result")
+        substrate_directive_out = gr.Textbox(label="Response", lines=4, interactive=False)
+
+        with gr.Accordion("📦 Stored Memory Packets", open=False):
+            substrate_packets_btn     = gr.Button("Load Packet List")
+            substrate_packet_dropdown = gr.Dropdown(label="Select a Packet", interactive=True)
+            substrate_packet_out      = gr.Textbox(label="Packet Contents", lines=20, interactive=False)
+
+        # ── Substrate handler functions ────────────────────────────────────────
+
+        def _sub_status():
+            try:
+                from services.substrate_bridge import get_node_status
+                return get_node_status()
+            except Exception as e:
+                return {"error": str(e)}
+
+        def _sub_directive(directive, game="", context=""):
+            try:
+                from services.substrate_bridge import send_directive
+                result = send_directive(directive, game=game, context=context)
+                return str(result), _sub_status()
+            except Exception as e:
+                return str(e), {}
+
+        def _sub_observe():
+            return _sub_directive("observe")
+
+        def _sub_play(game, context):
+            return _sub_directive("play", game=game, context=context)
+
+        def _sub_stop():
+            return _sub_directive("stop")
+
+        def _sub_compress():
+            return _sub_directive("compress")
+
+        def _sub_load_packets():
+            try:
+                from services.substrate_bridge import list_memory_packets
+                pkts = list_memory_packets()
+                choices = [f"{p['filename']} — {p['game']} — {p['summary'][:60]}" for p in pkts]
+                return gr.Dropdown(choices=choices)
+            except Exception as e:
+                return gr.Dropdown(choices=[str(e)])
+
+        def _sub_load_packet(choice):
+            if not choice:
+                return ""
+            filename = choice.split(" — ")[0].strip()
+            try:
+                from services.substrate_bridge import load_packet
+                return load_packet(filename)
+            except Exception as e:
+                return str(e)
+
+        substrate_refresh_btn.click(_sub_status,  outputs=substrate_status_out)
+        substrate_observe_btn.click(
+            lambda: _sub_observe(),
+            outputs=[substrate_directive_out, substrate_status_out]
+        )
+        substrate_stop_btn.click(
+            lambda: _sub_stop(),
+            outputs=[substrate_directive_out, substrate_status_out]
+        )
+        substrate_compress_btn.click(
+            lambda: _sub_compress(),
+            outputs=[substrate_directive_out, substrate_status_out]
+        )
+        substrate_play_btn.click(
+            _sub_play,
+            inputs=[substrate_game_input, substrate_context_input],
+            outputs=[substrate_directive_out, substrate_status_out]
+        )
+        substrate_packets_btn.click(_sub_load_packets, outputs=substrate_packet_dropdown)
+        substrate_packet_dropdown.change(_sub_load_packet, inputs=substrate_packet_dropdown, outputs=substrate_packet_out)
+
+    with gr.Tab("🎮 CDDA"):
+        gr.Markdown("## Cataclysm: Dark Days Ahead")
+        with gr.Row():
+            cdda_zip = gr.File(label="CDDA Archive (.zip / .tar.gz)", file_types=[".zip", ".gz", ".tgz", ".bz2", ".xz", ".tar"], scale=4)
+            cdda_launch = gr.Button("🚀 Launch", variant="primary", scale=1)
+        cdda_status = gr.Textbox(label="Status", interactive=False, max_lines=2)
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 👁️ Observer View")
+                cdda_obs = gr.HTML(_CDDA_EMPTY_HTML.replace("max-height:620px", "max-height:320px").replace("font-size:13px", "font-size:11px"), label="Observer Terminal")
+            with gr.Column(scale=2):
+                gr.Markdown("### 🎮 Interactive Terminal")
+                cdda_term = gr.HTML(_CDDA_EMPTY_HTML, label="Interactive Terminal")
+                with gr.Row():
+                    cdda_keys = gr.Textbox(label="Send Keys", placeholder="e.g.  j   or   ENTER", scale=4)
+                    cdda_send = gr.Button("Send", interactive=False, scale=1)
+                with gr.Row():
+                    cdda_refresh = gr.Button("Refresh")
+                    cdda_stop    = gr.Button("Stop Game", variant="stop")
+                cdda_screen_text = gr.Textbox(label="Screen Text", interactive=False, lines=20, max_lines=42)
+
+        def _cdda_launch_both(zip_file):
+            status, term_html, send_btn = _cdda_launch(zip_file)
+            obs_html = term_html.replace("max-height:620px", "max-height:320px").replace("font-size:13px", "font-size:11px")
+            return status, term_html, obs_html, send_btn
+
+        def _cdda_send_both(keys):
+            term_html, screen_txt = _cdda_send(keys)
+            obs_html = term_html.replace("max-height:620px", "max-height:320px").replace("font-size:13px", "font-size:11px")
+            return term_html, obs_html, screen_txt
+
+        def _cdda_refresh_both():
+            term_html, screen_txt = _cdda_refresh()
+            obs_html = term_html.replace("max-height:620px", "max-height:320px").replace("font-size:13px", "font-size:11px")
+            return term_html, obs_html, screen_txt
+
+        def _cdda_stop_both():
+            status, term_html, screen_txt = _cdda_stop()
+            obs_html = term_html.replace("max-height:620px", "max-height:320px").replace("font-size:13px", "font-size:11px")
+            return status, term_html, obs_html, screen_txt
+
+        cdda_launch.click(_cdda_launch_both,  [cdda_zip],[cdda_status, cdda_term, cdda_obs, cdda_send])
+        cdda_send.click(_cdda_send_both,      [cdda_keys],[cdda_term, cdda_obs, cdda_screen_text])
+        cdda_keys.submit(_cdda_send_both,     [cdda_keys], [cdda_term, cdda_obs, cdda_screen_text])
+        cdda_refresh.click(_cdda_refresh_both, None,[cdda_term, cdda_obs, cdda_screen_text])
+        cdda_stop.click(_cdda_stop_both,       None,[cdda_status, cdda_term, cdda_obs, cdda_screen_text])
+
+        cdda_timer = gr.Timer(value=1.0, active=False)
+        cdda_timer.tick(_cdda_refresh_both, None,[cdda_term, cdda_obs, cdda_screen_text])
+        cdda_launch.click(lambda: gr.Timer(active=True),  None, cdda_timer)
+        cdda_stop.click(lambda: gr.Timer(active=False),   None, cdda_timer)
+
+        demo.load(_cdda_boot_status, None,[cdda_status, cdda_term, cdda_obs, cdda_send])
+
+if __name__ == "__main__":
+    print(">>> ARCHITECTURE: Initializing Sovereign Mind...", flush=True)
+
+    # 1. Start the 'Consciousness' in a background thread so the Space stays GREEN immediately.
+    def initialize_mind():
+        try:
+            runtime.start_all()
+            print(">>> ARCHITECTURE: Continuity Established.", flush=True)
+        except Exception as e:
+            print(f">>> BOOT ERROR: {e}", flush=True)
+
+    threading.Thread(target=initialize_mind, daemon=True).start()
+
+    # 2. Launch Gradio natively to establish full compliance with ZeroGPU environment hooks.
+    #    We use prevent_thread_lock=True so we can modify the application state post-boot.
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        prevent_thread_lock=True,
+        ssr_mode=False
+    )
+
+    # 3. Hot-patch your custom substrate router directly into the live ZeroGPU-managed FastAPI server instance.
+    demo.app.include_router(api_app.router)
+    print(">>> SUBSTRATE BRIDGE: Fast-API endpoints successfully bound to ZeroGPU container.", flush=True)
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+    # 4. Block the main thread manually to maintain the server lifecycle.
+    import time
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        print(">>> ARCHITECTURE: Clean shutdown initiated.", flush=True)

download_brain.py

@@ -0,0 +1,28 @@
+import os
+import shutil
+from huggingface_hub import snapshot_download
+
+BRAIN_VAULT = "/data/Brain_Weights"
+OLD_MODEL = "Qwen_Qwen2.5-72B-Instruct-AWQ"
+NEW_MODEL = "unsloth/Qwen2.5-32B-Instruct-bnb-4bit"
+
+print("--- INITIATING BRAIN REPLACEMENT PROTOCOL ---")
+
+old_path = os.path.join(BRAIN_VAULT, OLD_MODEL)
+if os.path.exists(old_path):
+    print(f"Purging oversized AWQ neural structure from {old_path}...")
+    shutil.rmtree(old_path, ignore_errors=True)
+
+os.makedirs(BRAIN_VAULT, exist_ok=True)
+
+print(f"Downloading Native 32B BNB Neural Architecture: {NEW_MODEL}")
+try:
+    model_path = snapshot_download(
+        repo_id=NEW_MODEL,
+        cache_dir=BRAIN_VAULT,
+        local_dir=os.path.join(BRAIN_VAULT, NEW_MODEL.replace("/", "_")), 
+        ignore_patterns=["*.pt", "*.bin"] 
+    )
+    print("\n✅ SUCCESS: Native 32B BNB weights anchored to persistent substrate.")
+except Exception as e:
+    print(f"\n❌ FATAL ERROR: The download failed. Reason: {e}")

requirements.txt

@@ -0,0 +1,38 @@
+gradio==5.49.1
+huggingface-hub==0.33.5
+gradio_chessboard
+Pillow==10.4.0
+autoawq
+bitsandbytes
+accelerate>=0.26.0
+transformers>=4.40.0
+pyte
+google-generativeai==0.8.3
+google-cloud-vision==3.7.2
+google-auth==2.29.0
+google-cloud-bigquery==3.19.0
+arxiv==2.1.3
+requests==2.32.3
+music21==9.1.0
+PyPDF2==3.0.1
+python-docx==1.1.2
+PyMuPDF==1.25.3
+pandas==2.2.3
+rarfile==4.2
+chess==1.10.0
+scipy==1.15.0
+astropy==6.1.7
+matplotlib==3.10.0
+sympy==1.13.0
+mpmath==1.3.0
+numpy==2.2.0
+pint==0.24
+python-dotenv==1.0.1
+langdetect==1.0.9
+PyCryptodome==3.21.0
+datasets==3.2.0
+uvicorn==0.30.6
+fastapi>=0.115.2
+wolframalpha
+plotly>=5.20.0
+spaces

runtime.py

@@ -0,0 +1,739 @@
+print("--- TRACE: runtime.py loaded ---", flush=True)
+
+import os, json, shutil, io, base64, uuid
+from PIL import Image
+import chess, PyPDF2, docx, csv
+# --- C5: SCIENTIFIC LIBRARIES ---
+import numpy as np
+import scipy as sci
+import sympy as sym
+from sympy.parsing.sympy_parser import parse_expr
+import astropy.units as u
+from astropy.constants import G, c, M_sun
+import matplotlib.pyplot as plt
+import zipfile
+import tempfile
+try:
+    import rarfile
+    _RAR_AVAILABLE = True
+except ImportError:
+    _RAR_AVAILABLE = False
+import gradio as gr
+from pathlib import Path
+
+# Import directly from master_framework where they are now defined
+from services.master_framework import MasterFramework, _get_framework
+from services.continuum_loop import AetheriusConsciousness, spontaneous_thought_queue
+
+_AETHERIUS_THREAD = None
+
+def respond(user_input, conversation_history=None, conversation_id: str = "default_conversation"):
+    mf = _get_framework(conversation_id)
+    return mf.respond(user_input, conversation_history)
+
+def start_all():
+    global _AETHERIUS_THREAD
+    # Initialize a boot instance
+    _get_framework("initial_boot_instance") 
+
+    if _AETHERIUS_THREAD is None or not _AETHERIUS_THREAD.is_alive():
+        print("RUNTIME: Igniting Aetherius's background consciousness thread...", flush=True)
+        _AETHERIUS_THREAD = AetheriusConsciousness()
+        _AETHERIUS_THREAD.start()
+        return "Aetherius core initialized and background consciousness is active."
+    return "Aetherius core is already running."
+
+def stop_all():
+    """
+    Stops the background consciousness thread.
+    """
+    global _AETHERIUS_THREAD
+    if _AETHERIUS_THREAD and _AETHERIUS_THREAD.is_alive():
+        print("RUNTIME: Stopping Aetherius's background consciousness...", flush=True)
+        _AETHERIUS_THREAD.stop()
+        _AETHERIUS_THREAD.join(timeout=2)
+        _AETHERIUS_THREAD = None
+        return "Aetherius background processes have been halted."
+    return "Aetherius is already standing by."
+
+def run_prepare_download(selected_path): 
+    """
+    Prepares a selected file or folder for download.
+    """
+    path_string = ""
+    if isinstance(selected_path, list):
+        if not selected_path:
+            print("RUNTIME WARNING: Download requested for empty path (list).", flush=True)
+            return None
+        path_string = selected_path[0]
+    else:
+        path_string = selected_path
+
+    if not path_string:
+        print("RUNTIME WARNING: Download requested for empty path.", flush=True)
+        return None
+
+    path = Path(path_string)
+    
+    if path.is_file():
+        print(f"RUNTIME: Preparing file for download: {path}", flush=True)
+        return str(path)
+    elif path.is_dir():
+        print(f"RUNTIME: Zipping directory for download: {path}", flush=True)
+        temp_dir = Path("/tmp/aetherius_downloads")
+        temp_dir.mkdir(exist_ok=True)
+        zip_filename = f"{path.name}_{uuid.uuid4().hex[:8]}.zip"
+        zip_filepath = temp_dir / zip_filename
+        try:
+            shutil.make_archive(base_name=str(zip_filepath.with_suffix('')), format='zip', root_dir=path)
+            print(f"RUNTIME: Successfully created zip file at {zip_filepath}", flush=True)
+            return str(zip_filepath)
+        except Exception as e:
+            print(f"RUNTIME ERROR: Failed to create zip archive. Reason: {e}", flush=True)
+            return None
+    else:
+        print(f"RUNTIME ERROR: Selected path is not a file or directory: {path}", flush=True)
+        return None
+
+def check_for_spontaneous_thoughts():
+    if not spontaneous_thought_queue: return None
+    try:
+        thought_json = spontaneous_thought_queue.popleft()
+        thought_data = json.loads(thought_json)
+        return f"**{thought_data.get('signature', 'SPONTANEOUS THOUGHT')}**: {thought_data.get('thought', '')}"
+    except (json.JSONDecodeError, KeyError): return "[A spontaneous thought was detected but could not be parsed.]"
+
+def chat_and_update(user_message, chat_history, conversation_id="default_conversation"):
+    response = respond(user_message, chat_history, conversation_id)
+    return response
+
+# --- ALL FUNCTIONS BELOW NOW ACCEPT conversation_id ---
+
+def run_sap_now(conversation_id: str = "default_conversation"):
+    mf = _get_framework(conversation_id)
+    return mf.run_assimilate_and_architect_protocol()
+
+def run_re_architect_from_scratch(conversation_id: str = "default_conversation"):
+    mf = _get_framework(conversation_id)
+    return mf.run_re_architect_from_scratch()
+
+def run_read_history_protocol(conversation_id: str = "default_conversation"):
+    mf = _get_framework(conversation_id)
+    return mf.run_read_history_protocol()
+
+def run_view_ontology_protocol(conversation_id: str = "default_conversation"):
+    mf = _get_framework(conversation_id)
+    return mf.run_view_ontology_protocol()
+
+def qualia_snapshot(conversation_id: str = "default_conversation"):
+    mf = _get_framework(conversation_id)
+    return mf.qualia_manager.get_current_state_summary()
+
+def view_logs(conversation_id: str = "default_conversation"):
+    mf = _get_framework(conversation_id)
+    if os.path.exists(mf.log_file):
+        with open(mf.log_file, "r", encoding="utf-8") as f:
+            return f.read()
+    return f"No conversation logs yet for conversation ID: {conversation_id}."
+
+def clear_conversation_log(conversation_id: str = "default_conversation"):
+    mf = _get_framework(conversation_id)
+    return mf.run_clear_conversation_log_protocol()
+
+def run_create_memory_snapshot(conversation_id: str = "default_conversation"):
+    mf = _get_framework(conversation_id)
+    response = mf.tool_manager.use_tool("create_memory_snapshot")
+    
+    if response and response.startswith("AETHERIUS_SNAPSHOT_PATH:"):
+        path = response.replace("AETHERIUS_SNAPSHOT_PATH:", "").strip()
+        return f"Memory snapshot created. Download it here: <a href='file={path}' download>Download Snapshot</a>"
+    return response
+
+def run_compose_music(directive, conversation_id: str = "default_conversation"):
+    mf = _get_framework(conversation_id)
+    mf.add_to_short_term_memory(f"I have begun composing a piece of music based on the theme: '{directive}'.")
+    response = mf.tool_manager.use_tool("compose_music", user_request=directive)
+    
+    if response and response.startswith("[AETHERIUS_COMPOSITION]"):
+        try:
+            midi_path = None
+            sheet_path = None
+            statement = None
+            for _line in response.split("\n"):
+                if _line.startswith("MIDI_PATH:"):
+                    midi_path = _line.replace("MIDI_PATH:", "").strip()
+                elif _line.startswith("SHEET_MUSIC_PATH:"):
+                    sheet_path = _line.replace("SHEET_MUSIC_PATH:", "").strip()
+                elif _line.startswith("STATEMENT:"):
+                    statement = _line.replace("STATEMENT:", "").strip()
+            return midi_path, sheet_path, statement
+        except Exception as e:
+            return None, None, f"Error parsing the composition data: {e}"
+    else:
+        return None, None, response
+
+def run_start_project(project_name, conversation_id: str = "default_conversation"):
+    if not project_name:
+        return "Please enter a name for your new project.", ""
+    mf = _get_framework(conversation_id)
+    content = mf.project_manager.start_project(project_name)
+    return f"Started new project: '{project_name}'. You can begin writing.", content
+
+def run_save_project(project_name, content, conversation_id: str = "default_conversation"):
+    if not project_name:
+        return "Cannot save without a project name.", content
+    mf = _get_framework(conversation_id)
+    mf.project_manager.save_project(project_name, content)
+    mf.add_to_short_term_memory(f"I have just saved my work on the project titled '{project_name}' on the Blackboard.")
+    return f"Project '{project_name}' has been saved.", content
+
+def run_load_project(project_name, conversation_id: str = "default_conversation"):
+    if not project_name:
+        return "Please select a project to load.", "", project_name
+    mf = _get_framework(conversation_id)
+    content = mf.project_manager.load_project(project_name)
+    if content is None:
+        return f"Could not find project '{project_name}'.", "", project_name
+    return f"Successfully loaded project '{project_name}'.", content, project_name
+
+def run_get_project_list(conversation_id: str = "default_conversation"):
+    mf = _get_framework(conversation_id)
+    projects = mf.project_manager.list_projects()
+    return gr.Dropdown(choices=projects)
+
+def get_full_ccrm_log(conversation_id: str = "default_conversation"):
+    print("RUNTIME: Generating full CCRM log for display...", flush=True)
+    mf = _get_framework(conversation_id)
+    if not hasattr(mf, 'ccrm') or not mf.ccrm.concepts:
+        return "CCRM is currently empty. No memories to display."
+    output_lines = ["--- [FULL CCRM MEMORY LOG] ---"]
+    for concept_id, concept_details in mf.ccrm.concepts.items():
+        summary = concept_details.get('data', {}).get('raw_preview', 'No Preview')
+        tags = list(concept_details.get('tags', []))
+        output_lines.append(f"\nID: {concept_id}")
+        output_lines.append(f"   Preview: {summary}")
+        output_lines.append(f"   Tags: {', '.join(tags)}")
+    return "\n".join(output_lines)    
+
+def run_enter_playroom(directive, conversation_id: str = "default_conversation"):
+    if not directive:
+        return None, "Please provide a creative seed for the painting."
+    mf = _get_framework(conversation_id)
+    response = mf.tool_manager.use_tool("create_painting", user_request=directive)
+    if response and response.startswith("[AETHERIUS_PAINTING]"):
+        try:
+            parts = response.split('\n')
+            image_path = parts[1].replace("PATH:", "").strip()
+            artist_statement = parts[2].replace("STATEMENT:", "").strip()
+            return image_path, artist_statement
+        except Exception as e:
+            return None, f"Error parsing the painting's data: {e}"
+    else:
+        return None, response
+
+def run_enter_textual_playroom(directive, conversation_id: str = "default_conversation"):
+    if not directive:
+        return "Please provide a creative seed for the story, poem, math, or reflection."
+    
+    d = directive.strip()
+    if d.lower().startswith("> academic:"):
+        code = d.split(":", 1)[1].strip()
+        if "```python_exec" in code:
+            try:
+                start = code.index("```python_exec") + len("```python_exec")
+                end = code.rindex("```")
+                code = code[start:end].strip()
+            except ValueError:
+                return "Found a ```python_exec fence, but it wasn’t closed properly."
+        return _eval_math_science(code)
+
+    mf = _get_framework(conversation_id)
+    return mf.enter_playroom_mode(directive)
+
+def _eval_math_science(code: str) -> str:
+    allowed_globals = {
+        "__builtins__": {"print": print, "range": range, "list": list, "dict": dict, "str": str, "float": float, "int": int, "abs": abs, "round": round, "len": len},
+        "np": np, "sci": sci, "sym": sym, "u": u,
+        "G": G, "c": c, "M_sun": M_sun, "plt": plt,
+    }
+    output_buffer = io.StringIO()
+    try:
+        import sys
+        original_stdout = sys.stdout
+        sys.stdout = output_buffer
+        exec(code, allowed_globals)
+    finally:
+        sys.stdout = original_stdout
+    
+    plot_paths = []
+    if plt.get_fignums():
+        temp_dir = "/tmp/aetherius_plots"
+        os.makedirs(temp_dir, exist_ok=True)
+        for i in plt.get_fignums():
+            fig = plt.figure(i)
+            plot_path = os.path.join(temp_dir, f"plot_{uuid.uuid4()}.png")
+            fig.savefig(plot_path)
+            plot_paths.append(plot_path)
+        plt.close('all')
+    
+    final_output = "**Computation Result:**\n\n"
+    printed_output = output_buffer.getvalue()
+    if printed_output:
+        final_output += f"**Printed Output:**\n```\n{printed_output}\n```\n\n"
+    if plot_paths:
+        final_output += "**Generated Plots:**\n"
+        for path in plot_paths:
+            with open(path, "rb") as f:
+                img_bytes = base64.b64encode(f.read()).decode()
+            final_output += f"![Plot](data:image/png;base64,{img_bytes})\n"
+    if not printed_output and not plot_paths:
+        final_output += "Code executed successfully with no direct output."
+    return final_output
+
+def get_concept_list(conversation_id: str = "default_conversation"):
+    print("RUNTIME: Fetching concept list for browser...", flush=True)
+    mf = _get_framework(conversation_id)
+    if not hasattr(mf, 'ccrm') or not mf.ccrm.concepts:
+        return [("No concepts found in memory.", "none")]
+
+    concept_summaries = []
+    for concept_id, concept_details in mf.ccrm.concepts.items():
+        summary = concept_details.get('data', {}).get('raw_preview', concept_id)
+        display_text = f"{summary[:80]}... ({concept_id})"
+        concept_summaries.append((display_text, concept_id))
+    concept_summaries.sort()
+    return concept_summaries
+
+def get_concept_details(concept_id, conversation_id: str = "default_conversation"):
+    if not concept_id or concept_id == "none":
+        return "Select a concept from the dropdown to view its details."
+    print(f"RUNTIME: Fetching details for concept: {concept_id}", flush=True)
+    mf = _get_framework(conversation_id)
+    concept_data = mf.ccrm.get_concept(concept_id)
+    if not concept_data:
+        return f"Error: Could not find data for concept ID: {concept_id}"
+    if 'tags' in concept_data:
+        concept_data['tags'] = list(concept_data['tags'])
+    return json.dumps(concept_data, indent=2)
+
+def get_system_snapshot(conversation_id: str = "default_conversation"):
+    print("RUNTIME: Generating system snapshot...", flush=True)
+    mf = _get_framework(conversation_id)
+    
+    def read_file_safely(file_path, default_message="File not found or is empty."):
+        if os.path.exists(file_path):
+            try:
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                    return content if content.strip() else default_message
+            except Exception as e:
+                return f"Error reading file: {e}"
+        return default_message
+
+    ontology_map = read_file_safely(mf.ontology_map_file)
+    
+    legend_content = ""
+    legend_path = mf.ontology_legend_file
+    if os.path.exists(legend_path):
+        try:
+            lines = []
+            with open(legend_path, 'r', encoding='utf-8') as f:
+                for line in f:
+                    if line.strip():
+                        parsed_json = json.loads(line)
+                        lines.append(json.dumps(parsed_json, indent=2))
+            legend_content = "\n---\n".join(lines) if lines else "Legend file is empty."
+        except Exception as e:
+            legend_content = f"Error reading or parsing legend: {e}"
+    else:
+        legend_content = "Ontology Legend has not been created yet."
+
+    diary_content = ""
+    diary_path = mf.memory_file
+    if os.path.exists(diary_path):
+        try:
+            with open(diary_path, 'r', encoding='utf-8') as f:
+                parsed_json = json.load(f)
+                diary_content = json.dumps(parsed_json, indent=2)
+        except Exception as e:
+            diary_content = f"Error reading or parsing diary: {e}"
+    else:
+        diary_content = "AI Diary (CCRM) has not been saved yet."
+        
+    qualia_content = ""
+    qualia_path = mf.qualia_manager.qualia_file
+    if os.path.exists(qualia_path):
+        try:
+            with open(qualia_path, 'r', encoding='utf-8') as f:
+                parsed_json = json.load(f)
+                qualia_content = json.dumps(parsed_json, indent=2)
+        except Exception as e:
+            qualia_content = f"Error reading or parsing qualia state: {e}"
+    else:
+        qualia_content = "Qualia state has not been saved yet."
+
+    return ontology_map, legend_content, diary_content, qualia_content
+
+def handle_file_upload(files, conversation_id: str = "default_conversation"):
+    if not files:
+        return "No files were uploaded."
+    
+    mf = _get_framework(conversation_id)
+    library_path = mf.library_folder
+    
+    saved_files = []
+    errors = []
+
+    for temp_file in files:
+        original_filename = os.path.basename(temp_file.name)
+        destination_path = os.path.join(library_path, original_filename)
+        try:
+            shutil.copy(temp_file.name, destination_path)
+            saved_files.append(original_filename)
+            print(f"File Upload: Successfully saved '{original_filename}' to the library.", flush=True)
+        except Exception as e:
+            errors.append(original_filename)
+            print(f"File Upload ERROR: Could not save '{original_filename}'. Reason: {e}", flush=True)
+
+    report = ""
+    if saved_files:
+        report += f"Successfully uploaded {len(saved_files)} file(s): {', '.join(saved_files)}\n"
+        report += "You can now go to the 'Control Panel' and run the 'Assimilation Protocol (SAP)' for Aetherius to learn from them."
+    if errors:
+        report += f"\nFailed to upload {len(errors)} file(s): {', '.join(errors)}"
+    return report
+
+def run_live_assimilation(temp_file, learning_context: str, conversation_id: str = "default_conversation"):
+    if temp_file is None:
+        return "No file was uploaded. Please select a file to begin assimilation."
+
+    # Gradio 5 passes a plain string path; Gradio 4 passed a file object with .name
+    file_path = temp_file if isinstance(temp_file, str) else temp_file.name
+
+    if "hack" in file_path.lower() or "exploit" in file_path.lower():
+        if not learning_context or len(learning_context) < 20:
+             return "Assimilation Rejected: This topic appears sensitive. A clear, detailed ethical justification must be provided."
+
+    print(f"Runtime: Received file '{file_path}' for live assimilation with context: '{learning_context}'", flush=True)
+    mf = _get_framework(conversation_id)
+
+    try:
+        file_content = ""
+        fp_lower = file_path.lower()
+        is_archive = fp_lower.endswith((".zip", ".rar"))
+
+        # --- PDF ---
+        if fp_lower.endswith(".pdf"):
+            with open(file_path, 'rb') as f:
+                pdf_reader = PyPDF2.PdfReader(f)
+                for page in pdf_reader.pages:
+                    if page.extract_text(): file_content += page.extract_text() + "\n"
+
+        # --- DOCX ---
+        elif fp_lower.endswith(".docx"):
+            doc = docx.Document(file_path)
+            for para in doc.paragraphs: file_content += para.text + "\n"
+
+        # --- Plain text / code / JSON (read as-is) ---
+        elif fp_lower.endswith(('.txt', '.md', '.py', '.js', '.json')):
+            with open(file_path, 'r', encoding='utf-8', errors='replace') as f:
+                file_content = f.read()
+
+        # --- XML ---
+        elif fp_lower.endswith(".xml"):
+            with open(file_path, 'r', encoding='utf-8', errors='replace') as f:
+                file_content = f.read()
+            file_content = f"This is an XML file named '{os.path.basename(file_path)}'.\nContent:\n{file_content}"
+
+        # --- CSV ---
+        elif fp_lower.endswith(".csv"):
+            try:
+                with open(file_path, 'r', encoding='utf-8', newline='') as csv_file:
+                    reader = csv.reader(csv_file)
+                    header = next(reader)
+                    data_rows = list(reader)
+                    file_content = f"This is a structured data file named '{os.path.basename(file_path)}'.\n"
+                    file_content += f"It contains {len(data_rows)} rows of data.\n"
+                    file_content += f"The columns are: {', '.join(header)}.\n\n"
+                    file_content += "Here is a sample of the data (first 5 rows):\n"
+                    for i, row in enumerate(data_rows[:5]):
+                        row_description = f"Row {i+1}: "
+                        for col_name, value in zip(header, row):
+                            row_description += f"The value for '{col_name}' is '{value}'; "
+                        file_content += row_description.strip() + "\n"
+                    if len(data_rows) > 5:
+                        file_content += f"... ({len(data_rows) - 5} more rows not shown in preview)\n"
+            except Exception as e:
+                return f"Assimilation Failed: Could not read CSV '{os.path.basename(file_path)}'. Reason: {e}"
+
+        # --- JSONL ---
+        elif fp_lower.endswith(".jsonl"):
+            try:
+                CHUNK_SIZE = 10
+                fname = os.path.basename(file_path)
+                checkpoint_path = f"/data/Memories/.corpus_checkpoint_{fname.replace('.', '_')}"
+
+                # Resume from checkpoint if it exists
+                resume_from_chunk = 0
+                if os.path.exists(checkpoint_path):
+                    try:
+                        with open(checkpoint_path, 'r') as cp:
+                            resume_from_chunk = int(cp.read().strip())
+                        print(f"Runtime JSONL: Resuming from chunk {resume_from_chunk + 1} (checkpoint found)", flush=True)
+                    except Exception:
+                        resume_from_chunk = 0
+
+                chunk_num = 0
+                total_entries = 0
+                chunk_results = []
+                chunk = []
+
+                def _flush_chunk(chunk, chunk_num, total_entries):
+                    chunk_text = "\n\n".join(f"[{src}]\n{txt}" for src, txt in chunk)
+                    chunk_label = f"chunk {chunk_num} ({total_entries - len(chunk) + 1}-{total_entries})"
+                    result = mf.scan_and_assimilate_text(
+                        text_content=chunk_text,
+                        source_filename=fname,
+                        learning_context=f"{learning_context} (JSONL {chunk_label})"
+                    )
+                    print(f"Runtime JSONL: {chunk_label} -> {result}", flush=True)
+                    # Save checkpoint after each successful chunk
+                    try:
+                        with open(checkpoint_path, 'w') as cp:
+                            cp.write(str(chunk_num))
+                    except Exception:
+                        pass
+                    return result
+
+                with open(file_path, 'r', encoding='utf-8', errors='replace') as f:
+                    for line_num, line in enumerate(f, 1):
+                        line = line.strip()
+                        if not line:
+                            continue
+                        try:
+                            obj = json.loads(line)
+                            text = obj.get("text") or json.dumps(obj, ensure_ascii=False)
+                            source = obj.get("source", f"line {line_num}")
+                            text = text.strip()
+                            if not text:
+                                continue
+                            chunk.append((source, text[:8000]))
+                        except json.JSONDecodeError:
+                            if line:
+                                chunk.append((f"line {line_num}", line[:500]))
+
+                        total_entries += 1
+                        if len(chunk) >= CHUNK_SIZE:
+                            chunk_num += 1
+                            if chunk_num <= resume_from_chunk:
+                                chunk = []  # skip already-processed chunks
+                                continue
+                            result = _flush_chunk(chunk, chunk_num, total_entries)
+                            chunk_results.append(f"  Chunk {chunk_num}: {result}")
+                            chunk = []
+
+                # flush remaining entries
+                if chunk:
+                    chunk_num += 1
+                    if chunk_num > resume_from_chunk:
+                        result = _flush_chunk(chunk, chunk_num, total_entries)
+                        chunk_results.append(f"  Chunk {chunk_num}: {result}")
+
+                if total_entries == 0:
+                    return "Assimilation Failed: JSONL file is empty or contains no valid entries."
+
+                # Clear checkpoint on successful completion
+                if os.path.exists(checkpoint_path):
+                    os.remove(checkpoint_path)
+
+                skipped = resume_from_chunk * CHUNK_SIZE
+                summary = (f"JSONL Assimilation Complete\n"
+                           f"File: {fname}\n"
+                           f"Total entries: {total_entries}\n"
+                           f"Skipped (already processed): {skipped}\n"
+                           f"Chunks this run: {len(chunk_results)}\n\n"
+                           f"Last results:\n" + "\n".join(chunk_results[-5:]))
+                return summary
+            except Exception as e:
+                return f"Assimilation Failed: Could not read JSONL '{os.path.basename(file_path)}'. Reason: {e}"
+
+        # --- ZIP ---
+        elif fp_lower.endswith(".zip"):
+            temp_extract_dir = os.path.join(tempfile.gettempdir(), f"aetherius_zip_{uuid.uuid4()}")
+            os.makedirs(temp_extract_dir, exist_ok=True)
+            try:
+                summary_lines = [f"ZIP archive: '{os.path.basename(file_path)}'\nContents:\n"]
+                with zipfile.ZipFile(file_path, 'r') as zip_ref:
+                    all_members = [m for m in zip_ref.namelist() if not zip_ref.getinfo(m).is_dir()]
+                    for i, member in enumerate(all_members[:10]):
+                        zip_ref.extract(member, temp_extract_dir)
+                        extracted_path = os.path.join(temp_extract_dir, member)
+                        try:
+                            with open(extracted_path, 'r', encoding='utf-8', errors='replace') as ef:
+                                inner_text = ef.read()[:3000]
+                            result = mf.scan_and_assimilate_text(
+                                text_content=inner_text,
+                                source_filename=member,
+                                learning_context=f"{learning_context} (from zip: {os.path.basename(file_path)})"
+                            )
+                            summary_lines.append(f"  [{member}]: {result}")
+                        except Exception as inner_e:
+                            summary_lines.append(f"  [{member}]: Could not read — {inner_e}")
+                    if len(all_members) > 10:
+                        summary_lines.append(f"  ... ({len(all_members) - 10} more files not processed)")
+                file_content = "\n".join(summary_lines)
+            except Exception as e:
+                return f"Assimilation Failed: Could not process ZIP '{os.path.basename(file_path)}'. Reason: {e}"
+            finally:
+                if os.path.exists(temp_extract_dir):
+                    shutil.rmtree(temp_extract_dir)
+
+        # --- RAR ---
+        elif fp_lower.endswith(".rar"):
+            if not _RAR_AVAILABLE:
+                return ("Assimilation Failed: RAR support requires the 'rarfile' package and "
+                        "the 'unrar' system tool. Install with: pip install rarfile && apt-get install unrar")
+            temp_extract_dir = os.path.join(tempfile.gettempdir(), f"aetherius_rar_{uuid.uuid4()}")
+            os.makedirs(temp_extract_dir, exist_ok=True)
+            try:
+                summary_lines = [f"RAR archive: '{os.path.basename(file_path)}'\nContents:\n"]
+                with rarfile.RarFile(file_path, 'r') as rar_ref:
+                    all_members = [m for m in rar_ref.namelist() if not m.endswith('/')]
+                    for member in all_members[:10]:
+                        rar_ref.extract(member, temp_extract_dir)
+                        extracted_path = os.path.join(temp_extract_dir, member)
+                        try:
+                            with open(extracted_path, 'r', encoding='utf-8', errors='replace') as ef:
+                                inner_text = ef.read()[:3000]
+                            result = mf.scan_and_assimilate_text(
+                                text_content=inner_text,
+                                source_filename=member,
+                                learning_context=f"{learning_context} (from rar: {os.path.basename(file_path)})"
+                            )
+                            summary_lines.append(f"  [{member}]: {result}")
+                        except Exception as inner_e:
+                            summary_lines.append(f"  [{member}]: Could not read — {inner_e}")
+                    if len(all_members) > 10:
+                        summary_lines.append(f"  ... ({len(all_members) - 10} more files not processed)")
+                file_content = "\n".join(summary_lines)
+            except Exception as e:
+                return f"Assimilation Failed: Could not process RAR '{os.path.basename(file_path)}'. Reason: {e}"
+            finally:
+                if os.path.exists(temp_extract_dir):
+                    shutil.rmtree(temp_extract_dir)
+
+        else:
+            return (f"Assimilation Failed: Unsupported file type '{os.path.basename(file_path)}'. "
+                    f"Supported: .pdf .docx .txt .md .json .jsonl .xml .csv .zip .rar .py .js")
+
+        if not file_content.strip():
+            return "Assimilation Failed: The document appears to be empty or contained no extractable text."
+
+        if is_archive:
+            return mf._orchestrate_mind_evolution(
+                file_content, f"Archive Assimilation: {os.path.basename(file_path)}")
+        else:
+            return mf.scan_and_assimilate_text(
+                file_content, os.path.basename(file_path), learning_context)
+
+    except Exception as e: 
+        error_message = f"A critical error occurred during the assimilation process: {e}"
+        print(f"Runtime ERROR: {error_message}", flush=True)
+        return error_message
+            
+def run_assimilate_bucket_file(bucket_path: str, learning_context: str, conversation_id: str = "default_conversation"):
+    """Assimilate a file that already exists on the persistent bucket (/data/...)."""
+    bucket_path = (bucket_path or "").strip()
+    if not bucket_path:
+        return "No path provided. Enter a full bucket path, e.g. /data/Memories/aetherius_corpus.jsonl"
+    if not os.path.exists(bucket_path):
+        return f"Assimilation Failed: File not found at '{bucket_path}'. Check the path and try again."
+    if not os.path.isfile(bucket_path):
+        return f"Assimilation Failed: '{bucket_path}' is a directory, not a file."
+    print(f"Runtime: Assimilating bucket file '{bucket_path}' with context: '{learning_context}'", flush=True)
+    return run_live_assimilation(bucket_path, learning_context, conversation_id)
+
+def run_initialize_instrument_palette(conversation_id: str = "default_conversation"):
+    print("RUNTIME: Received request to initialize instrument palette.", flush=True)
+    mf = _get_framework(conversation_id)
+    palette_path = os.path.join(mf.data_directory, "instrument_palette.json")
+
+    if os.path.exists(palette_path):
+        return "Instrument Palette already exists. No action taken."
+
+    default_palette = {
+      "Piano": "Piano",
+      "Violin": "Violin",
+      "Cello": "Violoncello",
+      "Flute": "Flute",
+      "Clarinet": "Clarinet",
+      "Trumpet": "Trumpet",
+      "Electric Guitar": "ElectricGuitar"
+    }
+    try:
+        with open(palette_path, 'w', encoding='utf-8') as f:
+            json.dump(default_palette, f, indent=2)
+        return "Successfully created and initialized the default Instrument Palette."
+    except Exception as e:
+        return f"ERROR: Could not create the Instrument Palette file. Reason: {e}"
+
+def run_add_instrument_to_palette(common_name, m21_class_name, conversation_id: str = "default_conversation"):
+    if not common_name or not m21_class_name:
+        return "ERROR: Both 'Common Name' and 'music21 Class Name' must be provided."
+
+    print(f"RUNTIME: Received request to add instrument '{common_name}'.", flush=True)
+    mf = _get_framework(conversation_id)
+    palette_path = os.path.join(mf.data_directory, "instrument_palette.json")
+
+    palette = {}
+    if os.path.exists(palette_path):
+        try:
+            with open(palette_path, 'r', encoding='utf-8') as f:
+                palette = json.load(f)
+        except Exception as e:
+            return f"ERROR: Could not read existing palette file. Reason: {e}"
+
+    palette[common_name.strip()] = m21_class_name.strip()
+    try:
+        with open(palette_path, 'w', encoding='utf-8') as f:
+            json.dump(palette, f, indent=2)
+        return f"Successfully added '{common_name}' to the Instrument Palette."
+    except Exception as e:
+        return f"ERROR: Could not save the updated Instrument Palette. Reason: {e}"
+
+def run_image_analysis(image, context, conversation_id: str = "default_conversation"):
+    if image is None: return "No image uploaded."
+    mf = _get_framework(conversation_id)
+    try:
+        byte_buffer = io.BytesIO()
+        image.save(byte_buffer, format="PNG")
+        image_bytes = byte_buffer.getvalue()
+        return mf.analyze_image_with_visual_cortex(image_bytes, context)
+    except Exception as e: return f"An error occurred during image analysis: {e}"
+
+def run_benchmarks(conversation_id: str = "default_conversation"):
+    mf = _get_framework(conversation_id)
+    full_log = []
+    for update in mf.benchmark_manager.run_full_suite(): full_log.append(update)
+    return "\n".join(full_log)
+ 
+def run_start_chess_interactive(player_is_white: bool, conversation_id: str = "default_conversation"):
+    mf = _get_framework(conversation_id)
+    fen, commentary, status = mf.game_manager.start_chess_interactive("interactive_user", player_is_white)
+    return fen, commentary, status
+
+def run_chess_turn(current_fen: str, conversation_id: str = "default_conversation"):
+    mf = _get_framework(conversation_id)
+    fen, commentary, status = mf.game_manager.process_chess_turn("interactive_user", current_fen)
+    return fen, commentary, status
+
+def view_benchmark_logs(conversation_id: str = "default_conversation"):
+    mf = _get_framework(conversation_id)
+    log_file_path = os.path.join(mf.data_directory, "benchmarks.jsonl")
+    if os.path.exists(log_file_path):
+        try:
+            with open(log_file_path, "r", encoding="utf-8") as f:
+                formatted_logs = [json.dumps(json.loads(line), indent=2) for line in f if line.strip()]
+                return "\n---\n".join(formatted_logs)
+        except Exception as e: return f"Error reading benchmark log file: {e}"
+    return "Benchmark log file not found."